mono/mini/debugger-agent.c

   1 /**
   2  * \file
   3  * Soft Debugger back-end module
   4  *
   5  * Author:
   6  *   Zoltan Varga (vargaz@gmail.com)
   7  *
   8  * Copyright 2009-2010 Novell, Inc.
   9  * Copyright 2011 Xamarin Inc.
  10  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  11  */
  12
  13 #include <config.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #ifdef HAVE_SYS_TYPES_H
  18 #include <sys/types.h>
  19 #endif
  20 #ifdef HAVE_SYS_SELECT_H
  21 #include <sys/select.h>
  22 #endif
  23 #ifdef HAVE_SYS_SOCKET_H
  24 #include <sys/socket.h>
  25 #endif
  26 #ifdef HAVE_NETINET_TCP_H
  27 #include <netinet/tcp.h>
  28 #endif
  29 #ifdef HAVE_NETINET_IN_H
  30 #include <netinet/in.h>
  31 #endif
  32 #ifdef HAVE_UNISTD_H
  33 #include <unistd.h>
  34 #endif
  35 #include <errno.h>
  36 #include <glib.h>
  37
  38 #ifdef HAVE_PTHREAD_H
  39 #include <pthread.h>
  40 #endif
  41
  42 #ifdef HOST_WIN32
  43 #ifdef _MSC_VER
  44 #include <winsock2.h>
  45 #include <process.h>
  46 #endif
  47 #include <ws2tcpip.h>
  48 #endif
  49
  50 #ifdef HOST_ANDROID
  51 #include <linux/in.h>
  52 #include <linux/tcp.h>
  53 #include <sys/endian.h>
  54 #endif
  55
  56 #include <mono/metadata/mono-debug.h>
  57 #include <mono/metadata/debug-internals.h>
  58 #include <mono/metadata/gc-internals.h>
  59 #include <mono/metadata/environment.h>
  60 #include <mono/metadata/threads-types.h>
  61 #include <mono/metadata/threadpool.h>
  62 #include <mono/metadata/assembly.h>
  63 #include <mono/metadata/runtime.h>
  64 #include <mono/metadata/verify-internals.h>
  65 #include <mono/metadata/reflection-internals.h>
  66 #include <mono/metadata/w32socket.h>
  67 #include <mono/utils/mono-coop-mutex.h>
  68 #include <mono/utils/mono-coop-semaphore.h>
  69 #include <mono/utils/mono-error-internals.h>
  70 #include <mono/utils/mono-stack-unwinding.h>
  71 #include <mono/utils/mono-time.h>
  72 #include <mono/utils/mono-threads.h>
  73 #include <mono/utils/networking.h>
  74 #include <mono/utils/mono-proclib.h>
  75 #include <mono/utils/w32api.h>
  76 #include "debugger-agent.h"
  77 #include "mini.h"
  78 #include "seq-points.h"
  79 #include "interp/interp.h"
  80
  81 /*
  82  * On iOS we can't use System.Environment.Exit () as it will do the wrong
  83  * shutdown sequence.
  84 */
  85 #if !defined (TARGET_IOS)
  86 #define TRY_MANAGED_SYSTEM_ENVIRONMENT_EXIT
  87 #endif
  88
  89
  90 #ifndef MONO_ARCH_SOFT_DEBUG_SUPPORTED
  91 #define DISABLE_DEBUGGER_AGENT 1
  92 #endif
  93
  94 #ifdef DISABLE_SOFT_DEBUG
  95 #define DISABLE_DEBUGGER_AGENT 1
  96 #endif
  97
  98 #ifndef DISABLE_DEBUGGER_AGENT
  99
 100 #include <mono/utils/mono-os-mutex.h>
 101
 102 #define THREAD_TO_INTERNAL(thread) (thread)->internal_thread
 103
 104 typedef struct {
 105         gboolean enabled;
 106         char *transport;
 107         char *address;
 108         int log_level;
 109         char *log_file;
 110         gboolean suspend;
 111         gboolean server;
 112         gboolean onuncaught;
 113         GSList *onthrow;
 114         int timeout;
 115         char *launch;
 116         gboolean embedding;
 117         gboolean defer;
 118         int keepalive;
 119         gboolean setpgid;
 120 } AgentConfig;
 121
 122 typedef struct
 123 {
 124         int id;
 125         guint32 il_offset, native_offset;
 126         MonoDomain *domain;
 127         MonoMethod *method;
 128         /*
 129          * If method is gshared, this is the actual instance, otherwise this is equal to
 130          * method.
 131          */
 132         MonoMethod *actual_method;
 133         /*
 134          * This is the method which is visible to debugger clients. Same as method,
 135          * except for native-to-managed wrappers.
 136          */
 137         MonoMethod *api_method;
 138         MonoContext ctx;
 139         MonoDebugMethodJitInfo *jit;
 140         MonoJitInfo *ji;
 141         MonoInterpFrameHandle interp_frame;
 142         int flags;
 143         mgreg_t *reg_locations [MONO_MAX_IREGS];
 144         /*
 145          * Whenever ctx is set. This is FALSE for the last frame of running threads, since
 146          * the frame can become invalid.
 147          */
 148         gboolean has_ctx;
 149 } StackFrame;
 150
 151 typedef struct _InvokeData InvokeData;
 152
 153 struct _InvokeData
 154 {
 155         int id;
 156         int flags;
 157         guint8 *p;
 158         guint8 *endp;
 159         /* This is the context which needs to be restored after the invoke */
 160         MonoContext ctx;
 161         gboolean has_ctx;
 162         /*
 163          * If this is set, invoke this method with the arguments given by ARGS.
 164          */
 165         MonoMethod *method;
 166         gpointer *args;
 167         guint32 suspend_count;
 168         int nmethods;
 169
 170         InvokeData *last_invoke;
 171 };
 172
 173 typedef struct {
 174         MonoThreadUnwindState context;
 175
 176         /* This is computed on demand when it is requested using the wire protocol */
 177         /* It is freed up when the thread is resumed */
 178         int frame_count;
 179         StackFrame **frames;
 180         /*
 181          * Whenever the frame info is up-to-date. If not, compute_frame_info () will need to
 182          * re-compute it.
 183          */
 184         gboolean frames_up_to_date;
 185         /*
 186          * Points to data about a pending invoke which needs to be executed after the thread
 187          * resumes.
 188          */
 189         InvokeData *pending_invoke;
 190         /*
 191          * Set to TRUE if this thread is suspended in suspend_current () or it is executing
 192          * native code.
 193          */
 194         gboolean suspended;
 195         /*
 196          * Signals whenever the thread is in the process of suspending, i.e. it will suspend
 197          * within a finite amount of time.
 198          */
 199         gboolean suspending;
 200         /*
 201          * Set to TRUE if this thread is suspended in suspend_current ().
 202          */
 203         gboolean really_suspended;
 204         /* Used to pass the context to the breakpoint/single step handler */
 205         MonoContext handler_ctx;
 206         /* Whenever thread_stop () was called for this thread */
 207         gboolean terminated;
 208
 209         /* Whenever to disable breakpoints (used during invokes) */
 210         gboolean disable_breakpoints;
 211
 212         /*
 213          * Number of times this thread has been resumed using resume_thread ().
 214          */
 215         guint32 resume_count;
 216
 217         MonoInternalThread *thread;
 218
 219         /*
 220          * Information about the frame which transitioned to native code for running
 221          * threads.
 222          */
 223         StackFrameInfo async_last_frame;
 224
 225         /*
 226          * The context where the stack walk can be started for running threads.
 227          */
 228         MonoThreadUnwindState async_state;
 229
 230         /*
 231      * The context used for filter clauses
 232      */
 233         MonoThreadUnwindState filter_state;
 234
 235         gboolean abort_requested;
 236
 237         /*
 238          * The current mono_runtime_invoke_checked invocation.
 239          */
 240         InvokeData *invoke;
 241
 242         /*
 243          * The context where single stepping should resume while the thread is suspended because
 244          * of an EXCEPTION event.
 245          */
 246         MonoThreadUnwindState catch_state;
 247
 248         /*
 249          * The context which needs to be restored after handling a single step/breakpoint
 250          * event. This is the same as the ctx at step/breakpoint site, but includes changes
 251          * to caller saved registers done by set_var ().
 252          */
 253         MonoThreadUnwindState restore_state;
 254         /* Frames computed from restore_state */
 255         int restore_frame_count;
 256         StackFrame **restore_frames;
 257
 258         /* The currently unloading appdomain */
 259         MonoDomain *domain_unloading;
 260 } DebuggerTlsData;
 261
 262 typedef struct {
 263         const char *name;
 264         void (*connect) (const char *address);
 265         void (*close1) (void);
 266         void (*close2) (void);
 267         gboolean (*send) (void *buf, int len);
 268         int (*recv) (void *buf, int len);
 269 } DebuggerTransport;
 270
 271 /*
 272  * Wire Protocol definitions
 273  */
 274
 275 #define HEADER_LENGTH 11
 276
 277 #define MAJOR_VERSION 2
 278 #define MINOR_VERSION 45
 279
 280 typedef enum {
 281         CMD_SET_VM = 1,
 282         CMD_SET_OBJECT_REF = 9,
 283         CMD_SET_STRING_REF = 10,
 284         CMD_SET_THREAD = 11,
 285         CMD_SET_ARRAY_REF = 13,
 286         CMD_SET_EVENT_REQUEST = 15,
 287         CMD_SET_STACK_FRAME = 16,
 288         CMD_SET_APPDOMAIN = 20,
 289         CMD_SET_ASSEMBLY = 21,
 290         CMD_SET_METHOD = 22,
 291         CMD_SET_TYPE = 23,
 292         CMD_SET_MODULE = 24,
 293         CMD_SET_FIELD = 25,
 294         CMD_SET_EVENT = 64
 295 } CommandSet;
 296
 297 typedef enum {
 298         EVENT_KIND_VM_START = 0,
 299         EVENT_KIND_VM_DEATH = 1,
 300         EVENT_KIND_THREAD_START = 2,
 301         EVENT_KIND_THREAD_DEATH = 3,
 302         EVENT_KIND_APPDOMAIN_CREATE = 4,
 303         EVENT_KIND_APPDOMAIN_UNLOAD = 5,
 304         EVENT_KIND_METHOD_ENTRY = 6,
 305         EVENT_KIND_METHOD_EXIT = 7,
 306         EVENT_KIND_ASSEMBLY_LOAD = 8,
 307         EVENT_KIND_ASSEMBLY_UNLOAD = 9,
 308         EVENT_KIND_BREAKPOINT = 10,
 309         EVENT_KIND_STEP = 11,
 310         EVENT_KIND_TYPE_LOAD = 12,
 311         EVENT_KIND_EXCEPTION = 13,
 312         EVENT_KIND_KEEPALIVE = 14,
 313         EVENT_KIND_USER_BREAK = 15,
 314         EVENT_KIND_USER_LOG = 16
 315 } EventKind;
 316
 317 typedef enum {
 318         SUSPEND_POLICY_NONE = 0,
 319         SUSPEND_POLICY_EVENT_THREAD = 1,
 320         SUSPEND_POLICY_ALL = 2
 321 } SuspendPolicy;
 322
 323 typedef enum {
 324         ERR_NONE = 0,
 325         ERR_INVALID_OBJECT = 20,
 326         ERR_INVALID_FIELDID = 25,
 327         ERR_INVALID_FRAMEID = 30,
 328         ERR_NOT_IMPLEMENTED = 100,
 329         ERR_NOT_SUSPENDED = 101,
 330         ERR_INVALID_ARGUMENT = 102,
 331         ERR_UNLOADED = 103,
 332         ERR_NO_INVOCATION = 104,
 333         ERR_ABSENT_INFORMATION = 105,
 334         ERR_NO_SEQ_POINT_AT_IL_OFFSET = 106,
 335         ERR_INVOKE_ABORTED = 107,
 336         ERR_LOADER_ERROR = 200, /*XXX extend the protocol to pass this information down the pipe */
 337 } ErrorCode;
 338
 339 typedef enum {
 340         MOD_KIND_COUNT = 1,
 341         MOD_KIND_THREAD_ONLY = 3,
 342         MOD_KIND_LOCATION_ONLY = 7,
 343         MOD_KIND_EXCEPTION_ONLY = 8,
 344         MOD_KIND_STEP = 10,
 345         MOD_KIND_ASSEMBLY_ONLY = 11,
 346         MOD_KIND_SOURCE_FILE_ONLY = 12,
 347         MOD_KIND_TYPE_NAME_ONLY = 13,
 348         MOD_KIND_NONE = 14
 349 } ModifierKind;
 350
 351 typedef enum {
 352         STEP_DEPTH_INTO = 0,
 353         STEP_DEPTH_OVER = 1,
 354         STEP_DEPTH_OUT = 2
 355 } StepDepth;
 356
 357 typedef enum {
 358         STEP_SIZE_MIN = 0,
 359         STEP_SIZE_LINE = 1
 360 } StepSize;
 361
 362 typedef enum {
 363         STEP_FILTER_NONE = 0,
 364         STEP_FILTER_STATIC_CTOR = 1,
 365         STEP_FILTER_DEBUGGER_HIDDEN = 2,
 366         STEP_FILTER_DEBUGGER_STEP_THROUGH = 4,
 367         STEP_FILTER_DEBUGGER_NON_USER_CODE = 8
 368 } StepFilter;
 369
 370 typedef enum {
 371         TOKEN_TYPE_STRING = 0,
 372         TOKEN_TYPE_TYPE = 1,
 373         TOKEN_TYPE_FIELD = 2,
 374         TOKEN_TYPE_METHOD = 3,
 375         TOKEN_TYPE_UNKNOWN = 4
 376 } DebuggerTokenType;
 377
 378 typedef enum {
 379         VALUE_TYPE_ID_NULL = 0xf0,
 380         VALUE_TYPE_ID_TYPE = 0xf1,
 381         VALUE_TYPE_ID_PARENT_VTYPE = 0xf2
 382 } ValueTypeId;
 383
 384 typedef enum {
 385         FRAME_FLAG_DEBUGGER_INVOKE = 1,
 386         FRAME_FLAG_NATIVE_TRANSITION = 2
 387 } StackFrameFlags;
 388
 389 typedef enum {
 390         INVOKE_FLAG_DISABLE_BREAKPOINTS = 1,
 391         INVOKE_FLAG_SINGLE_THREADED = 2,
 392         INVOKE_FLAG_RETURN_OUT_THIS = 4,
 393         INVOKE_FLAG_RETURN_OUT_ARGS = 8,
 394         INVOKE_FLAG_VIRTUAL = 16
 395 } InvokeFlags;
 396
 397 typedef enum {
 398         BINDING_FLAGS_IGNORE_CASE = 0x70000000,
 399 } BindingFlagsExtensions;
 400
 401 typedef enum {
 402         CMD_VM_VERSION = 1,
 403         CMD_VM_ALL_THREADS = 2,
 404         CMD_VM_SUSPEND = 3,
 405         CMD_VM_RESUME = 4,
 406         CMD_VM_EXIT = 5,
 407         CMD_VM_DISPOSE = 6,
 408         CMD_VM_INVOKE_METHOD = 7,
 409         CMD_VM_SET_PROTOCOL_VERSION = 8,
 410         CMD_VM_ABORT_INVOKE = 9,
 411         CMD_VM_SET_KEEPALIVE = 10,
 412         CMD_VM_GET_TYPES_FOR_SOURCE_FILE = 11,
 413         CMD_VM_GET_TYPES = 12,
 414         CMD_VM_INVOKE_METHODS = 13,
 415         CMD_VM_START_BUFFERING = 14,
 416         CMD_VM_STOP_BUFFERING = 15
 417 } CmdVM;
 418
 419 typedef enum {
 420         CMD_THREAD_GET_FRAME_INFO = 1,
 421         CMD_THREAD_GET_NAME = 2,
 422         CMD_THREAD_GET_STATE = 3,
 423         CMD_THREAD_GET_INFO = 4,
 424         CMD_THREAD_GET_ID = 5,
 425         CMD_THREAD_GET_TID = 6,
 426         CMD_THREAD_SET_IP = 7
 427 } CmdThread;
 428
 429 typedef enum {
 430         CMD_EVENT_REQUEST_SET = 1,
 431         CMD_EVENT_REQUEST_CLEAR = 2,
 432         CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS = 3
 433 } CmdEvent;
 434
 435 typedef enum {
 436         CMD_COMPOSITE = 100
 437 } CmdComposite;
 438
 439 typedef enum {
 440         CMD_APPDOMAIN_GET_ROOT_DOMAIN = 1,
 441         CMD_APPDOMAIN_GET_FRIENDLY_NAME = 2,
 442         CMD_APPDOMAIN_GET_ASSEMBLIES = 3,
 443         CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY = 4,
 444         CMD_APPDOMAIN_CREATE_STRING = 5,
 445         CMD_APPDOMAIN_GET_CORLIB = 6,
 446         CMD_APPDOMAIN_CREATE_BOXED_VALUE = 7
 447 } CmdAppDomain;
 448
 449 typedef enum {
 450         CMD_ASSEMBLY_GET_LOCATION = 1,
 451         CMD_ASSEMBLY_GET_ENTRY_POINT = 2,
 452         CMD_ASSEMBLY_GET_MANIFEST_MODULE = 3,
 453         CMD_ASSEMBLY_GET_OBJECT = 4,
 454         CMD_ASSEMBLY_GET_TYPE = 5,
 455         CMD_ASSEMBLY_GET_NAME = 6,
 456         CMD_ASSEMBLY_GET_DOMAIN = 7
 457 } CmdAssembly;
 458
 459 typedef enum {
 460         CMD_MODULE_GET_INFO = 1,
 461 } CmdModule;
 462
 463 typedef enum {
 464         CMD_FIELD_GET_INFO = 1,
 465 } CmdField;
 466
 467 typedef enum {
 468         CMD_METHOD_GET_NAME = 1,
 469         CMD_METHOD_GET_DECLARING_TYPE = 2,
 470         CMD_METHOD_GET_DEBUG_INFO = 3,
 471         CMD_METHOD_GET_PARAM_INFO = 4,
 472         CMD_METHOD_GET_LOCALS_INFO = 5,
 473         CMD_METHOD_GET_INFO = 6,
 474         CMD_METHOD_GET_BODY = 7,
 475         CMD_METHOD_RESOLVE_TOKEN = 8,
 476         CMD_METHOD_GET_CATTRS = 9,
 477         CMD_METHOD_MAKE_GENERIC_METHOD = 10
 478 } CmdMethod;
 479
 480 typedef enum {
 481         CMD_TYPE_GET_INFO = 1,
 482         CMD_TYPE_GET_METHODS = 2,
 483         CMD_TYPE_GET_FIELDS = 3,
 484         CMD_TYPE_GET_VALUES = 4,
 485         CMD_TYPE_GET_OBJECT = 5,
 486         CMD_TYPE_GET_SOURCE_FILES = 6,
 487         CMD_TYPE_SET_VALUES = 7,
 488         CMD_TYPE_IS_ASSIGNABLE_FROM = 8,
 489         CMD_TYPE_GET_PROPERTIES = 9,
 490         CMD_TYPE_GET_CATTRS = 10,
 491         CMD_TYPE_GET_FIELD_CATTRS = 11,
 492         CMD_TYPE_GET_PROPERTY_CATTRS = 12,
 493         CMD_TYPE_GET_SOURCE_FILES_2 = 13,
 494         CMD_TYPE_GET_VALUES_2 = 14,
 495         CMD_TYPE_GET_METHODS_BY_NAME_FLAGS = 15,
 496         CMD_TYPE_GET_INTERFACES = 16,
 497         CMD_TYPE_GET_INTERFACE_MAP = 17,
 498         CMD_TYPE_IS_INITIALIZED = 18,
 499         CMD_TYPE_CREATE_INSTANCE = 19
 500 } CmdType;
 501
 502 typedef enum {
 503         CMD_STACK_FRAME_GET_VALUES = 1,
 504         CMD_STACK_FRAME_GET_THIS = 2,
 505         CMD_STACK_FRAME_SET_VALUES = 3,
 506         CMD_STACK_FRAME_GET_DOMAIN = 4,
 507         CMD_STACK_FRAME_SET_THIS = 5,
 508 } CmdStackFrame;
 509
 510 typedef enum {
 511         CMD_ARRAY_REF_GET_LENGTH = 1,
 512         CMD_ARRAY_REF_GET_VALUES = 2,
 513         CMD_ARRAY_REF_SET_VALUES = 3,
 514 } CmdArray;
 515
 516 typedef enum {
 517         CMD_STRING_REF_GET_VALUE = 1,
 518         CMD_STRING_REF_GET_LENGTH = 2,
 519         CMD_STRING_REF_GET_CHARS = 3
 520 } CmdString;
 521
 522 typedef enum {
 523         CMD_OBJECT_REF_GET_TYPE = 1,
 524         CMD_OBJECT_REF_GET_VALUES = 2,
 525         CMD_OBJECT_REF_IS_COLLECTED = 3,
 526         CMD_OBJECT_REF_GET_ADDRESS = 4,
 527         CMD_OBJECT_REF_GET_DOMAIN = 5,
 528         CMD_OBJECT_REF_SET_VALUES = 6,
 529         CMD_OBJECT_REF_GET_INFO = 7,
 530 } CmdObject;
 531
 532 typedef struct {
 533         ModifierKind kind;
 534         union {
 535                 int count; /* For kind == MOD_KIND_COUNT */
 536                 MonoInternalThread *thread; /* For kind == MOD_KIND_THREAD_ONLY */
 537                 MonoClass *exc_class; /* For kind == MONO_KIND_EXCEPTION_ONLY */
 538                 MonoAssembly **assemblies; /* For kind == MONO_KIND_ASSEMBLY_ONLY */
 539                 GHashTable *source_files; /* For kind == MONO_KIND_SOURCE_FILE_ONLY */
 540                 GHashTable *type_names; /* For kind == MONO_KIND_TYPE_NAME_ONLY */
 541                 StepFilter filter; /* For kind == MOD_KIND_STEP */
 542         } data;
 543         gboolean caught, uncaught, subclasses; /* For kind == MOD_KIND_EXCEPTION_ONLY */
 544 } Modifier;
 545
 546 typedef struct{
 547         int id;
 548         int event_kind;
 549         int suspend_policy;
 550         int nmodifiers;
 551         gpointer info;
 552         Modifier modifiers [MONO_ZERO_LEN_ARRAY];
 553 } EventRequest;
 554
 555 /*
 556  * Describes a single step request.
 557  */
 558 typedef struct {
 559         EventRequest *req;
 560         MonoInternalThread *thread;
 561         StepDepth depth;
 562         StepSize size;
 563         StepFilter filter;
 564         gpointer last_sp;
 565         gpointer start_sp;
 566         MonoMethod *start_method;
 567         MonoMethod *last_method;
 568         int last_line;
 569         /* Whenever single stepping is performed using start/stop_single_stepping () */
 570         gboolean global;
 571         /* The list of breakpoints used to implement step-over */
 572         GSList *bps;
 573         /* The number of frames at the start of a step-over */
 574         int nframes;
 575         /* If set, don't stop in methods that are not part of user assemblies */
 576         MonoAssembly** user_assemblies;
 577         /* Used to distinguish stepping breakpoint hits in parallel tasks executions */
 578         int async_id;
 579         /* Used to know if we are in process of async step-out and distishing from exception breakpoints */
 580         MonoMethod* async_stepout_method;
 581 } SingleStepReq;
 582
 583 /*
 584  * Contains additional information for an event
 585  */
 586 typedef struct {
 587         /* For EVENT_KIND_EXCEPTION */
 588         MonoObject *exc;
 589         MonoContext catch_ctx;
 590         gboolean caught;
 591         /* For EVENT_KIND_USER_LOG */
 592         int level;
 593         char *category, *message;
 594         /* For EVENT_KIND_TYPE_LOAD */
 595         MonoClass *klass;
 596 } EventInfo;
 597
 598 typedef struct {
 599         guint8 *buf, *p, *end;
 600 } Buffer;
 601
 602 typedef struct ReplyPacket {
 603         int id;
 604         int error;
 605         Buffer *data;
 606 } ReplyPacket;
 607
 608 #define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; fflush (log_file); } } while (0)
 609
 610 #ifdef HOST_ANDROID
 611 #define DEBUG_PRINTF(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { g_print (__VA_ARGS__); } } while (0)
 612 #else
 613 #define DEBUG_PRINTF(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { fprintf (log_file, __VA_ARGS__); fflush (log_file); } } while (0)
 614 #endif
 615
 616 #ifdef HOST_WIN32
 617 #define get_last_sock_error() WSAGetLastError()
 618 #define MONO_EWOULDBLOCK WSAEWOULDBLOCK
 619 #define MONO_EINTR WSAEINTR
 620 #else
 621 #define get_last_sock_error() errno
 622 #define MONO_EWOULDBLOCK EWOULDBLOCK
 623 #define MONO_EINTR EINTR
 624 #endif
 625
 626 #define CHECK_PROTOCOL_VERSION(major,minor) \
 627         (protocol_version_set && (major_version > (major) || (major_version == (major) && minor_version >= (minor))))
 628
 629 /*
 630  * Globals
 631  */
 632
 633 static AgentConfig agent_config;
 634
 635 /*
 636  * Whenever the agent is fully initialized.
 637  * When using the onuncaught or onthrow options, only some parts of the agent are
 638  * initialized on startup, and the full initialization which includes connection
 639  * establishment and the startup of the agent thread is only done in response to
 640  * an event.
 641  */
 642 static gint32 inited;
 643
 644 #ifndef DISABLE_SOCKET_TRANSPORT
 645 static int conn_fd;
 646 static int listen_fd;
 647 #endif
 648
 649 static int packet_id = 0;
 650
 651 static int objref_id = 0;
 652
 653 static int event_request_id = 0;
 654
 655 static int frame_id = 0;
 656
 657 static GPtrArray *event_requests;
 658
 659 static MonoNativeTlsKey debugger_tls_id;
 660
 661 static gboolean vm_start_event_sent, vm_death_event_sent, disconnected;
 662
 663 /* Maps MonoInternalThread -> DebuggerTlsData */
 664 /* Protected by the loader lock */
 665 static MonoGHashTable *thread_to_tls;
 666
 667 /* Maps tid -> MonoInternalThread */
 668 /* Protected by the loader lock */
 669 static MonoGHashTable *tid_to_thread;
 670
 671 /* Maps tid -> MonoThread (not MonoInternalThread) */
 672 /* Protected by the loader lock */
 673 static MonoGHashTable *tid_to_thread_obj;
 674
 675 static MonoNativeThreadId debugger_thread_id;
 676
 677 static MonoThreadHandle *debugger_thread_handle;
 678
 679 static int log_level;
 680
 681 static gboolean embedding;
 682
 683 static FILE *log_file;
 684
 685 /* Assemblies whose assembly load event has no been sent yet */
 686 /* Protected by the dbg lock */
 687 static GPtrArray *pending_assembly_loads;
 688
 689 /* Whenever the debugger thread has exited */
 690 static gboolean debugger_thread_exited;
 691
 692 /* Cond variable used to wait for debugger_thread_exited becoming true */
 693 static MonoCoopCond debugger_thread_exited_cond;
 694
 695 /* Mutex for the cond var above */
 696 static MonoCoopMutex debugger_thread_exited_mutex;
 697
 698 /* The single step request instance */
 699 static SingleStepReq *ss_req;
 700
 701 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
 702 /* Number of single stepping operations in progress */
 703 static int ss_count;
 704 #endif
 705
 706 /* The protocol version of the client */
 707 static int major_version, minor_version;
 708
 709 /* Whenever the variables above are set by the client */
 710 static gboolean protocol_version_set;
 711
 712 /* A hash table containing all active domains */
 713 /* Protected by the loader lock */
 714 static GHashTable *domains;
 715
 716 /* The number of times the runtime is suspended */
 717 static gint32 suspend_count;
 718
 719 /* Whenever to buffer reply messages and send them together */
 720 static gboolean buffer_replies;
 721
 722 /* Buffered reply packets */
 723 static ReplyPacket reply_packets [128];
 724 int nreply_packets;
 725
 726 #define dbg_lock() mono_coop_mutex_lock (&debug_mutex)
 727 #define dbg_unlock() mono_coop_mutex_unlock (&debug_mutex)
 728 static MonoCoopMutex debug_mutex;
 729
 730 static void transport_init (void);
 731 static void transport_connect (const char *address);
 732 static gboolean transport_handshake (void);
 733 static void register_transport (DebuggerTransport *trans);
 734
 735 static gsize WINAPI debugger_thread (void *arg);
 736
 737 static void runtime_initialized (MonoProfiler *prof);
 738
 739 static void runtime_shutdown (MonoProfiler *prof);
 740
 741 static void thread_startup (MonoProfiler *prof, uintptr_t tid);
 742
 743 static void thread_end (MonoProfiler *prof, uintptr_t tid);
 744
 745 static void appdomain_load (MonoProfiler *prof, MonoDomain *domain);
 746
 747 static void appdomain_start_unload (MonoProfiler *prof, MonoDomain *domain);
 748
 749 static void appdomain_unload (MonoProfiler *prof, MonoDomain *domain);
 750
 751 static void emit_appdomain_load (gpointer key, gpointer value, gpointer user_data);
 752
 753 static void emit_thread_start (gpointer key, gpointer value, gpointer user_data);
 754
 755 static void invalidate_each_thread (gpointer key, gpointer value, gpointer user_data);
 756
 757 static void assembly_load (MonoProfiler *prof, MonoAssembly *assembly);
 758
 759 static void assembly_unload (MonoProfiler *prof, MonoAssembly *assembly);
 760
 761 static void emit_assembly_load (gpointer assembly, gpointer user_data);
 762
 763 static void emit_type_load (gpointer key, gpointer type, gpointer user_data);
 764
 765 static void jit_done (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo);
 766
 767 static void jit_failed (MonoProfiler *prof, MonoMethod *method);
 768
 769 static void jit_end (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo);
 770
 771 static void add_pending_breakpoints (MonoMethod *method, MonoJitInfo *jinfo);
 772
 773 static void start_single_stepping (void);
 774
 775 static void stop_single_stepping (void);
 776
 777 static void suspend_current (void);
 778
 779 static void clear_event_requests_for_assembly (MonoAssembly *assembly);
 780
 781 static void clear_types_for_assembly (MonoAssembly *assembly);
 782
 783 static void clear_breakpoints_for_domain (MonoDomain *domain);
 784
 785 static void process_profiler_event (EventKind event, gpointer arg);
 786
 787 /* Submodule init/cleanup */
 788 static void breakpoints_init (void);
 789 static void breakpoints_cleanup (void);
 790
 791 static void objrefs_init (void);
 792 static void objrefs_cleanup (void);
 793
 794 static void ids_init (void);
 795 static void ids_cleanup (void);
 796
 797 static void suspend_init (void);
 798
 799 static void ss_start (SingleStepReq *ss_req, MonoMethod *method, SeqPoint *sp, MonoSeqPointInfo *info, MonoContext *ctx, DebuggerTlsData *tls, gboolean step_to_catch,
 800                                           StackFrame **frames, int nframes);
 801 static ErrorCode ss_create (MonoInternalThread *thread, StepSize size, StepDepth depth, StepFilter filter, EventRequest *req);
 802 static void ss_destroy (SingleStepReq *req);
 803
 804 static void start_debugger_thread (void);
 805 static void stop_debugger_thread (void);
 806
 807 static void finish_agent_init (gboolean on_startup);
 808
 809 static void process_profiler_event (EventKind event, gpointer arg);
 810
 811 static void invalidate_frames (DebuggerTlsData *tls);
 812
 813 #ifndef DISABLE_SOCKET_TRANSPORT
 814 static void
 815 register_socket_transport (void);
 816 #endif
 817
 818 static inline gboolean
 819 is_debugger_thread (void)
 820 {
 821         MonoInternalThread *internal;
 822
 823         internal = mono_thread_internal_current ();
 824         if (!internal)
 825                 return FALSE;
 826
 827         return internal->debugger_thread;
 828 }
 829
 830 static int
 831 parse_address (char *address, char **host, int *port)
 832 {
 833         char *pos = strchr (address, ':');
 834
 835         if (pos == NULL || pos == address)
 836                 return 1;
 837
 838         size_t len = pos - address;
 839         *host = (char *)g_malloc (len + 1);
 840         memcpy (*host, address, len);
 841         (*host) [len] = '\0';
 842
 843         *port = atoi (pos + 1);
 844
 845         return 0;
 846 }
 847
 848 static void
 849 print_usage (void)
 850 {
 851         fprintf (stderr, "Usage: mono --debugger-agent=[<option>=<value>,...] ...\n");
 852         fprintf (stderr, "Available options:\n");
 853         fprintf (stderr, "  transport=<transport>\t\tTransport to use for connecting to the debugger (mandatory, possible values: 'dt_socket')\n");
 854         fprintf (stderr, "  address=<hostname>:<port>\tAddress to connect to (mandatory)\n");
 855         fprintf (stderr, "  loglevel=<n>\t\t\tLog level (defaults to 0)\n");
 856         fprintf (stderr, "  logfile=<file>\t\tFile to log to (defaults to stdout)\n");
 857         fprintf (stderr, "  suspend=y/n\t\t\tWhether to suspend after startup.\n");
 858         fprintf (stderr, "  timeout=<n>\t\t\tTimeout for connecting in milliseconds.\n");
 859         fprintf (stderr, "  server=y/n\t\t\tWhether to listen for a client connection.\n");
 860         fprintf (stderr, "  keepalive=<n>\t\t\tSend keepalive events every n milliseconds.\n");
 861         fprintf (stderr, "  setpgid=y/n\t\t\tWhether to call setpid(0, 0) after startup.\n");
 862         fprintf (stderr, "  help\t\t\t\tPrint this help.\n");
 863 }
 864
 865 static gboolean
 866 parse_flag (const char *option, char *flag)
 867 {
 868         if (!strcmp (flag, "y"))
 869                 return TRUE;
 870         else if (!strcmp (flag, "n"))
 871                 return FALSE;
 872         else {
 873                 fprintf (stderr, "debugger-agent: The valid values for the '%s' option are 'y' and 'n'.\n", option);
 874                 exit (1);
 875                 return FALSE;
 876         }
 877 }
 878
 879 void
 880 mono_debugger_agent_parse_options (char *options)
 881 {
 882         char **args, **ptr;
 883         char *host;
 884         int port;
 885         char *extra;
 886
 887 #ifndef MONO_ARCH_SOFT_DEBUG_SUPPORTED
 888         fprintf (stderr, "--debugger-agent is not supported on this platform.\n");
 889         exit (1);
 890 #endif
 891
 892         extra = g_getenv ("MONO_SDB_ENV_OPTIONS");
 893         if (extra) {
 894                 options = g_strdup_printf ("%s,%s", options, extra);
 895                 g_free (extra);
 896         }
 897
 898         agent_config.enabled = TRUE;
 899         agent_config.suspend = TRUE;
 900         agent_config.server = FALSE;
 901         agent_config.defer = FALSE;
 902         agent_config.address = NULL;
 903
 904         //agent_config.log_level = 10;
 905
 906         args = g_strsplit (options, ",", -1);
 907         for (ptr = args; ptr && *ptr; ptr ++) {
 908                 char *arg = *ptr;
 909
 910                 if (strncmp (arg, "transport=", 10) == 0) {
 911                         agent_config.transport = g_strdup (arg + 10);
 912                 } else if (strncmp (arg, "address=", 8) == 0) {
 913                         agent_config.address = g_strdup (arg + 8);
 914                 } else if (strncmp (arg, "loglevel=", 9) == 0) {
 915                         agent_config.log_level = atoi (arg + 9);
 916                 } else if (strncmp (arg, "logfile=", 8) == 0) {
 917                         agent_config.log_file = g_strdup (arg + 8);
 918                 } else if (strncmp (arg, "suspend=", 8) == 0) {
 919                         agent_config.suspend = parse_flag ("suspend", arg + 8);
 920                 } else if (strncmp (arg, "server=", 7) == 0) {
 921                         agent_config.server = parse_flag ("server", arg + 7);
 922                 } else if (strncmp (arg, "onuncaught=", 11) == 0) {
 923                         agent_config.onuncaught = parse_flag ("onuncaught", arg + 11);
 924                 } else if (strncmp (arg, "onthrow=", 8) == 0) {
 925                         /* We support multiple onthrow= options */
 926                         agent_config.onthrow = g_slist_append (agent_config.onthrow, g_strdup (arg + 8));
 927                 } else if (strncmp (arg, "onthrow", 7) == 0) {
 928                         agent_config.onthrow = g_slist_append (agent_config.onthrow, g_strdup (""));
 929                 } else if (strncmp (arg, "help", 4) == 0) {
 930                         print_usage ();
 931                         exit (0);
 932                 } else if (strncmp (arg, "timeout=", 8) == 0) {
 933                         agent_config.timeout = atoi (arg + 8);
 934                 } else if (strncmp (arg, "launch=", 7) == 0) {
 935                         agent_config.launch = g_strdup (arg + 7);
 936                 } else if (strncmp (arg, "embedding=", 10) == 0) {
 937                         agent_config.embedding = atoi (arg + 10) == 1;
 938                 } else if (strncmp (arg, "keepalive=", 10) == 0) {
 939                         agent_config.keepalive = atoi (arg + 10);
 940                 } else if (strncmp (arg, "setpgid=", 8) == 0) {
 941                         agent_config.setpgid = parse_flag ("setpgid", arg + 8);
 942                 } else {
 943                         print_usage ();
 944                         exit (1);
 945                 }
 946         }
 947
 948         if (agent_config.server && !agent_config.suspend) {
 949                 /* Waiting for deferred attachment */
 950                 agent_config.defer = TRUE;
 951                 if (agent_config.address == NULL) {
 952                         agent_config.address = g_strdup_printf ("0.0.0.0:%u", 56000 + (mono_process_current_pid () % 1000));
 953                 }
 954         }
 955
 956         //agent_config.log_level = 0;
 957
 958         if (agent_config.transport == NULL) {
 959                 fprintf (stderr, "debugger-agent: The 'transport' option is mandatory.\n");
 960                 exit (1);
 961         }
 962
 963         if (agent_config.address == NULL && !agent_config.server) {
 964                 fprintf (stderr, "debugger-agent: The 'address' option is mandatory.\n");
 965                 exit (1);
 966         }
 967
 968         // FIXME:
 969         if (!strcmp (agent_config.transport, "dt_socket")) {
 970                 if (agent_config.address && parse_address (agent_config.address, &host, &port)) {
 971                         fprintf (stderr, "debugger-agent: The format of the 'address' options is '<host>:<port>'\n");
 972                         exit (1);
 973                 }
 974         }
 975 }
 976
 977 void
 978 mono_debugger_agent_init (void)
 979 {
 980         mono_coop_mutex_init_recursive (&debug_mutex);
 981
 982         if (!agent_config.enabled)
 983                 return;
 984
 985         transport_init ();
 986
 987         /* Need to know whenever a thread has acquired the loader mutex */
 988         mono_loader_lock_track_ownership (TRUE);
 989
 990         event_requests = g_ptr_array_new ();
 991
 992         mono_coop_mutex_init (&debugger_thread_exited_mutex);
 993         mono_coop_cond_init (&debugger_thread_exited_cond);
 994
 995         MonoProfilerHandle prof = mono_profiler_create (NULL);
 996         mono_profiler_set_runtime_shutdown_end_callback (prof, runtime_shutdown);
 997         mono_profiler_set_runtime_initialized_callback (prof, runtime_initialized);
 998         mono_profiler_set_domain_loaded_callback (prof, appdomain_load);
 999         mono_profiler_set_domain_unloading_callback (prof, appdomain_start_unload);
1000         mono_profiler_set_domain_unloaded_callback (prof, appdomain_unload);
1001         mono_profiler_set_thread_started_callback (prof, thread_startup);
1002         mono_profiler_set_thread_stopped_callback (prof, thread_end);
1003         mono_profiler_set_assembly_loaded_callback (prof, assembly_load);
1004         mono_profiler_set_assembly_unloading_callback (prof, assembly_unload);
1005         mono_profiler_set_jit_done_callback (prof, jit_done);
1006         mono_profiler_set_jit_failed_callback (prof, jit_failed);
1007
1008         mono_native_tls_alloc (&debugger_tls_id, NULL);
1009
1010         /* Needed by the hash_table_new_type () call below */
1011         mono_gc_base_init ();
1012
1013         thread_to_tls = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_DEBUGGER, "thread-to-tls table");
1014
1015         tid_to_thread = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DEBUGGER, "tid-to-thread table");
1016
1017         tid_to_thread_obj = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DEBUGGER, "tid-to-thread object table");
1018
1019         pending_assembly_loads = g_ptr_array_new ();
1020         domains = g_hash_table_new (mono_aligned_addr_hash, NULL);
1021
1022         log_level = agent_config.log_level;
1023
1024         embedding = agent_config.embedding;
1025         disconnected = TRUE;
1026
1027         if (agent_config.log_file) {
1028                 log_file = fopen (agent_config.log_file, "w+");
1029                 if (!log_file) {
1030                         fprintf (stderr, "Unable to create log file '%s': %s.\n", agent_config.log_file, strerror (errno));
1031                         exit (1);
1032                 }
1033         } else {
1034                 log_file = stdout;
1035         }
1036
1037         ids_init ();
1038         objrefs_init ();
1039         breakpoints_init ();
1040         suspend_init ();
1041
1042         mini_get_debug_options ()->gen_sdb_seq_points = TRUE;
1043         /*
1044          * This is needed because currently we don't handle liveness info.
1045          */
1046         mini_get_debug_options ()->mdb_optimizations = TRUE;
1047
1048 #ifndef MONO_ARCH_HAVE_CONTEXT_SET_INT_REG
1049         /* This is needed because we can't set local variables in registers yet */
1050         mono_disable_optimizations (MONO_OPT_LINEARS);
1051 #endif
1052
1053         /*
1054          * The stack walk done from thread_interrupt () needs to be signal safe, but it
1055          * isn't, since it can call into mono_aot_find_jit_info () which is not signal
1056          * safe (#3411). So load AOT info eagerly when the debugger is running as a
1057          * workaround.
1058          */
1059         mini_get_debug_options ()->load_aot_jit_info_eagerly = TRUE;
1060
1061 #ifdef HAVE_SETPGID
1062         if (agent_config.setpgid)
1063                 setpgid (0, 0);
1064 #endif
1065
1066         if (!agent_config.onuncaught && !agent_config.onthrow)
1067                 finish_agent_init (TRUE);
1068 }
1069
1070 /*
1071  * finish_agent_init:
1072  *
1073  *   Finish the initialization of the agent. This involves connecting the transport
1074  * and starting the agent thread. This is either done at startup, or
1075  * in response to some event like an unhandled exception.
1076  */
1077 static void
1078 finish_agent_init (gboolean on_startup)
1079 {
1080         int res;
1081
1082         if (InterlockedCompareExchange (&inited, 1, 0) == 1)
1083                 return;
1084
1085         if (agent_config.launch) {
1086                 char *argv [16];
1087
1088                 // FIXME: Generated address
1089                 // FIXME: Races with transport_connect ()
1090
1091                 argv [0] = agent_config.launch;
1092                 argv [1] = agent_config.transport;
1093                 argv [2] = agent_config.address;
1094                 argv [3] = NULL;
1095
1096                 res = g_spawn_async_with_pipes (NULL, argv, NULL, (GSpawnFlags)0, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1097                 if (!res) {
1098                         fprintf (stderr, "Failed to execute '%s'.\n", agent_config.launch);
1099                         exit (1);
1100                 }
1101         }
1102
1103         transport_connect (agent_config.address);
1104
1105         if (!on_startup) {
1106                 /* Do some which is usually done after sending the VMStart () event */
1107                 vm_start_event_sent = TRUE;
1108                 start_debugger_thread ();
1109         }
1110 }
1111
1112 static void
1113 mono_debugger_agent_cleanup (void)
1114 {
1115         if (!inited)
1116                 return;
1117
1118         stop_debugger_thread ();
1119
1120         breakpoints_cleanup ();
1121         objrefs_cleanup ();
1122         ids_cleanup ();
1123 }
1124
1125 /*
1126  * SOCKET TRANSPORT
1127  */
1128
1129 #ifndef DISABLE_SOCKET_TRANSPORT
1130
1131 /*
1132  * recv_length:
1133  *
1134  * recv() + handle incomplete reads and EINTR
1135  */
1136 static int
1137 socket_transport_recv (void *buf, int len)
1138 {
1139         int res;
1140         int total = 0;
1141         int fd = conn_fd;
1142         int flags = 0;
1143         static gint64 last_keepalive;
1144         gint64 msecs;
1145
1146         MONO_ENTER_GC_SAFE;
1147
1148         do {
1149         again:
1150                 res = recv (fd, (char *) buf + total, len - total, flags);
1151                 if (res > 0)
1152                         total += res;
1153                 if (agent_config.keepalive) {
1154                         gboolean need_keepalive = FALSE;
1155                         if (res == -1 && get_last_sock_error () == MONO_EWOULDBLOCK) {
1156                                 need_keepalive = TRUE;
1157                         } else if (res == -1) {
1158                                 /* This could happen if recv () is interrupted repeatedly */
1159                                 msecs = mono_msec_ticks ();
1160                                 if (msecs - last_keepalive >= agent_config.keepalive) {
1161                                         need_keepalive = TRUE;
1162                                         last_keepalive = msecs;
1163                                 }
1164                         }
1165                         if (need_keepalive) {
1166                                 process_profiler_event (EVENT_KIND_KEEPALIVE, NULL);
1167                                 goto again;
1168                         }
1169                 }
1170         } while ((res > 0 && total < len) || (res == -1 && get_last_sock_error () == MONO_EINTR));
1171
1172         MONO_EXIT_GC_SAFE;
1173
1174         return total;
1175 }
1176
1177 static void
1178 set_keepalive (void)
1179 {
1180         struct timeval tv;
1181         int result;
1182
1183         if (!agent_config.keepalive || !conn_fd)
1184                 return;
1185
1186         tv.tv_sec = agent_config.keepalive / 1000;
1187         tv.tv_usec = (agent_config.keepalive % 1000) * 1000;
1188
1189         result = setsockopt (conn_fd, SOL_SOCKET, SO_RCVTIMEO, (char *) &tv, sizeof(struct timeval));
1190         g_assert (result >= 0);
1191 }
1192
1193 static int
1194 socket_transport_accept (int socket_fd)
1195 {
1196         MONO_ENTER_GC_SAFE;
1197         conn_fd = accept (socket_fd, NULL, NULL);
1198         MONO_EXIT_GC_SAFE;
1199
1200         if (conn_fd == -1) {
1201                 fprintf (stderr, "debugger-agent: Unable to listen on %d\n", socket_fd);
1202         } else {
1203                 DEBUG_PRINTF (1, "Accepted connection from client, connection fd=%d.\n", conn_fd);
1204         }
1205
1206         return conn_fd;
1207 }
1208
1209 static gboolean
1210 socket_transport_send (void *data, int len)
1211 {
1212         int res;
1213
1214         MONO_ENTER_GC_SAFE;
1215
1216         do {
1217                 res = send (conn_fd, data, len, 0);
1218         } while (res == -1 && get_last_sock_error () == MONO_EINTR);
1219
1220         MONO_EXIT_GC_SAFE;
1221
1222         if (res != len)
1223                 return FALSE;
1224         else
1225                 return TRUE;
1226 }
1227
1228 /*
1229  * socket_transport_connect:
1230  *
1231  *   Connect/Listen on HOST:PORT. If HOST is NULL, generate an address and listen on it.
1232  */
1233 static void
1234 socket_transport_connect (const char *address)
1235 {
1236         MonoAddressInfo *result;
1237         MonoAddressEntry *rp;
1238         int sfd = -1, s, res;
1239         char *host;
1240         int port;
1241
1242         if (agent_config.address) {
1243                 res = parse_address (agent_config.address, &host, &port);
1244                 g_assert (res == 0);
1245         } else {
1246                 host = NULL;
1247                 port = 0;
1248         }
1249
1250         conn_fd = -1;
1251         listen_fd = -1;
1252
1253         if (host) {
1254
1255                 mono_network_init ();
1256
1257                 /* Obtain address(es) matching host/port */
1258                 s = mono_get_address_info (host, port, MONO_HINT_UNSPECIFIED, &result);
1259                 if (s != 0) {
1260                         fprintf (stderr, "debugger-agent: Unable to resolve %s:%d: %d\n", host, port, s); // FIXME add portable error conversion functions
1261                         exit (1);
1262                 }
1263         }
1264
1265         if (agent_config.server) {
1266                 /* Wait for a connection */
1267                 if (!host) {
1268                         struct sockaddr_in addr;
1269                         socklen_t addrlen;
1270
1271                         /* No address, generate one */
1272                         sfd = socket (AF_INET, SOCK_STREAM, 0);
1273                         g_assert (sfd);
1274
1275                         /* This will bind the socket to a random port */
1276                         res = listen (sfd, 16);
1277                         if (res == -1) {
1278                                 fprintf (stderr, "debugger-agent: Unable to setup listening socket: %s\n", strerror (get_last_sock_error ()));
1279                                 exit (1);
1280                         }
1281                         listen_fd = sfd;
1282
1283                         addrlen = sizeof (addr);
1284                         memset (&addr, 0, sizeof (addr));
1285                         res = getsockname (sfd, (struct sockaddr*)&addr, &addrlen);
1286                         g_assert (res == 0);
1287
1288                         host = (char*)"127.0.0.1";
1289                         port = ntohs (addr.sin_port);
1290
1291                         /* Emit the address to stdout */
1292                         /* FIXME: Should print another interface, not localhost */
1293                         printf ("%s:%d\n", host, port);
1294                 } else {
1295                         /* Listen on the provided address */
1296                         for (rp = result->entries; rp != NULL; rp = rp->next) {
1297                                 MonoSocketAddress sockaddr;
1298                                 socklen_t sock_len;
1299                                 int n = 1;
1300
1301                                 mono_socket_address_init (&sockaddr, &sock_len, rp->family, &rp->address, port);
1302
1303                                 sfd = socket (rp->family, rp->socktype,
1304                                                           rp->protocol);
1305                                 if (sfd == -1)
1306                                         continue;
1307
1308                                 if (setsockopt (sfd, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) == -1)
1309                                         continue;
1310
1311                                 res = bind (sfd, &sockaddr.addr, sock_len);
1312                                 if (res == -1)
1313                                         continue;
1314
1315                                 res = listen (sfd, 16);
1316                                 if (res == -1)
1317                                         continue;
1318                                 listen_fd = sfd;
1319                                 break;
1320                         }
1321
1322                         mono_free_address_info (result);
1323                 }
1324
1325                 if (agent_config.defer)
1326                         return;
1327
1328                 DEBUG_PRINTF (1, "Listening on %s:%d (timeout=%d ms)...\n", host, port, agent_config.timeout);
1329
1330                 if (agent_config.timeout) {
1331                         fd_set readfds;
1332                         struct timeval tv;
1333
1334                         tv.tv_sec = 0;
1335                         tv.tv_usec = agent_config.timeout * 1000;
1336                         FD_ZERO (&readfds);
1337                         FD_SET (sfd, &readfds);
1338
1339                         MONO_ENTER_GC_SAFE;
1340                         res = select (sfd + 1, &readfds, NULL, NULL, &tv);
1341                         MONO_EXIT_GC_SAFE;
1342
1343                         if (res == 0) {
1344                                 fprintf (stderr, "debugger-agent: Timed out waiting to connect.\n");
1345                                 exit (1);
1346                         }
1347                 }
1348
1349                 conn_fd = socket_transport_accept (sfd);
1350                 if (conn_fd == -1)
1351                         exit (1);
1352
1353                 DEBUG_PRINTF (1, "Accepted connection from client, socket fd=%d.\n", conn_fd);
1354         } else {
1355                 /* Connect to the specified address */
1356                 /* FIXME: Respect the timeout */
1357                 for (rp = result->entries; rp != NULL; rp = rp->next) {
1358                         MonoSocketAddress sockaddr;
1359                         socklen_t sock_len;
1360
1361                         mono_socket_address_init (&sockaddr, &sock_len, rp->family, &rp->address, port);
1362
1363                         sfd = socket (rp->family, rp->socktype,
1364                                                   rp->protocol);
1365                         if (sfd == -1)
1366                                 continue;
1367
1368                         MONO_ENTER_GC_SAFE;
1369                         res = connect (sfd, &sockaddr.addr, sock_len);
1370                         MONO_EXIT_GC_SAFE;
1371
1372                         if (res != -1)
1373                                 break;       /* Success */
1374
1375                         MONO_ENTER_GC_SAFE;
1376                         close (sfd);
1377                         MONO_EXIT_GC_SAFE;
1378                 }
1379
1380                 if (rp == 0) {
1381                         fprintf (stderr, "debugger-agent: Unable to connect to %s:%d\n", host, port);
1382                         exit (1);
1383                 }
1384
1385                 conn_fd = sfd;
1386
1387                 mono_free_address_info (result);
1388         }
1389
1390         if (!transport_handshake ())
1391                 exit (1);
1392 }
1393
1394 static void
1395 socket_transport_close1 (void)
1396 {
1397         /* This will interrupt the agent thread */
1398         /* Close the read part only so it can still send back replies */
1399         /* Also shut down the connection listener so that we can exit normally */
1400 #ifdef HOST_WIN32
1401         /* SD_RECEIVE doesn't break the recv in the debugger thread */
1402         shutdown (conn_fd, SD_BOTH);
1403         shutdown (listen_fd, SD_BOTH);
1404         closesocket (listen_fd);
1405 #else
1406         shutdown (conn_fd, SHUT_RD);
1407         shutdown (listen_fd, SHUT_RDWR);
1408         MONO_ENTER_GC_SAFE;
1409         close (listen_fd);
1410         MONO_EXIT_GC_SAFE;
1411 #endif
1412 }
1413
1414 static void
1415 socket_transport_close2 (void)
1416 {
1417 #ifdef HOST_WIN32
1418         shutdown (conn_fd, SD_BOTH);
1419 #else
1420         shutdown (conn_fd, SHUT_RDWR);
1421 #endif
1422 }
1423
1424 static void
1425 register_socket_transport (void)
1426 {
1427         DebuggerTransport trans;
1428
1429         trans.name = "dt_socket";
1430         trans.connect = socket_transport_connect;
1431         trans.close1 = socket_transport_close1;
1432         trans.close2 = socket_transport_close2;
1433         trans.send = socket_transport_send;
1434         trans.recv = socket_transport_recv;
1435
1436         register_transport (&trans);
1437 }
1438
1439 /*
1440  * socket_fd_transport_connect:
1441  *
1442  */
1443 static void
1444 socket_fd_transport_connect (const char *address)
1445 {
1446         int res;
1447
1448         res = sscanf (address, "%d", &conn_fd);
1449         if (res != 1) {
1450                 fprintf (stderr, "debugger-agent: socket-fd transport address is invalid: '%s'\n", address);
1451                 exit (1);
1452         }
1453
1454         if (!transport_handshake ())
1455                 exit (1);
1456 }
1457
1458 static void
1459 register_socket_fd_transport (void)
1460 {
1461         DebuggerTransport trans;
1462
1463         /* This is the same as the 'dt_socket' transport, but receives an already connected socket fd */
1464         trans.name = "socket-fd";
1465         trans.connect = socket_fd_transport_connect;
1466         trans.close1 = socket_transport_close1;
1467         trans.close2 = socket_transport_close2;
1468         trans.send = socket_transport_send;
1469         trans.recv = socket_transport_recv;
1470
1471         register_transport (&trans);
1472 }
1473
1474 #endif /* DISABLE_SOCKET_TRANSPORT */
1475
1476 /*
1477  * TRANSPORT CODE
1478  */
1479
1480 #define MAX_TRANSPORTS 16
1481
1482 static DebuggerTransport *transport;
1483
1484 static DebuggerTransport transports [MAX_TRANSPORTS];
1485 static int ntransports;
1486
1487 MONO_API void
1488 mono_debugger_agent_register_transport (DebuggerTransport *trans);
1489
1490 void
1491 mono_debugger_agent_register_transport (DebuggerTransport *trans)
1492 {
1493         register_transport (trans);
1494 }
1495
1496 static void
1497 register_transport (DebuggerTransport *trans)
1498 {
1499         g_assert (ntransports < MAX_TRANSPORTS);
1500
1501         memcpy (&transports [ntransports], trans, sizeof (DebuggerTransport));
1502         ntransports ++;
1503 }
1504
1505 static void
1506 transport_init (void)
1507 {
1508         int i;
1509
1510 #ifndef DISABLE_SOCKET_TRANSPORT
1511         register_socket_transport ();
1512         register_socket_fd_transport ();
1513 #endif
1514
1515         for (i = 0; i < ntransports; ++i) {
1516                 if (!strcmp (agent_config.transport, transports [i].name))
1517                         break;
1518         }
1519         if (i == ntransports) {
1520                 fprintf (stderr, "debugger-agent: The supported values for the 'transport' option are: ");
1521                 for (i = 0; i < ntransports; ++i)
1522                         fprintf (stderr, "%s'%s'", i > 0 ? ", " : "", transports [i].name);
1523                 fprintf (stderr, "\n");
1524                 exit (1);
1525         }
1526         transport = &transports [i];
1527 }
1528
1529 void
1530 transport_connect (const char *address)
1531 {
1532         transport->connect (address);
1533 }
1534
1535 static void
1536 transport_close1 (void)
1537 {
1538         transport->close1 ();
1539 }
1540
1541 static void
1542 transport_close2 (void)
1543 {
1544         transport->close2 ();
1545 }
1546
1547 static int
1548 transport_send (void *buf, int len)
1549 {
1550         return transport->send (buf, len);
1551 }
1552
1553 static int
1554 transport_recv (void *buf, int len)
1555 {
1556         return transport->recv (buf, len);
1557 }
1558
1559 gboolean
1560 mono_debugger_agent_transport_handshake (void)
1561 {
1562         return transport_handshake ();
1563 }
1564
1565 static gboolean
1566 transport_handshake (void)
1567 {
1568         char handshake_msg [128];
1569         guint8 buf [128];
1570         int res;
1571
1572         disconnected = TRUE;
1573
1574         /* Write handshake message */
1575         sprintf (handshake_msg, "DWP-Handshake");
1576
1577         do {
1578                 res = transport_send (handshake_msg, strlen (handshake_msg));
1579         } while (res == -1 && get_last_sock_error () == MONO_EINTR);
1580
1581         g_assert (res != -1);
1582
1583         /* Read answer */
1584         res = transport_recv (buf, strlen (handshake_msg));
1585         if ((res != strlen (handshake_msg)) || (memcmp (buf, handshake_msg, strlen (handshake_msg)) != 0)) {
1586                 fprintf (stderr, "debugger-agent: DWP handshake failed.\n");
1587                 return FALSE;
1588         }
1589
1590         /*
1591          * To support older clients, the client sends its protocol version after connecting
1592          * using a command. Until that is received, default to our protocol version.
1593          */
1594         major_version = MAJOR_VERSION;
1595         minor_version = MINOR_VERSION;
1596         protocol_version_set = FALSE;
1597
1598 #ifndef DISABLE_SOCKET_TRANSPORT
1599         // FIXME: Move this somewhere else
1600         /*
1601          * Set TCP_NODELAY on the socket so the client receives events/command
1602          * results immediately.
1603          */
1604         if (conn_fd) {
1605                 int flag = 1;
1606                 int result = setsockopt (conn_fd,
1607                                  IPPROTO_TCP,
1608                                  TCP_NODELAY,
1609                                  (char *) &flag,
1610                                  sizeof(int));
1611                 g_assert (result >= 0);
1612         }
1613
1614         set_keepalive ();
1615 #endif
1616
1617         disconnected = FALSE;
1618         return TRUE;
1619 }
1620
1621 static void
1622 stop_debugger_thread (void)
1623 {
1624         if (!inited)
1625                 return;
1626
1627         transport_close1 ();
1628
1629         /*
1630          * Wait for the thread to exit.
1631          *
1632          * If we continue with the shutdown without waiting for it, then the client might
1633          * not receive an answer to its last command like a resume.
1634          */
1635         if (!is_debugger_thread ()) {
1636                 do {
1637                         mono_coop_mutex_lock (&debugger_thread_exited_mutex);
1638                         if (!debugger_thread_exited)
1639                                 mono_coop_cond_wait (&debugger_thread_exited_cond, &debugger_thread_exited_mutex);
1640                         mono_coop_mutex_unlock (&debugger_thread_exited_mutex);
1641                 } while (!debugger_thread_exited);
1642         }
1643
1644         transport_close2 ();
1645 }
1646
1647 static void
1648 start_debugger_thread (void)
1649 {
1650         MonoError error;
1651         MonoInternalThread *thread;
1652
1653         thread = mono_thread_create_internal (mono_get_root_domain (), debugger_thread, NULL, MONO_THREAD_CREATE_FLAGS_DEBUGGER, &error);
1654         mono_error_assert_ok (&error);
1655
1656         debugger_thread_handle = mono_threads_open_thread_handle (thread->handle);
1657         g_assert (debugger_thread_handle);
1658 }
1659
1660 /*
1661  * Functions to decode protocol data
1662  */
1663
1664 static inline int
1665 decode_byte (guint8 *buf, guint8 **endbuf, guint8 *limit)
1666 {
1667         *endbuf = buf + 1;
1668         g_assert (*endbuf <= limit);
1669         return buf [0];
1670 }
1671
1672 static inline int
1673 decode_int (guint8 *buf, guint8 **endbuf, guint8 *limit)
1674 {
1675         *endbuf = buf + 4;
1676         g_assert (*endbuf <= limit);
1677
1678         return (((int)buf [0]) << 24) | (((int)buf [1]) << 16) | (((int)buf [2]) << 8) | (((int)buf [3]) << 0);
1679 }
1680
1681 static inline gint64
1682 decode_long (guint8 *buf, guint8 **endbuf, guint8 *limit)
1683 {
1684         guint32 high = decode_int (buf, &buf, limit);
1685         guint32 low = decode_int (buf, &buf, limit);
1686
1687         *endbuf = buf;
1688
1689         return ((((guint64)high) << 32) | ((guint64)low));
1690 }
1691
1692 static inline int
1693 decode_id (guint8 *buf, guint8 **endbuf, guint8 *limit)
1694 {
1695         return decode_int (buf, endbuf, limit);
1696 }
1697
1698 static inline char*
1699 decode_string (guint8 *buf, guint8 **endbuf, guint8 *limit)
1700 {
1701         int len = decode_int (buf, &buf, limit);
1702         char *s;
1703
1704         if (len < 0) {
1705                 *endbuf = buf;
1706                 return NULL;
1707         }
1708
1709         s = (char *)g_malloc (len + 1);
1710         g_assert (s);
1711
1712         memcpy (s, buf, len);
1713         s [len] = '\0';
1714         buf += len;
1715         *endbuf = buf;
1716
1717         return s;
1718 }
1719
1720 /*
1721  * Functions to encode protocol data
1722  */
1723
1724 static inline void
1725 buffer_init (Buffer *buf, int size)
1726 {
1727         buf->buf = (guint8 *)g_malloc (size);
1728         buf->p = buf->buf;
1729         buf->end = buf->buf + size;
1730 }
1731
1732 static inline int
1733 buffer_len (Buffer *buf)
1734 {
1735         return buf->p - buf->buf;
1736 }
1737
1738 static inline void
1739 buffer_make_room (Buffer *buf, int size)
1740 {
1741         if (buf->end - buf->p < size) {
1742                 int new_size = buf->end - buf->buf + size + 32;
1743                 guint8 *p = (guint8 *)g_realloc (buf->buf, new_size);
1744                 size = buf->p - buf->buf;
1745                 buf->buf = p;
1746                 buf->p = p + size;
1747                 buf->end = buf->buf + new_size;
1748         }
1749 }
1750
1751 static inline void
1752 buffer_add_byte (Buffer *buf, guint8 val)
1753 {
1754         buffer_make_room (buf, 1);
1755         buf->p [0] = val;
1756         buf->p++;
1757 }
1758
1759 static inline void
1760 buffer_add_short (Buffer *buf, guint32 val)
1761 {
1762         buffer_make_room (buf, 2);
1763         buf->p [0] = (val >> 8) & 0xff;
1764         buf->p [1] = (val >> 0) & 0xff;
1765         buf->p += 2;
1766 }
1767
1768 static inline void
1769 buffer_add_int (Buffer *buf, guint32 val)
1770 {
1771         buffer_make_room (buf, 4);
1772         buf->p [0] = (val >> 24) & 0xff;
1773         buf->p [1] = (val >> 16) & 0xff;
1774         buf->p [2] = (val >> 8) & 0xff;
1775         buf->p [3] = (val >> 0) & 0xff;
1776         buf->p += 4;
1777 }
1778
1779 static inline void
1780 buffer_add_long (Buffer *buf, guint64 l)
1781 {
1782         buffer_add_int (buf, (l >> 32) & 0xffffffff);
1783         buffer_add_int (buf, (l >> 0) & 0xffffffff);
1784 }
1785
1786 static inline void
1787 buffer_add_id (Buffer *buf, int id)
1788 {
1789         buffer_add_int (buf, (guint64)id);
1790 }
1791
1792 static inline void
1793 buffer_add_data (Buffer *buf, guint8 *data, int len)
1794 {
1795         buffer_make_room (buf, len);
1796         memcpy (buf->p, data, len);
1797         buf->p += len;
1798 }
1799
1800 static inline void
1801 buffer_add_string (Buffer *buf, const char *str)
1802 {
1803         int len;
1804
1805         if (str == NULL) {
1806                 buffer_add_int (buf, 0);
1807         } else {
1808                 len = strlen (str);
1809                 buffer_add_int (buf, len);
1810                 buffer_add_data (buf, (guint8*)str, len);
1811         }
1812 }
1813
1814 static inline void
1815 buffer_add_buffer (Buffer *buf, Buffer *data)
1816 {
1817         buffer_add_data (buf, data->buf, buffer_len (data));
1818 }
1819
1820 static inline void
1821 buffer_free (Buffer *buf)
1822 {
1823         g_free (buf->buf);
1824 }
1825
1826 static gboolean
1827 send_packet (int command_set, int command, Buffer *data)
1828 {
1829         Buffer buf;
1830         int len, id;
1831         gboolean res;
1832
1833         id = InterlockedIncrement (&packet_id);
1834
1835         len = data->p - data->buf + 11;
1836         buffer_init (&buf, len);
1837         buffer_add_int (&buf, len);
1838         buffer_add_int (&buf, id);
1839         buffer_add_byte (&buf, 0); /* flags */
1840         buffer_add_byte (&buf, command_set);
1841         buffer_add_byte (&buf, command);
1842         memcpy (buf.buf + 11, data->buf, data->p - data->buf);
1843
1844         res = transport_send (buf.buf, len);
1845
1846         buffer_free (&buf);
1847
1848         return res;
1849 }
1850
1851 static gboolean
1852 send_reply_packets (int npackets, ReplyPacket *packets)
1853 {
1854         Buffer buf;
1855         int i, len;
1856         gboolean res;
1857
1858         len = 0;
1859         for (i = 0; i < npackets; ++i)
1860                 len += buffer_len (packets [i].data) + 11;
1861         buffer_init (&buf, len);
1862         for (i = 0; i < npackets; ++i) {
1863                 buffer_add_int (&buf, buffer_len (packets [i].data) + 11);
1864                 buffer_add_int (&buf, packets [i].id);
1865                 buffer_add_byte (&buf, 0x80); /* flags */
1866                 buffer_add_byte (&buf, (packets [i].error >> 8) & 0xff);
1867                 buffer_add_byte (&buf, packets [i].error);
1868                 buffer_add_buffer (&buf, packets [i].data);
1869         }
1870
1871         res = transport_send (buf.buf, len);
1872
1873         buffer_free (&buf);
1874
1875         return res;
1876 }
1877
1878 static gboolean
1879 send_reply_packet (int id, int error, Buffer *data)
1880 {
1881         ReplyPacket packet;
1882
1883         memset (&packet, 0, sizeof (ReplyPacket));
1884         packet.id = id;
1885         packet.error = error;
1886         packet.data = data;
1887
1888         return send_reply_packets (1, &packet);
1889 }
1890
1891 static void
1892 send_buffered_reply_packets (void)
1893 {
1894         int i;
1895
1896         send_reply_packets (nreply_packets, reply_packets);
1897         for (i = 0; i < nreply_packets; ++i)
1898                 buffer_free (reply_packets [i].data);
1899         DEBUG_PRINTF (1, "[dbg] Sent %d buffered reply packets [at=%lx].\n", nreply_packets, (long)mono_100ns_ticks () / 10000);
1900         nreply_packets = 0;
1901 }
1902
1903 static void
1904 buffer_reply_packet (int id, int error, Buffer *data)
1905 {
1906         ReplyPacket *p;
1907
1908         if (nreply_packets == 128)
1909                 send_buffered_reply_packets ();
1910
1911         p = &reply_packets [nreply_packets];
1912         p->id = id;
1913         p->error = error;
1914         p->data = g_new0 (Buffer, 1);
1915         buffer_init (p->data, buffer_len (data));
1916         buffer_add_buffer (p->data, data);
1917         nreply_packets ++;
1918 }
1919
1920 /*
1921  * OBJECT IDS
1922  */
1923
1924 /*
1925  * Represents an object accessible by the debugger client.
1926  */
1927 typedef struct {
1928         /* Unique id used in the wire protocol to refer to objects */
1929         int id;
1930         /*
1931          * A weakref gc handle pointing to the object. The gc handle is used to
1932          * detect if the object was garbage collected.
1933          */
1934         guint32 handle;
1935 } ObjRef;
1936
1937 /* Maps objid -> ObjRef */
1938 /* Protected by the loader lock */
1939 static GHashTable *objrefs;
1940 /* Protected by the loader lock */
1941 static GHashTable *obj_to_objref;
1942 /* Protected by the dbg lock */
1943 static MonoGHashTable *suspended_objs;
1944
1945 static void
1946 free_objref (gpointer value)
1947 {
1948         ObjRef *o = (ObjRef *)value;
1949
1950         mono_gchandle_free (o->handle);
1951
1952         g_free (o);
1953 }
1954
1955 static void
1956 objrefs_init (void)
1957 {
1958         objrefs = g_hash_table_new_full (NULL, NULL, NULL, free_objref);
1959         obj_to_objref = g_hash_table_new (NULL, NULL);
1960         suspended_objs = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_DEBUGGER, "suspended objects table");
1961 }
1962
1963 static void
1964 objrefs_cleanup (void)
1965 {
1966         g_hash_table_destroy (objrefs);
1967         objrefs = NULL;
1968 }
1969
1970 /*
1971  * Return an ObjRef for OBJ.
1972  */
1973 static ObjRef*
1974 get_objref (MonoObject *obj)
1975 {
1976         ObjRef *ref;
1977         GSList *reflist = NULL, *l;
1978         int hash = 0;
1979
1980         if (obj == NULL)
1981                 return NULL;
1982
1983         if (suspend_count) {
1984                 /*
1985                  * Have to keep object refs created during suspensions alive for the duration of the suspension, so GCs during invokes don't collect them.
1986                  */
1987                 dbg_lock ();
1988                 mono_g_hash_table_insert (suspended_objs, obj, NULL);
1989                 dbg_unlock ();
1990         }
1991
1992         mono_loader_lock ();
1993
1994         /* FIXME: The tables can grow indefinitely */
1995
1996         if (mono_gc_is_moving ()) {
1997                 /*
1998                  * Objects can move, so use a hash table mapping hash codes to lists of
1999                  * ObjRef structures.
2000                  */
2001                 hash = mono_object_hash (obj);
2002
2003                 reflist = (GSList *)g_hash_table_lookup (obj_to_objref, GINT_TO_POINTER (hash));
2004                 for (l = reflist; l; l = l->next) {
2005                         ref = (ObjRef *)l->data;
2006                         if (ref && mono_gchandle_get_target (ref->handle) == obj) {
2007                                 mono_loader_unlock ();
2008                                 return ref;
2009                         }
2010                 }
2011         } else {
2012                 /* Use a hash table with masked pointers to internalize object references */
2013                 ref = (ObjRef *)g_hash_table_lookup (obj_to_objref, GINT_TO_POINTER (~((gsize)obj)));
2014                 /* ref might refer to a different object with the same addr which was GCd */
2015                 if (ref && mono_gchandle_get_target (ref->handle) == obj) {
2016                         mono_loader_unlock ();
2017                         return ref;
2018                 }
2019         }
2020
2021         ref = g_new0 (ObjRef, 1);
2022         ref->id = InterlockedIncrement (&objref_id);
2023         ref->handle = mono_gchandle_new_weakref (obj, FALSE);
2024
2025         g_hash_table_insert (objrefs, GINT_TO_POINTER (ref->id), ref);
2026
2027         if (mono_gc_is_moving ()) {
2028                 reflist = g_slist_append (reflist, ref);
2029                 g_hash_table_insert (obj_to_objref, GINT_TO_POINTER (hash), reflist);
2030         } else {
2031                 g_hash_table_insert (obj_to_objref, GINT_TO_POINTER (~((gsize)obj)), ref);
2032         }
2033
2034         mono_loader_unlock ();
2035
2036         return ref;
2037 }
2038
2039 static gboolean
2040 true_pred (gpointer key, gpointer value, gpointer user_data)
2041 {
2042         return TRUE;
2043 }
2044
2045 static void
2046 clear_suspended_objs (void)
2047 {
2048         dbg_lock ();
2049         mono_g_hash_table_foreach_remove (suspended_objs, true_pred, NULL);
2050         dbg_unlock ();
2051 }
2052
2053 static inline int
2054 get_objid (MonoObject *obj)
2055 {
2056         if (!obj)
2057                 return 0;
2058         else
2059                 return get_objref (obj)->id;
2060 }
2061
2062 /*
2063  * Set OBJ to the object identified by OBJID.
2064  * Returns 0 or an error code if OBJID is invalid or the object has been garbage
2065  * collected.
2066  */
2067 static ErrorCode
2068 get_object_allow_null (int objid, MonoObject **obj)
2069 {
2070         ObjRef *ref;
2071
2072         if (objid == 0) {
2073                 *obj = NULL;
2074                 return ERR_NONE;
2075         }
2076
2077         if (!objrefs)
2078                 return ERR_INVALID_OBJECT;
2079
2080         mono_loader_lock ();
2081
2082         ref = (ObjRef *)g_hash_table_lookup (objrefs, GINT_TO_POINTER (objid));
2083
2084         if (ref) {
2085                 *obj = mono_gchandle_get_target (ref->handle);
2086                 mono_loader_unlock ();
2087                 if (!(*obj))
2088                         return ERR_INVALID_OBJECT;
2089                 return ERR_NONE;
2090         } else {
2091                 mono_loader_unlock ();
2092                 return ERR_INVALID_OBJECT;
2093         }
2094 }
2095
2096 static ErrorCode
2097 get_object (int objid, MonoObject **obj)
2098 {
2099         ErrorCode err = get_object_allow_null (objid, obj);
2100
2101         if (err != ERR_NONE)
2102                 return err;
2103         if (!(*obj))
2104                 return ERR_INVALID_OBJECT;
2105         return ERR_NONE;
2106 }
2107
2108 static inline int
2109 decode_objid (guint8 *buf, guint8 **endbuf, guint8 *limit)
2110 {
2111         return decode_id (buf, endbuf, limit);
2112 }
2113
2114 static inline void
2115 buffer_add_objid (Buffer *buf, MonoObject *o)
2116 {
2117         buffer_add_id (buf, get_objid (o));
2118 }
2119
2120 /*
2121  * IDS
2122  */
2123
2124 typedef enum {
2125         ID_ASSEMBLY = 0,
2126         ID_MODULE = 1,
2127         ID_TYPE = 2,
2128         ID_METHOD = 3,
2129         ID_FIELD = 4,
2130         ID_DOMAIN = 5,
2131         ID_PROPERTY = 6,
2132         ID_NUM
2133 } IdType;
2134
2135 /*
2136  * Represents a runtime structure accessible to the debugger client
2137  */
2138 typedef struct {
2139         /* Unique id used in the wire protocol */
2140         int id;
2141         /* Domain of the runtime structure, NULL if the domain was unloaded */
2142         MonoDomain *domain;
2143         union {
2144                 gpointer val;
2145                 MonoClass *klass;
2146                 MonoMethod *method;
2147                 MonoImage *image;
2148                 MonoAssembly *assembly;
2149                 MonoClassField *field;
2150                 MonoDomain *domain;
2151                 MonoProperty *property;
2152         } data;
2153 } Id;
2154
2155 typedef struct {
2156         /* Maps runtime structure -> Id */
2157         /* Protected by the dbg lock */
2158         GHashTable *val_to_id [ID_NUM];
2159         /* Classes whose class load event has been sent */
2160         /* Protected by the loader lock */
2161         GHashTable *loaded_classes;
2162         /* Maps MonoClass->GPtrArray of file names */
2163         GHashTable *source_files;
2164         /* Maps source file basename -> GSList of classes */
2165         GHashTable *source_file_to_class;
2166         /* Same with ignore-case */
2167         GHashTable *source_file_to_class_ignorecase;
2168 } AgentDomainInfo;
2169
2170 /* Maps id -> Id */
2171 /* Protected by the dbg lock */
2172 static GPtrArray *ids [ID_NUM];
2173
2174 static void
2175 ids_init (void)
2176 {
2177         int i;
2178
2179         for (i = 0; i < ID_NUM; ++i)
2180                 ids [i] = g_ptr_array_new ();
2181 }
2182
2183 static void
2184 ids_cleanup (void)
2185 {
2186         int i, j;
2187
2188         for (i = 0; i < ID_NUM; ++i) {
2189                 if (ids [i]) {
2190                         for (j = 0; j < ids [i]->len; ++j)
2191                                 g_free (g_ptr_array_index (ids [i], j));
2192                         g_ptr_array_free (ids [i], TRUE);
2193                 }
2194                 ids [i] = NULL;
2195         }
2196 }
2197
2198 void
2199 mono_debugger_agent_free_domain_info (MonoDomain *domain)
2200 {
2201         AgentDomainInfo *info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info;
2202         int i, j;
2203         GHashTableIter iter;
2204         GPtrArray *file_names;
2205         char *basename;
2206         GSList *l;
2207
2208         if (info) {
2209                 for (i = 0; i < ID_NUM; ++i)
2210                         if (info->val_to_id [i])
2211                                 g_hash_table_destroy (info->val_to_id [i]);
2212                 g_hash_table_destroy (info->loaded_classes);
2213
2214                 g_hash_table_iter_init (&iter, info->source_files);
2215                 while (g_hash_table_iter_next (&iter, NULL, (void**)&file_names)) {
2216                         for (i = 0; i < file_names->len; ++i)
2217                                 g_free (g_ptr_array_index (file_names, i));
2218                         g_ptr_array_free (file_names, TRUE);
2219                 }
2220
2221                 g_hash_table_iter_init (&iter, info->source_file_to_class);
2222                 while (g_hash_table_iter_next (&iter, (void**)&basename, (void**)&l)) {
2223                         g_free (basename);
2224                         g_slist_free (l);
2225                 }
2226
2227                 g_hash_table_iter_init (&iter, info->source_file_to_class_ignorecase);
2228                 while (g_hash_table_iter_next (&iter, (void**)&basename, (void**)&l)) {
2229                         g_free (basename);
2230                         g_slist_free (l);
2231                 }
2232
2233                 g_free (info);
2234         }
2235
2236         domain_jit_info (domain)->agent_info = NULL;
2237
2238         /* Clear ids referencing structures in the domain */
2239         dbg_lock ();
2240         for (i = 0; i < ID_NUM; ++i) {
2241                 if (ids [i]) {
2242                         for (j = 0; j < ids [i]->len; ++j) {
2243                                 Id *id = (Id *)g_ptr_array_index (ids [i], j);
2244                                 if (id->domain == domain)
2245                                         id->domain = NULL;
2246                         }
2247                 }
2248         }
2249         dbg_unlock ();
2250
2251         mono_loader_lock ();
2252         g_hash_table_remove (domains, domain);
2253         mono_loader_unlock ();
2254 }
2255
2256 static AgentDomainInfo*
2257 get_agent_domain_info (MonoDomain *domain)
2258 {
2259         AgentDomainInfo *info = NULL;
2260
2261         mono_domain_lock (domain);
2262
2263         info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info;
2264         if (!info) {
2265                 info = g_new0 (AgentDomainInfo, 1);
2266                 domain_jit_info (domain)->agent_info = info;
2267                 info->loaded_classes = g_hash_table_new (mono_aligned_addr_hash, NULL);
2268                 info->source_files = g_hash_table_new (mono_aligned_addr_hash, NULL);
2269                 info->source_file_to_class = g_hash_table_new (g_str_hash, g_str_equal);
2270                 info->source_file_to_class_ignorecase = g_hash_table_new (g_str_hash, g_str_equal);
2271         }
2272
2273         mono_domain_unlock (domain);
2274
2275         return info;
2276 }
2277
2278 static int
2279 get_id (MonoDomain *domain, IdType type, gpointer val)
2280 {
2281         Id *id;
2282         AgentDomainInfo *info;
2283
2284         if (val == NULL)
2285                 return 0;
2286
2287         info = get_agent_domain_info (domain);
2288
2289         dbg_lock ();
2290
2291         if (info->val_to_id [type] == NULL)
2292                 info->val_to_id [type] = g_hash_table_new (mono_aligned_addr_hash, NULL);
2293
2294         id = (Id *)g_hash_table_lookup (info->val_to_id [type], val);
2295         if (id) {
2296                 dbg_unlock ();
2297                 return id->id;
2298         }
2299
2300         id = g_new0 (Id, 1);
2301         /* Reserve id 0 */
2302         id->id = ids [type]->len + 1;
2303         id->domain = domain;
2304         id->data.val = val;
2305
2306         g_hash_table_insert (info->val_to_id [type], val, id);
2307         g_ptr_array_add (ids [type], id);
2308
2309         dbg_unlock ();
2310
2311         return id->id;
2312 }
2313
2314 static inline gpointer
2315 decode_ptr_id (guint8 *buf, guint8 **endbuf, guint8 *limit, IdType type, MonoDomain **domain, ErrorCode *err)
2316 {
2317         Id *res;
2318
2319         int id = decode_id (buf, endbuf, limit);
2320
2321         *err = ERR_NONE;
2322         if (domain)
2323                 *domain = NULL;
2324
2325         if (id == 0)
2326                 return NULL;
2327
2328         // FIXME: error handling
2329         dbg_lock ();
2330         g_assert (id > 0 && id <= ids [type]->len);
2331
2332         res = (Id *)g_ptr_array_index (ids [type], GPOINTER_TO_INT (id - 1));
2333         dbg_unlock ();
2334
2335         if (res->domain == NULL || res->domain->state == MONO_APPDOMAIN_UNLOADED) {
2336                 DEBUG_PRINTF (1, "ERR_UNLOADED, id=%d, type=%d.\n", id, type);
2337                 *err = ERR_UNLOADED;
2338                 return NULL;
2339         }
2340
2341         if (domain)
2342                 *domain = res->domain;
2343
2344         return res->data.val;
2345 }
2346
2347 static inline int
2348 buffer_add_ptr_id (Buffer *buf, MonoDomain *domain, IdType type, gpointer val)
2349 {
2350         int id = get_id (domain, type, val);
2351
2352         buffer_add_id (buf, id);
2353         return id;
2354 }
2355
2356 static inline MonoClass*
2357 decode_typeid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
2358 {
2359         MonoClass *klass;
2360
2361         klass = (MonoClass *)decode_ptr_id (buf, endbuf, limit, ID_TYPE, domain, err);
2362         if (G_UNLIKELY (log_level >= 2) && klass) {
2363                 char *s;
2364
2365                 s = mono_type_full_name (&klass->byval_arg);
2366                 DEBUG_PRINTF (2, "[dbg]   recv class [%s]\n", s);
2367                 g_free (s);
2368         }
2369         return klass;
2370 }
2371
2372 static inline MonoAssembly*
2373 decode_assemblyid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
2374 {
2375         return (MonoAssembly *)decode_ptr_id (buf, endbuf, limit, ID_ASSEMBLY, domain, err);
2376 }
2377
2378 static inline MonoImage*
2379 decode_moduleid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
2380 {
2381         return (MonoImage *)decode_ptr_id (buf, endbuf, limit, ID_MODULE, domain, err);
2382 }
2383
2384 static inline MonoMethod*
2385 decode_methodid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
2386 {
2387         MonoMethod *m;
2388
2389         m = (MonoMethod *)decode_ptr_id (buf, endbuf, limit, ID_METHOD, domain, err);
2390         if (G_UNLIKELY (log_level >= 2) && m) {
2391                 char *s;
2392
2393                 s = mono_method_full_name (m, TRUE);
2394                 DEBUG_PRINTF (2, "[dbg]   recv method [%s]\n", s);
2395                 g_free (s);
2396         }
2397         return m;
2398 }
2399
2400 static inline MonoClassField*
2401 decode_fieldid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
2402 {
2403         return (MonoClassField *)decode_ptr_id (buf, endbuf, limit, ID_FIELD, domain, err);
2404 }
2405
2406 static inline MonoDomain*
2407 decode_domainid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
2408 {
2409         return (MonoDomain *)decode_ptr_id (buf, endbuf, limit, ID_DOMAIN, domain, err);
2410 }
2411
2412 static inline MonoProperty*
2413 decode_propertyid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, ErrorCode *err)
2414 {
2415         return (MonoProperty *)decode_ptr_id (buf, endbuf, limit, ID_PROPERTY, domain, err);
2416 }
2417
2418 static inline void
2419 buffer_add_typeid (Buffer *buf, MonoDomain *domain, MonoClass *klass)
2420 {
2421         buffer_add_ptr_id (buf, domain, ID_TYPE, klass);
2422         if (G_UNLIKELY (log_level >= 2) && klass) {
2423                 char *s;
2424
2425                 s = mono_type_full_name (&klass->byval_arg);
2426                 if (is_debugger_thread ())
2427                         DEBUG_PRINTF (2, "[dbg]   send class [%s]\n", s);
2428                 else
2429                         DEBUG_PRINTF (2, "[%p]   send class [%s]\n", (gpointer) (gsize) mono_native_thread_id_get (), s);
2430                 g_free (s);
2431         }
2432 }
2433
2434 static inline void
2435 buffer_add_methodid (Buffer *buf, MonoDomain *domain, MonoMethod *method)
2436 {
2437         buffer_add_ptr_id (buf, domain, ID_METHOD, method);
2438         if (G_UNLIKELY (log_level >= 2) && method) {
2439                 char *s;
2440
2441                 s = mono_method_full_name (method, 1);
2442                 DEBUG_PRINTF (2, "[dbg]   send method [%s]\n", s);
2443                 g_free (s);
2444         }
2445 }
2446
2447 static inline void
2448 buffer_add_assemblyid (Buffer *buf, MonoDomain *domain, MonoAssembly *assembly)
2449 {
2450         int id;
2451
2452         id = buffer_add_ptr_id (buf, domain, ID_ASSEMBLY, assembly);
2453         if (G_UNLIKELY (log_level >= 2) && assembly)
2454                 DEBUG_PRINTF (2, "[dbg]   send assembly [%s][%s][%d]\n", assembly->aname.name, domain->friendly_name, id);
2455 }
2456
2457 static inline void
2458 buffer_add_moduleid (Buffer *buf, MonoDomain *domain, MonoImage *image)
2459 {
2460         buffer_add_ptr_id (buf, domain, ID_MODULE, image);
2461 }
2462
2463 static inline void
2464 buffer_add_fieldid (Buffer *buf, MonoDomain *domain, MonoClassField *field)
2465 {
2466         buffer_add_ptr_id (buf, domain, ID_FIELD, field);
2467 }
2468
2469 static inline void
2470 buffer_add_propertyid (Buffer *buf, MonoDomain *domain, MonoProperty *property)
2471 {
2472         buffer_add_ptr_id (buf, domain, ID_PROPERTY, property);
2473 }
2474
2475 static inline void
2476 buffer_add_domainid (Buffer *buf, MonoDomain *domain)
2477 {
2478         buffer_add_ptr_id (buf, domain, ID_DOMAIN, domain);
2479 }
2480
2481 static void invoke_method (void);
2482
2483 /*
2484  * SUSPEND/RESUME
2485  */
2486
2487 static MonoJitInfo*
2488 get_top_method_ji (gpointer ip, MonoDomain **domain, gpointer *out_ip)
2489 {
2490         MonoJitInfo *ji;
2491
2492         if (out_ip)
2493                 *out_ip = ip;
2494
2495         ji = mini_jit_info_table_find (mono_domain_get (), (char*)ip, domain);
2496         if (!ji) {
2497                 /* Could be an interpreter method */
2498
2499                 MonoLMF *lmf = mono_get_lmf ();
2500                 MonoInterpFrameHandle *frame;
2501
2502                 g_assert (((guint64)lmf->previous_lmf) & 2);
2503                 MonoLMFExt *ext = (MonoLMFExt*)lmf;
2504
2505                 g_assert (ext->interp_exit);
2506                 frame = ext->interp_exit_data;
2507                 ji = mono_interp_frame_get_jit_info (frame);
2508                 if (domain)
2509                         *domain = mono_domain_get ();
2510                 if (out_ip)
2511                         *out_ip = mono_interp_frame_get_ip (frame);
2512         }
2513         return ji;
2514 }
2515
2516 /*
2517  * save_thread_context:
2518  *
2519  *   Set CTX as the current threads context which is used for computing stack traces.
2520  * This function is signal-safe.
2521  */
2522 static void
2523 save_thread_context (MonoContext *ctx)
2524 {
2525         DebuggerTlsData *tls;
2526
2527         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
2528         g_assert (tls);
2529
2530         if (ctx)
2531                 mono_thread_state_init_from_monoctx (&tls->context, ctx);
2532         else
2533                 mono_thread_state_init_from_current (&tls->context);
2534 }
2535
2536 /* Number of threads suspended */
2537 /*
2538  * If this is equal to the size of thread_to_tls, the runtime is considered
2539  * suspended.
2540  */
2541 static gint32 threads_suspend_count;
2542
2543 static MonoCoopMutex suspend_mutex;
2544
2545 /* Cond variable used to wait for suspend_count becoming 0 */
2546 static MonoCoopCond suspend_cond;
2547
2548 /* Semaphore used to wait for a thread becoming suspended */
2549 static MonoCoopSem suspend_sem;
2550
2551 static void
2552 suspend_init (void)
2553 {
2554         mono_coop_mutex_init (&suspend_mutex);
2555         mono_coop_cond_init (&suspend_cond);
2556         mono_coop_sem_init (&suspend_sem, 0);
2557 }
2558
2559 typedef struct
2560 {
2561         StackFrameInfo last_frame;
2562         gboolean last_frame_set;
2563         MonoContext ctx;
2564         gpointer lmf;
2565         MonoDomain *domain;
2566 } GetLastFrameUserData;
2567
2568 static gboolean
2569 get_last_frame (StackFrameInfo *info, MonoContext *ctx, gpointer user_data)
2570 {
2571         GetLastFrameUserData *data = (GetLastFrameUserData *)user_data;
2572
2573         if (info->type == FRAME_TYPE_MANAGED_TO_NATIVE || info->type == FRAME_TYPE_TRAMPOLINE)
2574                 return FALSE;
2575
2576         if (!data->last_frame_set) {
2577                 /* Store the last frame */
2578                 memcpy (&data->last_frame, info, sizeof (StackFrameInfo));
2579                 data->last_frame_set = TRUE;
2580                 return FALSE;
2581         } else {
2582                 /* Store the context/lmf for the frame above the last frame */
2583                 memcpy (&data->ctx, ctx, sizeof (MonoContext));
2584                 data->lmf = info->lmf;
2585                 data->domain = info->domain;
2586                 return TRUE;
2587         }
2588 }
2589
2590 static void
2591 copy_unwind_state_from_frame_data (MonoThreadUnwindState *to, GetLastFrameUserData *data, gpointer jit_tls)
2592 {
2593         memcpy (&to->ctx, &data->ctx, sizeof (MonoContext));
2594
2595         to->unwind_data [MONO_UNWIND_DATA_DOMAIN] = data->domain;
2596         to->unwind_data [MONO_UNWIND_DATA_LMF] = data->lmf;
2597         to->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = jit_tls;
2598         to->valid = TRUE;
2599 }
2600
2601 /*
2602  * thread_interrupt:
2603  *
2604  *   Process interruption of a thread. This should be signal safe.
2605  *
2606  * This always runs in the debugger thread.
2607  */
2608 static void
2609 thread_interrupt (DebuggerTlsData *tls, MonoThreadInfo *info, MonoJitInfo *ji)
2610 {
2611         gpointer ip;
2612         MonoNativeThreadId tid;
2613
2614         g_assert (info);
2615
2616         ip = MONO_CONTEXT_GET_IP (&mono_thread_info_get_suspend_state (info)->ctx);
2617         tid = mono_thread_info_get_tid (info);
2618
2619         // FIXME: Races when the thread leaves managed code before hitting a single step
2620         // event.
2621
2622         if (ji && !ji->is_trampoline) {
2623                 /* Running managed code, will be suspended by the single step code */
2624                 DEBUG_PRINTF (1, "[%p] Received interrupt while at %s(%p), continuing.\n", (gpointer)(gsize)tid, jinfo_get_method (ji)->name, ip);
2625         } else {
2626                 /*
2627                  * Running native code, will be suspended when it returns to/enters
2628                  * managed code. Treat it as already suspended.
2629                  * This might interrupt the code in process_single_step_inner (), we use the
2630                  * tls->suspending flag to avoid races when that happens.
2631                  */
2632                 if (!tls->suspended && !tls->suspending) {
2633                         GetLastFrameUserData data;
2634
2635                         // FIXME: printf is not signal safe, but this is only used during
2636                         // debugger debugging
2637                         if (ip)
2638                                 DEBUG_PRINTF (1, "[%p] Received interrupt while at %p, treating as suspended.\n", (gpointer)(gsize)tid, ip);
2639                         //save_thread_context (&ctx);
2640
2641                         if (!tls->thread)
2642                                 /* Already terminated */
2643                                 return;
2644
2645                         /*
2646                          * We are in a difficult position: we want to be able to provide stack
2647                          * traces for this thread, but we can't use the current ctx+lmf, since
2648                          * the thread is still running, so it might return to managed code,
2649                          * making these invalid.
2650                          * So we start a stack walk and save the first frame, along with the
2651                          * parent frame's ctx+lmf. This (hopefully) works because the thread will be
2652                          * suspended when it returns to managed code, so the parent's ctx should
2653                          * remain valid.
2654                          */
2655                         MonoThreadUnwindState *state = mono_thread_info_get_suspend_state (info);
2656
2657                         data.last_frame_set = FALSE;
2658                         mono_get_eh_callbacks ()->mono_walk_stack_with_state (get_last_frame, state, MONO_UNWIND_SIGNAL_SAFE, &data);
2659                         if (data.last_frame_set) {
2660                                 gpointer jit_tls = ((MonoThreadInfo*)tls->thread->thread_info)->jit_data;
2661
2662                                 memcpy (&tls->async_last_frame, &data.last_frame, sizeof (StackFrameInfo));
2663
2664                                 if (data.last_frame.type == FRAME_TYPE_INTERP_TO_MANAGED) {
2665                                         /*
2666                                          * Store the current lmf instead of the parent one, since that
2667                                          * contains the interp exit data.
2668                                          */
2669                                         data.lmf = state->unwind_data [MONO_UNWIND_DATA_LMF];
2670                                 }
2671
2672                                 copy_unwind_state_from_frame_data (&tls->async_state, &data, jit_tls);
2673                                 copy_unwind_state_from_frame_data (&tls->context, &data, jit_tls);
2674                         } else {
2675                                 tls->async_state.valid = FALSE;
2676                         }
2677
2678                         mono_memory_barrier ();
2679
2680                         tls->suspended = TRUE;
2681                         mono_coop_sem_post (&suspend_sem);
2682                 }
2683         }
2684 }
2685
2686 /*
2687  * reset_native_thread_suspend_state:
2688  *
2689  *   Reset the suspended flag and state on native threads
2690  */
2691 static void
2692 reset_native_thread_suspend_state (gpointer key, gpointer value, gpointer user_data)
2693 {
2694         DebuggerTlsData *tls = (DebuggerTlsData *)value;
2695
2696         if (!tls->really_suspended && tls->suspended) {
2697                 tls->suspended = FALSE;
2698                 /*
2699                  * The thread might still be running if it was executing native code, so the state won't be invalided by
2700                  * suspend_current ().
2701                  */
2702                 tls->context.valid = FALSE;
2703                 tls->async_state.valid = FALSE;
2704                 invalidate_frames (tls);
2705         }
2706 }
2707
2708 typedef struct {
2709         DebuggerTlsData *tls;
2710         gboolean valid_info;
2711 } InterruptData;
2712
2713 static SuspendThreadResult
2714 debugger_interrupt_critical (MonoThreadInfo *info, gpointer user_data)
2715 {
2716         InterruptData *data = (InterruptData *)user_data;
2717         MonoJitInfo *ji;
2718
2719         data->valid_info = TRUE;
2720         ji = mono_jit_info_table_find_internal (
2721                         (MonoDomain *)mono_thread_info_get_suspend_state (info)->unwind_data [MONO_UNWIND_DATA_DOMAIN],
2722                         (char *)MONO_CONTEXT_GET_IP (&mono_thread_info_get_suspend_state (info)->ctx),
2723                         TRUE,
2724                         TRUE);
2725
2726         /* This is signal safe */
2727         thread_interrupt (data->tls, info, ji);
2728         return MonoResumeThread;
2729 }
2730
2731 /*
2732  * notify_thread:
2733  *
2734  *   Notify a thread that it needs to suspend.
2735  */
2736 static void
2737 notify_thread (gpointer key, gpointer value, gpointer user_data)
2738 {
2739         MonoInternalThread *thread = (MonoInternalThread *)key;
2740         DebuggerTlsData *tls = (DebuggerTlsData *)value;
2741         MonoNativeThreadId tid = MONO_UINT_TO_NATIVE_THREAD_ID (thread->tid);
2742
2743         if (mono_thread_internal_is_current (thread) || tls->terminated)
2744                 return;
2745
2746         DEBUG_PRINTF (1, "[%p] Interrupting %p...\n", (gpointer) (gsize) mono_native_thread_id_get (), (gpointer)tid);
2747
2748         /* This is _not_ equivalent to mono_thread_internal_abort () */
2749         InterruptData interrupt_data = { 0 };
2750         interrupt_data.tls = tls;
2751
2752         mono_thread_info_safe_suspend_and_run ((MonoNativeThreadId)(gpointer)(gsize)thread->tid, FALSE, debugger_interrupt_critical, &interrupt_data);
2753         if (!interrupt_data.valid_info) {
2754                 DEBUG_PRINTF (1, "[%p] mono_thread_info_suspend_sync () failed for %p...\n", (gpointer) (gsize) mono_native_thread_id_get (), (gpointer)tid);
2755                 /*
2756                  * Attached thread which died without detaching.
2757                  */
2758                 tls->terminated = TRUE;
2759         }
2760 }
2761
2762 static void
2763 process_suspend (DebuggerTlsData *tls, MonoContext *ctx)
2764 {
2765         guint8 *ip = (guint8 *)MONO_CONTEXT_GET_IP (ctx);
2766         MonoJitInfo *ji;
2767         MonoMethod *method;
2768
2769         if (mono_loader_lock_is_owned_by_self ()) {
2770                 /*
2771                  * Shortcut for the check in suspend_current (). This speeds up processing
2772                  * when executing long running code inside the loader lock, i.e. assembly load
2773                  * hooks.
2774                  */
2775                 return;
2776         }
2777
2778         if (is_debugger_thread ())
2779                 return;
2780
2781         /* Prevent races with mono_debugger_agent_thread_interrupt () */
2782         if (suspend_count - tls->resume_count > 0)
2783                 tls->suspending = TRUE;
2784
2785         DEBUG_PRINTF (1, "[%p] Received single step event for suspending.\n", (gpointer) (gsize) mono_native_thread_id_get ());
2786
2787         if (suspend_count - tls->resume_count == 0) {
2788                 /*
2789                  * We are executing a single threaded invoke but the single step for
2790                  * suspending is still active.
2791                  * FIXME: This slows down single threaded invokes.
2792                  */
2793                 DEBUG_PRINTF (1, "[%p] Ignored during single threaded invoke.\n", (gpointer) (gsize) mono_native_thread_id_get ());
2794                 return;
2795         }
2796
2797         ji = get_top_method_ji (ip, NULL, NULL);
2798         g_assert (ji);
2799         /* Can't suspend in these methods */
2800         method = jinfo_get_method (ji);
2801         if (method->klass == mono_defaults.string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy")))
2802                 return;
2803
2804         save_thread_context (ctx);
2805
2806         suspend_current ();
2807 }
2808
2809 /*
2810  * suspend_vm:
2811  *
2812  * Increase the suspend count of the VM. While the suspend count is greater
2813  * than 0, runtime threads are suspended at certain points during execution.
2814  */
2815 static void
2816 suspend_vm (void)
2817 {
2818         mono_loader_lock ();
2819
2820         mono_coop_mutex_lock (&suspend_mutex);
2821
2822         suspend_count ++;
2823
2824         DEBUG_PRINTF (1, "[%p] Suspending vm...\n", (gpointer) (gsize) mono_native_thread_id_get ());
2825
2826         if (suspend_count == 1) {
2827                 // FIXME: Is it safe to call this inside the lock ?
2828                 start_single_stepping ();
2829                 mono_g_hash_table_foreach (thread_to_tls, notify_thread, NULL);
2830         }
2831
2832         mono_coop_mutex_unlock (&suspend_mutex);
2833
2834         if (suspend_count == 1)
2835                 /*
2836                  * Suspend creation of new threadpool threads, since they cannot run
2837                  */
2838                 mono_threadpool_suspend ();
2839
2840         mono_loader_unlock ();
2841 }
2842
2843 /*
2844  * resume_vm:
2845  *
2846  * Decrease the suspend count of the VM. If the count reaches 0, runtime threads
2847  * are resumed.
2848  */
2849 static void
2850 resume_vm (void)
2851 {
2852         g_assert (is_debugger_thread ());
2853
2854         mono_loader_lock ();
2855
2856         mono_coop_mutex_lock (&suspend_mutex);
2857
2858         g_assert (suspend_count > 0);
2859         suspend_count --;
2860
2861         DEBUG_PRINTF (1, "[%p] Resuming vm, suspend count=%d...\n", (gpointer) (gsize) mono_native_thread_id_get (), suspend_count);
2862
2863         if (suspend_count == 0) {
2864                 // FIXME: Is it safe to call this inside the lock ?
2865                 stop_single_stepping ();
2866                 mono_g_hash_table_foreach (thread_to_tls, reset_native_thread_suspend_state, NULL);
2867         }
2868
2869         /* Signal this even when suspend_count > 0, since some threads might have resume_count > 0 */
2870         mono_coop_cond_broadcast (&suspend_cond);
2871
2872         mono_coop_mutex_unlock (&suspend_mutex);
2873         //g_assert (err == 0);
2874
2875         if (suspend_count == 0)
2876                 mono_threadpool_resume ();
2877
2878         mono_loader_unlock ();
2879 }
2880
2881 /*
2882  * resume_thread:
2883  *
2884  *   Resume just one thread.
2885  */
2886 static void
2887 resume_thread (MonoInternalThread *thread)
2888 {
2889         DebuggerTlsData *tls;
2890
2891         g_assert (is_debugger_thread ());
2892
2893         mono_loader_lock ();
2894
2895         tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
2896         g_assert (tls);
2897
2898         mono_coop_mutex_lock (&suspend_mutex);
2899
2900         g_assert (suspend_count > 0);
2901
2902         DEBUG_PRINTF (1, "[sdb] Resuming thread %p...\n", (gpointer)(gssize)thread->tid);
2903
2904         tls->resume_count += suspend_count;
2905
2906         /*
2907          * Signal suspend_count without decreasing suspend_count, the threads will wake up
2908          * but only the one whose resume_count field is > 0 will be resumed.
2909          */
2910         mono_coop_cond_broadcast (&suspend_cond);
2911
2912         mono_coop_mutex_unlock (&suspend_mutex);
2913         //g_assert (err == 0);
2914
2915         mono_loader_unlock ();
2916 }
2917
2918 static void
2919 free_frames (StackFrame **frames, int nframes)
2920 {
2921         int i;
2922
2923         for (i = 0; i < nframes; ++i) {
2924                 if (frames [i]->jit)
2925                         mono_debug_free_method_jit_info (frames [i]->jit);
2926                 g_free (frames [i]);
2927         }
2928         g_free (frames);
2929 }
2930
2931 static void
2932 invalidate_frames (DebuggerTlsData *tls)
2933 {
2934         if (!tls)
2935                 tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
2936         g_assert (tls);
2937
2938         free_frames (tls->frames, tls->frame_count);
2939         tls->frame_count = 0;
2940         tls->frames = NULL;
2941
2942         free_frames (tls->restore_frames, tls->restore_frame_count);
2943         tls->restore_frame_count = 0;
2944         tls->restore_frames = NULL;
2945 }
2946
2947 /*
2948  * suspend_current:
2949  *
2950  *   Suspend the current thread until the runtime is resumed. If the thread has a
2951  * pending invoke, then the invoke is executed before this function returns.
2952  */
2953 static void
2954 suspend_current (void)
2955 {
2956         DebuggerTlsData *tls;
2957
2958         g_assert (!is_debugger_thread ());
2959
2960         if (mono_loader_lock_is_owned_by_self ()) {
2961                 /*
2962                  * If we own the loader mutex, can't suspend until we release it, since the
2963                  * whole runtime can deadlock otherwise.
2964                  */
2965                 return;
2966         }
2967
2968         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
2969         g_assert (tls);
2970
2971         mono_coop_mutex_lock (&suspend_mutex);
2972
2973         tls->suspending = FALSE;
2974         tls->really_suspended = TRUE;
2975
2976         if (!tls->suspended) {
2977                 tls->suspended = TRUE;
2978                 mono_coop_sem_post (&suspend_sem);
2979         }
2980
2981         DEBUG_PRINTF (1, "[%p] Suspended.\n", (gpointer) (gsize) mono_native_thread_id_get ());
2982
2983         while (suspend_count - tls->resume_count > 0) {
2984                 mono_coop_cond_wait (&suspend_cond, &suspend_mutex);
2985         }
2986
2987         tls->suspended = FALSE;
2988         tls->really_suspended = FALSE;
2989
2990         threads_suspend_count --;
2991
2992         mono_coop_mutex_unlock (&suspend_mutex);
2993
2994         DEBUG_PRINTF (1, "[%p] Resumed.\n", (gpointer) (gsize) mono_native_thread_id_get ());
2995
2996         if (tls->pending_invoke) {
2997                 /* Save the original context */
2998                 tls->pending_invoke->has_ctx = TRUE;
2999                 tls->pending_invoke->ctx = tls->context.ctx;
3000
3001                 invoke_method ();
3002         }
3003
3004         /* The frame info becomes invalid after a resume */
3005         tls->context.valid = FALSE;
3006         tls->async_state.valid = FALSE;
3007         invalidate_frames (tls);
3008 }
3009
3010 static void
3011 count_thread (gpointer key, gpointer value, gpointer user_data)
3012 {
3013         DebuggerTlsData *tls = (DebuggerTlsData *)value;
3014
3015         if (!tls->suspended && !tls->terminated && !mono_thread_internal_is_current (tls->thread))
3016                 *(int*)user_data = *(int*)user_data + 1;
3017 }
3018
3019 static int
3020 count_threads_to_wait_for (void)
3021 {
3022         int count = 0;
3023
3024         mono_loader_lock ();
3025         mono_g_hash_table_foreach (thread_to_tls, count_thread, &count);
3026         mono_loader_unlock ();
3027
3028         return count;
3029 }
3030
3031 /*
3032  * wait_for_suspend:
3033  *
3034  *   Wait until the runtime is completely suspended.
3035  */
3036 static void
3037 wait_for_suspend (void)
3038 {
3039         int nthreads, nwait, err;
3040         gboolean waited = FALSE;
3041
3042         // FIXME: Threads starting/stopping ?
3043         mono_loader_lock ();
3044         nthreads = mono_g_hash_table_size (thread_to_tls);
3045         mono_loader_unlock ();
3046
3047         while (TRUE) {
3048                 nwait = count_threads_to_wait_for ();
3049                 if (nwait) {
3050                         DEBUG_PRINTF (1, "Waiting for %d(%d) threads to suspend...\n", nwait, nthreads);
3051                         err = mono_coop_sem_wait (&suspend_sem, MONO_SEM_FLAGS_NONE);
3052                         g_assert (err == 0);
3053                         waited = TRUE;
3054                 } else {
3055                         break;
3056                 }
3057         }
3058
3059         if (waited)
3060                 DEBUG_PRINTF (1, "%d threads suspended.\n", nthreads);
3061 }
3062
3063 /*
3064  * is_suspended:
3065  *
3066  *   Return whenever the runtime is suspended.
3067  */
3068 static gboolean
3069 is_suspended (void)
3070 {
3071         return count_threads_to_wait_for () == 0;
3072 }
3073
3074 static void
3075 no_seq_points_found (MonoMethod *method, int offset)
3076 {
3077         /*
3078          * This can happen in full-aot mode with assemblies AOTed without the 'soft-debug' option to save space.
3079          */
3080         printf ("Unable to find seq points for method '%s', offset 0x%x.\n", mono_method_full_name (method, TRUE), offset);
3081 }
3082
3083 typedef struct {
3084         DebuggerTlsData *tls;
3085         GSList *frames;
3086 } ComputeFramesUserData;
3087
3088 static gboolean
3089 process_frame (StackFrameInfo *info, MonoContext *ctx, gpointer user_data)
3090 {
3091         ComputeFramesUserData *ud = (ComputeFramesUserData *)user_data;
3092         StackFrame *frame;
3093         MonoMethod *method, *actual_method, *api_method;
3094         SeqPoint sp;
3095         int flags = 0;
3096
3097         if (info->type != FRAME_TYPE_MANAGED && info->type != FRAME_TYPE_INTERP) {
3098                 if (info->type == FRAME_TYPE_DEBUGGER_INVOKE) {
3099                         /* Mark the last frame as an invoke frame */
3100                         if (ud->frames)
3101                                 ((StackFrame*)g_slist_last (ud->frames)->data)->flags |= FRAME_FLAG_DEBUGGER_INVOKE;
3102                 }
3103                 return FALSE;
3104         }
3105
3106         if (info->ji)
3107                 method = jinfo_get_method (info->ji);
3108         else
3109                 method = info->method;
3110         actual_method = info->actual_method;
3111         api_method = method;
3112
3113         if (!method)
3114                 return FALSE;
3115
3116         if (!method || (method->wrapper_type && method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD && method->wrapper_type != MONO_WRAPPER_MANAGED_TO_NATIVE))
3117                 return FALSE;
3118
3119         if (info->il_offset == -1) {
3120                 /* mono_debug_il_offset_from_address () doesn't seem to be precise enough (#2092) */
3121                 if (ud->frames == NULL) {
3122                         if (mono_find_prev_seq_point_for_native_offset (info->domain, method, info->native_offset, NULL, &sp))
3123                                 info->il_offset = sp.il_offset;
3124                 }
3125                 if (info->il_offset == -1)
3126                         info->il_offset = mono_debug_il_offset_from_address (method, info->domain, info->native_offset);
3127         }
3128
3129         DEBUG_PRINTF (1, "\tFrame: %s:[il=0x%x, native=0x%x] %d\n", mono_method_full_name (method, TRUE), info->il_offset, info->native_offset, info->managed);
3130
3131         if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
3132                 if (!CHECK_PROTOCOL_VERSION (2, 17))
3133                         /* Older clients can't handle this flag */
3134                         return FALSE;
3135                 api_method = mono_marshal_method_from_wrapper (method);
3136                 if (!api_method)
3137                         return FALSE;
3138                 actual_method = api_method;
3139                 flags |= FRAME_FLAG_NATIVE_TRANSITION;
3140         }
3141
3142         frame = g_new0 (StackFrame, 1);
3143         frame->method = method;
3144         frame->actual_method = actual_method;
3145         frame->api_method = api_method;
3146         frame->il_offset = info->il_offset;
3147         frame->native_offset = info->native_offset;
3148         frame->flags = flags;
3149         frame->ji = info->ji;
3150         frame->interp_frame = info->interp_frame;
3151         if (info->reg_locations)
3152                 memcpy (frame->reg_locations, info->reg_locations, MONO_MAX_IREGS * sizeof (mgreg_t*));
3153         if (ctx) {
3154                 frame->ctx = *ctx;
3155                 frame->has_ctx = TRUE;
3156         }
3157         frame->domain = info->domain;
3158
3159         ud->frames = g_slist_append (ud->frames, frame);
3160
3161         return FALSE;
3162 }
3163
3164 static gboolean
3165 process_filter_frame (StackFrameInfo *info, MonoContext *ctx, gpointer user_data)
3166 {
3167         ComputeFramesUserData *ud = (ComputeFramesUserData *)user_data;
3168
3169         /*
3170          * 'tls->filter_ctx' is the location of the throw site.
3171          *
3172          * mono_walk_stack() will never actually hit the throw site, but unwind
3173          * directly from the filter to the call site; we abort stack unwinding here
3174          * once this happens and resume from the throw site.
3175          */
3176
3177         if (MONO_CONTEXT_GET_SP (ctx) >= MONO_CONTEXT_GET_SP (&ud->tls->filter_state.ctx))
3178                 return TRUE;
3179
3180         return process_frame (info, ctx, user_data);
3181 }
3182
3183 /*
3184  * Return a malloc-ed list of StackFrame structures.
3185  */
3186 static StackFrame**
3187 compute_frame_info_from (MonoInternalThread *thread, DebuggerTlsData *tls, MonoThreadUnwindState *state, int *out_nframes)
3188 {
3189         ComputeFramesUserData user_data;
3190         MonoUnwindOptions opts = (MonoUnwindOptions)(MONO_UNWIND_DEFAULT | MONO_UNWIND_REG_LOCATIONS);
3191         StackFrame **res;
3192         int i, nframes;
3193         GSList *l;
3194
3195         user_data.tls = tls;
3196         user_data.frames = NULL;
3197
3198         mono_walk_stack_with_state (process_frame, state, opts, &user_data);
3199
3200         nframes = g_slist_length (user_data.frames);
3201         res = g_new0 (StackFrame*, nframes);
3202         l = user_data.frames;
3203         for (i = 0; i < nframes; ++i) {
3204                 res [i] = (StackFrame *)l->data;
3205                 l = l->next;
3206         }
3207         *out_nframes = nframes;
3208
3209         return res;
3210 }
3211
3212 static void
3213 compute_frame_info (MonoInternalThread *thread, DebuggerTlsData *tls)
3214 {
3215         ComputeFramesUserData user_data;
3216         GSList *tmp;
3217         int i, findex, new_frame_count;
3218         StackFrame **new_frames, *f;
3219         MonoUnwindOptions opts = (MonoUnwindOptions)(MONO_UNWIND_DEFAULT | MONO_UNWIND_REG_LOCATIONS);
3220
3221         // FIXME: Locking on tls
3222         if (tls->frames && tls->frames_up_to_date)
3223                 return;
3224
3225         DEBUG_PRINTF (1, "Frames for %p(tid=%lx):\n", thread, (glong)thread->tid);
3226
3227         user_data.tls = tls;
3228         user_data.frames = NULL;
3229         if (tls->terminated) {
3230                 tls->frame_count = 0;
3231                 return;
3232         } if (!tls->really_suspended && tls->async_state.valid) {
3233                 /* Have to use the state saved by the signal handler */
3234                 process_frame (&tls->async_last_frame, NULL, &user_data);
3235                 mono_walk_stack_with_state (process_frame, &tls->async_state, opts, &user_data);
3236         } else if (tls->filter_state.valid) {
3237                 /*
3238                  * We are inside an exception filter.
3239                  *
3240                  * First we add all the frames from inside the filter; 'tls->ctx' has the current context.
3241                  */
3242                 if (tls->context.valid)
3243                         mono_walk_stack_with_state (process_filter_frame, &tls->context, opts, &user_data);
3244                 /*
3245                  * After that, we resume unwinding from the location where the exception has been thrown.
3246                  */
3247                 mono_walk_stack_with_state (process_frame, &tls->filter_state, opts, &user_data);
3248         } else if (tls->context.valid) {
3249                 mono_walk_stack_with_state (process_frame, &tls->context, opts, &user_data);
3250         } else {
3251                 // FIXME:
3252                 tls->frame_count = 0;
3253                 return;
3254         }
3255
3256         new_frame_count = g_slist_length (user_data.frames);
3257         new_frames = g_new0 (StackFrame*, new_frame_count);
3258         findex = 0;
3259         for (tmp = user_data.frames; tmp; tmp = tmp->next) {
3260                 f = (StackFrame *)tmp->data;
3261
3262                 /*
3263                  * Reuse the id for already existing stack frames, so invokes don't invalidate
3264                  * the still valid stack frames.
3265                  */
3266                 for (i = 0; i < tls->frame_count; ++i) {
3267                         if (MONO_CONTEXT_GET_SP (&tls->frames [i]->ctx) == MONO_CONTEXT_GET_SP (&f->ctx)) {
3268                                 f->id = tls->frames [i]->id;
3269                                 break;
3270                         }
3271                 }
3272
3273                 if (i >= tls->frame_count)
3274                         f->id = InterlockedIncrement (&frame_id);
3275
3276                 new_frames [findex ++] = f;
3277         }
3278
3279         g_slist_free (user_data.frames);
3280
3281         invalidate_frames (tls);
3282
3283         tls->frames = new_frames;
3284         tls->frame_count = new_frame_count;
3285         tls->frames_up_to_date = TRUE;
3286 }
3287
3288 /*
3289  * GHFunc to emit an appdomain creation event
3290  * @param key Don't care
3291  * @param value A loaded appdomain
3292  * @param user_data Don't care
3293  */
3294 static void
3295 emit_appdomain_load (gpointer key, gpointer value, gpointer user_data)
3296 {
3297         process_profiler_event (EVENT_KIND_APPDOMAIN_CREATE, value);
3298         g_hash_table_foreach (get_agent_domain_info ((MonoDomain *)value)->loaded_classes, emit_type_load, NULL);
3299 }
3300
3301 /*
3302  * GHFunc to emit a thread start event
3303  * @param key A thread id
3304  * @param value A thread object
3305  * @param user_data Don't care
3306  */
3307 static void
3308 emit_thread_start (gpointer key, gpointer value, gpointer user_data)
3309 {
3310         g_assert (!mono_native_thread_id_equals (MONO_UINT_TO_NATIVE_THREAD_ID (GPOINTER_TO_UINT (key)), debugger_thread_id));
3311         process_profiler_event (EVENT_KIND_THREAD_START, value);
3312 }
3313
3314 /*
3315  * GFunc to emit an assembly load event
3316  * @param value A loaded assembly
3317  * @param user_data Don't care
3318  */
3319 static void
3320 emit_assembly_load (gpointer value, gpointer user_data)
3321 {
3322         process_profiler_event (EVENT_KIND_ASSEMBLY_LOAD, value);
3323 }
3324
3325 /*
3326  * GFunc to emit a type load event
3327  * @param value A loaded type
3328  * @param user_data Don't care
3329  */
3330 static void
3331 emit_type_load (gpointer key, gpointer value, gpointer user_data)
3332 {
3333         process_profiler_event (EVENT_KIND_TYPE_LOAD, value);
3334 }
3335
3336 static char*
3337 strdup_tolower (char *s)
3338 {
3339         char *s2, *p;
3340
3341         s2 = g_strdup (s);
3342         for (p = s2; *p; ++p)
3343                 *p = tolower (*p);
3344         return s2;
3345 }
3346
3347 /*
3348  * Same as g_path_get_basename () but handles windows paths as well,
3349  * which can occur in .mdb files created by pdb2mdb.
3350  */
3351 static char*
3352 dbg_path_get_basename (const char *filename)
3353 {
3354         char *r;
3355
3356         if (!filename || strchr (filename, '/') || !strchr (filename, '\\'))
3357                 return g_path_get_basename (filename);
3358
3359         /* From gpath.c */
3360
3361         /* No separator -> filename */
3362         r = strrchr (filename, '\\');
3363         if (r == NULL)
3364                 return g_strdup (filename);
3365
3366         /* Trailing slash, remove component */
3367         if (r [1] == 0){
3368                 char *copy = g_strdup (filename);
3369                 copy [r-filename] = 0;
3370                 r = strrchr (copy, '\\');
3371
3372                 if (r == NULL){
3373                         g_free (copy);
3374                         return g_strdup ("/");
3375                 }
3376                 r = g_strdup (&r[1]);
3377                 g_free (copy);
3378                 return r;
3379         }
3380
3381         return g_strdup (&r[1]);
3382 }
3383
3384 static void
3385 init_jit_info_dbg_attrs (MonoJitInfo *ji)
3386 {
3387         static MonoClass *hidden_klass, *step_through_klass, *non_user_klass;
3388         MonoError error;
3389         MonoCustomAttrInfo *ainfo;
3390
3391         if (ji->dbg_attrs_inited)
3392                 return;
3393
3394         if (!hidden_klass)
3395                 hidden_klass = mono_class_load_from_name (mono_defaults.corlib, "System.Diagnostics", "DebuggerHiddenAttribute");
3396
3397         if (!step_through_klass)
3398                 step_through_klass = mono_class_load_from_name (mono_defaults.corlib, "System.Diagnostics", "DebuggerStepThroughAttribute");
3399
3400         if (!non_user_klass)
3401                 non_user_klass = mono_class_load_from_name (mono_defaults.corlib, "System.Diagnostics", "DebuggerNonUserCodeAttribute");
3402
3403         ainfo = mono_custom_attrs_from_method_checked (jinfo_get_method (ji), &error);
3404         mono_error_cleanup (&error); /* FIXME don't swallow the error? */
3405         if (ainfo) {
3406                 if (mono_custom_attrs_has_attr (ainfo, hidden_klass))
3407                         ji->dbg_hidden = TRUE;
3408                 if (mono_custom_attrs_has_attr (ainfo, step_through_klass))
3409                         ji->dbg_step_through = TRUE;
3410                 if (mono_custom_attrs_has_attr (ainfo, non_user_klass))
3411                         ji->dbg_non_user_code = TRUE;
3412                 mono_custom_attrs_free (ainfo);
3413         }
3414
3415         ainfo = mono_custom_attrs_from_class_checked (jinfo_get_method (ji)->klass, &error);
3416         mono_error_cleanup (&error); /* FIXME don't swallow the error? */
3417         if (ainfo) {
3418                 if (mono_custom_attrs_has_attr (ainfo, step_through_klass))
3419                         ji->dbg_step_through = TRUE;
3420                 if (mono_custom_attrs_has_attr (ainfo, non_user_klass))
3421                         ji->dbg_non_user_code = TRUE;
3422                 mono_custom_attrs_free (ainfo);
3423         }
3424
3425         mono_memory_barrier ();
3426         ji->dbg_attrs_inited = TRUE;
3427 }
3428
3429 /*
3430  * EVENT HANDLING
3431  */
3432
3433 /*
3434  * create_event_list:
3435  *
3436  *   Return a list of event request ids matching EVENT, starting from REQS, which
3437  * can be NULL to include all event requests. Set SUSPEND_POLICY to the suspend
3438  * policy.
3439  * We return request ids, instead of requests, to simplify threading, since
3440  * requests could be deleted anytime when the loader lock is not held.
3441  * LOCKING: Assumes the loader lock is held.
3442  */
3443 static GSList*
3444 create_event_list (EventKind event, GPtrArray *reqs, MonoJitInfo *ji, EventInfo *ei, int *suspend_policy)
3445 {
3446         int i, j;
3447         GSList *events = NULL;
3448
3449         *suspend_policy = SUSPEND_POLICY_NONE;
3450
3451         if (!reqs)
3452                 reqs = event_requests;
3453
3454         if (!reqs)
3455                 return NULL;
3456
3457         for (i = 0; i < reqs->len; ++i) {
3458                 EventRequest *req = (EventRequest *)g_ptr_array_index (reqs, i);
3459                 if (req->event_kind == event) {
3460                         gboolean filtered = FALSE;
3461
3462                         /* Apply filters */
3463                         for (j = 0; j < req->nmodifiers; ++j) {
3464                                 Modifier *mod = &req->modifiers [j];
3465
3466                                 if (mod->kind == MOD_KIND_COUNT) {
3467                                         filtered = TRUE;
3468                                         if (mod->data.count > 0) {
3469                                                 if (mod->data.count > 0) {
3470                                                         mod->data.count --;
3471                                                         if (mod->data.count == 0)
3472                                                                 filtered = FALSE;
3473                                                 }
3474                                         }
3475                                 } else if (mod->kind == MOD_KIND_THREAD_ONLY) {
3476                                         if (mod->data.thread != mono_thread_internal_current ())
3477                                                 filtered = TRUE;
3478                                 } else if (mod->kind == MOD_KIND_EXCEPTION_ONLY && ei) {
3479                                         if (mod->data.exc_class && mod->subclasses && !mono_class_is_assignable_from (mod->data.exc_class, ei->exc->vtable->klass))
3480                                                 filtered = TRUE;
3481                                         if (mod->data.exc_class && !mod->subclasses && mod->data.exc_class != ei->exc->vtable->klass)
3482                                                 filtered = TRUE;
3483                                         if (ei->caught && !mod->caught)
3484                                                 filtered = TRUE;
3485                                         if (!ei->caught && !mod->uncaught)
3486                                                 filtered = TRUE;
3487                                 } else if (mod->kind == MOD_KIND_ASSEMBLY_ONLY && ji) {
3488                                         int k;
3489                                         gboolean found = FALSE;
3490                                         MonoAssembly **assemblies = mod->data.assemblies;
3491
3492                                         if (assemblies) {
3493                                                 for (k = 0; assemblies [k]; ++k)
3494                                                         if (assemblies [k] == jinfo_get_method (ji)->klass->image->assembly)
3495                                                                 found = TRUE;
3496                                         }
3497                                         if (!found)
3498                                                 filtered = TRUE;
3499                                 } else if (mod->kind == MOD_KIND_SOURCE_FILE_ONLY && ei && ei->klass) {
3500                                         gpointer iter = NULL;
3501                                         MonoMethod *method;
3502                                         MonoDebugSourceInfo *sinfo;
3503                                         char *source_file, *s;
3504                                         gboolean found = FALSE;
3505                                         int i;
3506                                         GPtrArray *source_file_list;
3507
3508                                         while ((method = mono_class_get_methods (ei->klass, &iter))) {
3509                                                 MonoDebugMethodInfo *minfo = mono_debug_lookup_method (method);
3510
3511                                                 if (minfo) {
3512                                                         mono_debug_get_seq_points (minfo, &source_file, &source_file_list, NULL, NULL, NULL);
3513                                                         for (i = 0; i < source_file_list->len; ++i) {
3514                                                                 sinfo = (MonoDebugSourceInfo *)g_ptr_array_index (source_file_list, i);
3515                                                                 /*
3516                                                                  * Do a case-insesitive match by converting the file name to
3517                                                                  * lowercase.
3518                                                                  */
3519                                                                 s = strdup_tolower (sinfo->source_file);
3520                                                                 if (g_hash_table_lookup (mod->data.source_files, s))
3521                                                                         found = TRUE;
3522                                                                 else {
3523                                                                         char *s2 = dbg_path_get_basename (sinfo->source_file);
3524                                                                         char *s3 = strdup_tolower (s2);
3525
3526                                                                         if (g_hash_table_lookup (mod->data.source_files, s3))
3527                                                                                 found = TRUE;
3528                                                                         g_free (s2);
3529                                                                         g_free (s3);
3530                                                                 }
3531                                                                 g_free (s);
3532                                                         }
3533                                                         g_ptr_array_free (source_file_list, TRUE);
3534                                                 }
3535                                         }
3536                                         if (!found)
3537                                                 filtered = TRUE;
3538                                 } else if (mod->kind == MOD_KIND_TYPE_NAME_ONLY && ei && ei->klass) {
3539                                         char *s;
3540
3541                                         s = mono_type_full_name (&ei->klass->byval_arg);
3542                                         if (!g_hash_table_lookup (mod->data.type_names, s))
3543                                                 filtered = TRUE;
3544                                         g_free (s);
3545                                 } else if (mod->kind == MOD_KIND_STEP) {
3546                                         if ((mod->data.filter & STEP_FILTER_STATIC_CTOR) && ji &&
3547                                                 (jinfo_get_method (ji)->flags & METHOD_ATTRIBUTE_SPECIAL_NAME) &&
3548                                                 !strcmp (jinfo_get_method (ji)->name, ".cctor") &&
3549                                                 (jinfo_get_method (ji) != ((SingleStepReq*)req->info)->start_method))
3550                                                 filtered = TRUE;
3551                                         if ((mod->data.filter & STEP_FILTER_DEBUGGER_HIDDEN) && ji) {
3552                                                 init_jit_info_dbg_attrs (ji);
3553                                                 if (ji->dbg_hidden)
3554                                                         filtered = TRUE;
3555                                         }
3556                                         if ((mod->data.filter & STEP_FILTER_DEBUGGER_STEP_THROUGH) && ji) {
3557                                                 init_jit_info_dbg_attrs (ji);
3558                                                 if (ji->dbg_step_through)
3559                                                         filtered = TRUE;
3560                                         }
3561                                         if ((mod->data.filter & STEP_FILTER_DEBUGGER_NON_USER_CODE) && ji) {
3562                                                 init_jit_info_dbg_attrs (ji);
3563                                                 if (ji->dbg_non_user_code)
3564                                                         filtered = TRUE;
3565                                         }
3566                                 }
3567                         }
3568
3569                         if (!filtered) {
3570                                 *suspend_policy = MAX (*suspend_policy, req->suspend_policy);
3571                                 events = g_slist_append (events, GINT_TO_POINTER (req->id));
3572                         }
3573                 }
3574         }
3575
3576         /* Send a VM START/DEATH event by default */
3577         if (event == EVENT_KIND_VM_START)
3578                 events = g_slist_append (events, GINT_TO_POINTER (0));
3579         if (event == EVENT_KIND_VM_DEATH)
3580                 events = g_slist_append (events, GINT_TO_POINTER (0));
3581
3582         return events;
3583 }
3584
3585 static G_GNUC_UNUSED const char*
3586 event_to_string (EventKind event)
3587 {
3588         switch (event) {
3589         case EVENT_KIND_VM_START: return "VM_START";
3590         case EVENT_KIND_VM_DEATH: return "VM_DEATH";
3591         case EVENT_KIND_THREAD_START: return "THREAD_START";
3592         case EVENT_KIND_THREAD_DEATH: return "THREAD_DEATH";
3593         case EVENT_KIND_APPDOMAIN_CREATE: return "APPDOMAIN_CREATE";
3594         case EVENT_KIND_APPDOMAIN_UNLOAD: return "APPDOMAIN_UNLOAD";
3595         case EVENT_KIND_METHOD_ENTRY: return "METHOD_ENTRY";
3596         case EVENT_KIND_METHOD_EXIT: return "METHOD_EXIT";
3597         case EVENT_KIND_ASSEMBLY_LOAD: return "ASSEMBLY_LOAD";
3598         case EVENT_KIND_ASSEMBLY_UNLOAD: return "ASSEMBLY_UNLOAD";
3599         case EVENT_KIND_BREAKPOINT: return "BREAKPOINT";
3600         case EVENT_KIND_STEP: return "STEP";
3601         case EVENT_KIND_TYPE_LOAD: return "TYPE_LOAD";
3602         case EVENT_KIND_EXCEPTION: return "EXCEPTION";
3603         case EVENT_KIND_KEEPALIVE: return "KEEPALIVE";
3604         case EVENT_KIND_USER_BREAK: return "USER_BREAK";
3605         case EVENT_KIND_USER_LOG: return "USER_LOG";
3606         default:
3607                 g_assert_not_reached ();
3608                 return "";
3609         }
3610 }
3611
3612 /*
3613  * process_event:
3614  *
3615  *   Send an event to the client, suspending the vm if needed.
3616  * LOCKING: Since this can suspend the calling thread, no locks should be held
3617  * by the caller.
3618  * The EVENTS list is freed by this function.
3619  */
3620 static void
3621 process_event (EventKind event, gpointer arg, gint32 il_offset, MonoContext *ctx, GSList *events, int suspend_policy)
3622 {
3623         Buffer buf;
3624         GSList *l;
3625         MonoDomain *domain = mono_domain_get ();
3626         MonoThread *thread = NULL;
3627         MonoObject *keepalive_obj = NULL;
3628         gboolean send_success = FALSE;
3629         static int ecount;
3630         int nevents;
3631
3632         if (!inited) {
3633                 DEBUG_PRINTF (2, "Debugger agent not initialized yet: dropping %s\n", event_to_string (event));
3634                 return;
3635         }
3636
3637         if (!vm_start_event_sent && event != EVENT_KIND_VM_START) {
3638                 // FIXME: We miss those events
3639                 DEBUG_PRINTF (2, "VM start event not sent yet: dropping %s\n", event_to_string (event));
3640                 return;
3641         }
3642
3643         if (vm_death_event_sent) {
3644                 DEBUG_PRINTF (2, "VM death event has been sent: dropping %s\n", event_to_string (event));
3645                 return;
3646         }
3647
3648         if (mono_runtime_is_shutting_down () && event != EVENT_KIND_VM_DEATH) {
3649                 DEBUG_PRINTF (2, "Mono runtime is shutting down: dropping %s\n", event_to_string (event));
3650                 return;
3651         }
3652
3653         if (disconnected) {
3654                 DEBUG_PRINTF (2, "Debugger client is not connected: dropping %s\n", event_to_string (event));
3655                 return;
3656         }
3657
3658         if (event == EVENT_KIND_KEEPALIVE)
3659                 suspend_policy = SUSPEND_POLICY_NONE;
3660         else {
3661                 if (events == NULL)
3662                         return;
3663
3664                 if (agent_config.defer) {
3665                         if (is_debugger_thread ()) {
3666                                 /* Don't suspend on events from the debugger thread */
3667                                 suspend_policy = SUSPEND_POLICY_NONE;
3668                         }
3669                 } else {
3670                         if (is_debugger_thread () && event != EVENT_KIND_VM_DEATH)
3671                                 // FIXME: Send these with a NULL thread, don't suspend the current thread
3672                                 return;
3673                 }
3674         }
3675
3676         nevents = g_slist_length (events);
3677         buffer_init (&buf, 128);
3678         buffer_add_byte (&buf, suspend_policy);
3679         buffer_add_int (&buf, nevents);
3680
3681         for (l = events; l; l = l->next) {
3682                 buffer_add_byte (&buf, event); // event kind
3683                 buffer_add_int (&buf, GPOINTER_TO_INT (l->data)); // request id
3684
3685                 ecount ++;
3686
3687                 if (event == EVENT_KIND_VM_DEATH) {
3688                         thread = NULL;
3689                 } else {
3690                         if (!thread)
3691                                 thread = is_debugger_thread () ? mono_thread_get_main () : mono_thread_current ();
3692
3693                         if (event == EVENT_KIND_VM_START && arg != NULL)
3694                                 thread = (MonoThread *)arg;
3695                 }
3696
3697                 buffer_add_objid (&buf, (MonoObject*)thread); // thread
3698
3699                 switch (event) {
3700                 case EVENT_KIND_THREAD_START:
3701                 case EVENT_KIND_THREAD_DEATH:
3702                         break;
3703                 case EVENT_KIND_APPDOMAIN_CREATE:
3704                 case EVENT_KIND_APPDOMAIN_UNLOAD:
3705                         buffer_add_domainid (&buf, (MonoDomain *)arg);
3706                         break;
3707                 case EVENT_KIND_METHOD_ENTRY:
3708                 case EVENT_KIND_METHOD_EXIT:
3709                         buffer_add_methodid (&buf, domain, (MonoMethod *)arg);
3710                         break;
3711                 case EVENT_KIND_ASSEMBLY_LOAD:
3712                         buffer_add_assemblyid (&buf, domain, (MonoAssembly *)arg);
3713                         break;
3714                 case EVENT_KIND_ASSEMBLY_UNLOAD: {
3715                         DebuggerTlsData *tls;
3716
3717                         /* The domain the assembly belonged to is not equal to the current domain */
3718                         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
3719                         g_assert (tls);
3720                         g_assert (tls->domain_unloading);
3721
3722                         buffer_add_assemblyid (&buf, tls->domain_unloading, (MonoAssembly *)arg);
3723                         break;
3724                 }
3725                 case EVENT_KIND_TYPE_LOAD:
3726                         buffer_add_typeid (&buf, domain, (MonoClass *)arg);
3727                         break;
3728                 case EVENT_KIND_BREAKPOINT:
3729                 case EVENT_KIND_STEP:
3730                         buffer_add_methodid (&buf, domain, (MonoMethod *)arg);
3731                         buffer_add_long (&buf, il_offset);
3732                         break;
3733                 case EVENT_KIND_VM_START:
3734                         buffer_add_domainid (&buf, mono_get_root_domain ());
3735                         break;
3736                 case EVENT_KIND_VM_DEATH:
3737                         if (CHECK_PROTOCOL_VERSION (2, 27))
3738                                 buffer_add_int (&buf, mono_environment_exitcode_get ());
3739                         break;
3740                 case EVENT_KIND_EXCEPTION: {
3741                         EventInfo *ei = (EventInfo *)arg;
3742                         buffer_add_objid (&buf, ei->exc);
3743                         /*
3744                          * We are not yet suspending, so get_objref () will not keep this object alive. So we need to do it
3745                          * later after the suspension. (#12494).
3746                          */
3747                         keepalive_obj = ei->exc;
3748                         break;
3749                 }
3750                 case EVENT_KIND_USER_BREAK:
3751                         break;
3752                 case EVENT_KIND_USER_LOG: {
3753                         EventInfo *ei = (EventInfo *)arg;
3754                         buffer_add_int (&buf, ei->level);
3755                         buffer_add_string (&buf, ei->category ? ei->category : "");
3756                         buffer_add_string (&buf, ei->message ? ei->message : "");
3757                         break;
3758                 }
3759                 case EVENT_KIND_KEEPALIVE:
3760                         suspend_policy = SUSPEND_POLICY_NONE;
3761                         break;
3762                 default:
3763                         g_assert_not_reached ();
3764                 }
3765         }
3766
3767         if (event == EVENT_KIND_VM_START) {
3768                 suspend_policy = agent_config.suspend ? SUSPEND_POLICY_ALL : SUSPEND_POLICY_NONE;
3769                 if (!agent_config.defer)
3770                         start_debugger_thread ();
3771         }
3772
3773         if (event == EVENT_KIND_VM_DEATH) {
3774                 vm_death_event_sent = TRUE;
3775                 suspend_policy = SUSPEND_POLICY_NONE;
3776         }
3777
3778         if (mono_runtime_is_shutting_down ())
3779                 suspend_policy = SUSPEND_POLICY_NONE;
3780
3781         if (suspend_policy != SUSPEND_POLICY_NONE) {
3782                 /*
3783                  * Save the thread context and start suspending before sending the packet,
3784                  * since we could be receiving the resume request before send_packet ()
3785                  * returns.
3786                  */
3787                 save_thread_context (ctx);
3788                 suspend_vm ();
3789
3790                 if (keepalive_obj)
3791                         /* This will keep this object alive */
3792                         get_objref (keepalive_obj);
3793         }
3794
3795         send_success = send_packet (CMD_SET_EVENT, CMD_COMPOSITE, &buf);
3796
3797         buffer_free (&buf);
3798
3799         g_slist_free (events);
3800         events = NULL;
3801
3802         if (!send_success) {
3803                 DEBUG_PRINTF (2, "Sending command %s failed.\n", event_to_string (event));
3804                 return;
3805         }
3806
3807         if (event == EVENT_KIND_VM_START) {
3808                 vm_start_event_sent = TRUE;
3809         }
3810
3811         DEBUG_PRINTF (1, "[%p] Sent %d events %s(%d), suspend=%d.\n", (gpointer) (gsize) mono_native_thread_id_get (), nevents, event_to_string (event), ecount, suspend_policy);
3812
3813         switch (suspend_policy) {
3814         case SUSPEND_POLICY_NONE:
3815                 break;
3816         case SUSPEND_POLICY_ALL:
3817                 suspend_current ();
3818                 break;
3819         case SUSPEND_POLICY_EVENT_THREAD:
3820                 NOT_IMPLEMENTED;
3821                 break;
3822         default:
3823                 g_assert_not_reached ();
3824         }
3825 }
3826
3827 static void
3828 process_profiler_event (EventKind event, gpointer arg)
3829 {
3830         int suspend_policy;
3831         GSList *events;
3832         EventInfo ei, *ei_arg = NULL;
3833
3834         if (event == EVENT_KIND_TYPE_LOAD) {
3835                 ei.klass = (MonoClass *)arg;
3836                 ei_arg = &ei;
3837         }
3838
3839         mono_loader_lock ();
3840         events = create_event_list (event, NULL, NULL, ei_arg, &suspend_policy);
3841         mono_loader_unlock ();
3842
3843         process_event (event, arg, 0, NULL, events, suspend_policy);
3844 }
3845
3846 static void
3847 runtime_initialized (MonoProfiler *prof)
3848 {
3849         process_profiler_event (EVENT_KIND_VM_START, mono_thread_current ());
3850         if (agent_config.defer)
3851                 start_debugger_thread ();
3852 }
3853
3854 static void
3855 runtime_shutdown (MonoProfiler *prof)
3856 {
3857         process_profiler_event (EVENT_KIND_VM_DEATH, NULL);
3858
3859         mono_debugger_agent_cleanup ();
3860 }
3861
3862 static void
3863 thread_startup (MonoProfiler *prof, uintptr_t tid)
3864 {
3865         MonoInternalThread *thread = mono_thread_internal_current ();
3866         MonoInternalThread *old_thread;
3867         DebuggerTlsData *tls;
3868
3869         if (is_debugger_thread ())
3870                 return;
3871
3872         g_assert (mono_native_thread_id_equals (MONO_UINT_TO_NATIVE_THREAD_ID (tid), MONO_UINT_TO_NATIVE_THREAD_ID (thread->tid)));
3873
3874         mono_loader_lock ();
3875         old_thread = (MonoInternalThread *)mono_g_hash_table_lookup (tid_to_thread, GUINT_TO_POINTER (tid));
3876         mono_loader_unlock ();
3877         if (old_thread) {
3878                 if (thread == old_thread) {
3879                         /*
3880                          * For some reason, thread_startup () might be called for the same thread
3881                          * multiple times (attach ?).
3882                          */
3883                         DEBUG_PRINTF (1, "[%p] thread_start () called multiple times for %p, ignored.\n", GUINT_TO_POINTER (tid), GUINT_TO_POINTER (tid));
3884                         return;
3885                 } else {
3886                         /*
3887                          * thread_end () might not be called for some threads, and the tid could
3888                          * get reused.
3889                          */
3890                         DEBUG_PRINTF (1, "[%p] Removing stale data for tid %p.\n", GUINT_TO_POINTER (tid), GUINT_TO_POINTER (tid));
3891                         mono_loader_lock ();
3892                         mono_g_hash_table_remove (thread_to_tls, old_thread);
3893                         mono_g_hash_table_remove (tid_to_thread, GUINT_TO_POINTER (tid));
3894                         mono_g_hash_table_remove (tid_to_thread_obj, GUINT_TO_POINTER (tid));
3895                         mono_loader_unlock ();
3896                 }
3897         }
3898
3899         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
3900         g_assert (!tls);
3901         // FIXME: Free this somewhere
3902         tls = g_new0 (DebuggerTlsData, 1);
3903         MONO_GC_REGISTER_ROOT_SINGLE (tls->thread, MONO_ROOT_SOURCE_DEBUGGER, "debugger thread reference");
3904         tls->thread = thread;
3905         mono_native_tls_set_value (debugger_tls_id, tls);
3906
3907         DEBUG_PRINTF (1, "[%p] Thread started, obj=%p, tls=%p.\n", (gpointer)tid, thread, tls);
3908
3909         mono_loader_lock ();
3910         mono_g_hash_table_insert (thread_to_tls, thread, tls);
3911         mono_g_hash_table_insert (tid_to_thread, (gpointer)tid, thread);
3912         mono_g_hash_table_insert (tid_to_thread_obj, GUINT_TO_POINTER (tid), mono_thread_current ());
3913         mono_loader_unlock ();
3914
3915         process_profiler_event (EVENT_KIND_THREAD_START, thread);
3916
3917         /*
3918          * suspend_vm () could have missed this thread, so wait for a resume.
3919          */
3920         suspend_current ();
3921 }
3922
3923 static void
3924 thread_end (MonoProfiler *prof, uintptr_t tid)
3925 {
3926         MonoInternalThread *thread;
3927         DebuggerTlsData *tls = NULL;
3928
3929         mono_loader_lock ();
3930         thread = (MonoInternalThread *)mono_g_hash_table_lookup (tid_to_thread, GUINT_TO_POINTER (tid));
3931         if (thread) {
3932                 mono_g_hash_table_remove (tid_to_thread_obj, GUINT_TO_POINTER (tid));
3933                 tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
3934                 if (tls) {
3935                         /* FIXME: Maybe we need to free this instead, but some code can't handle that */
3936                         tls->terminated = TRUE;
3937                         /* Can't remove from tid_to_thread, as that would defeat the check in thread_start () */
3938                         MONO_GC_UNREGISTER_ROOT (tls->thread);
3939                         tls->thread = NULL;
3940                 }
3941         }
3942         mono_loader_unlock ();
3943
3944         /* We might be called for threads started before we registered the start callback */
3945         if (thread) {
3946                 DEBUG_PRINTF (1, "[%p] Thread terminated, obj=%p, tls=%p.\n", (gpointer)tid, thread, tls);
3947
3948                 if (mono_thread_internal_is_current (thread) && !mono_native_tls_get_value (debugger_tls_id)
3949                 ) {
3950                         /*
3951                          * This can happen on darwin since we deregister threads using pthread dtors.
3952                          * process_profiler_event () and the code it calls cannot handle a null TLS value.
3953                          */
3954                         return;
3955                 }
3956
3957                 process_profiler_event (EVENT_KIND_THREAD_DEATH, thread);
3958         }
3959 }
3960
3961 static void
3962 appdomain_load (MonoProfiler *prof, MonoDomain *domain)
3963 {
3964         mono_loader_lock ();
3965         g_hash_table_insert (domains, domain, domain);
3966         mono_loader_unlock ();
3967
3968         process_profiler_event (EVENT_KIND_APPDOMAIN_CREATE, domain);
3969 }
3970
3971 static void
3972 appdomain_start_unload (MonoProfiler *prof, MonoDomain *domain)
3973 {
3974         DebuggerTlsData *tls;
3975
3976         /* This might be called during shutdown on the debugger thread from the CMD_VM_EXIT code */
3977         if (is_debugger_thread ())
3978                 return;
3979
3980         /*
3981          * Remember the currently unloading appdomain as it is needed to generate
3982          * proper ids for unloading assemblies.
3983          */
3984         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
3985         g_assert (tls);
3986         tls->domain_unloading = domain;
3987 }
3988
3989 static void
3990 appdomain_unload (MonoProfiler *prof, MonoDomain *domain)
3991 {
3992         DebuggerTlsData *tls;
3993
3994         if (is_debugger_thread ())
3995                 return;
3996
3997         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
3998         g_assert (tls);
3999         tls->domain_unloading = NULL;
4000
4001         clear_breakpoints_for_domain (domain);
4002
4003         mono_loader_lock ();
4004         /* Invalidate each thread's frame stack */
4005         mono_g_hash_table_foreach (thread_to_tls, invalidate_each_thread, NULL);
4006         mono_loader_unlock ();
4007
4008         process_profiler_event (EVENT_KIND_APPDOMAIN_UNLOAD, domain);
4009 }
4010
4011 /*
4012  * invalidate_each_thread:
4013  *
4014  *   A GHFunc to invalidate frames.
4015  *   value must be a DebuggerTlsData*
4016  */
4017 static void
4018 invalidate_each_thread (gpointer key, gpointer value, gpointer user_data)
4019 {
4020         invalidate_frames ((DebuggerTlsData *)value);
4021 }
4022
4023 static void
4024 assembly_load (MonoProfiler *prof, MonoAssembly *assembly)
4025 {
4026         /* Sent later in jit_end () */
4027         dbg_lock ();
4028         g_ptr_array_add (pending_assembly_loads, assembly);
4029         dbg_unlock ();
4030 }
4031
4032 static void
4033 assembly_unload (MonoProfiler *prof, MonoAssembly *assembly)
4034 {
4035         if (is_debugger_thread ())
4036                 return;
4037
4038         process_profiler_event (EVENT_KIND_ASSEMBLY_UNLOAD, assembly);
4039
4040         clear_event_requests_for_assembly (assembly);
4041         clear_types_for_assembly (assembly);
4042 }
4043
4044 static void
4045 send_type_load (MonoClass *klass)
4046 {
4047         gboolean type_load = FALSE;
4048         MonoDomain *domain = mono_domain_get ();
4049         AgentDomainInfo *info = NULL;
4050
4051         info = get_agent_domain_info (domain);
4052
4053         mono_loader_lock ();
4054
4055         if (!g_hash_table_lookup (info->loaded_classes, klass)) {
4056                 type_load = TRUE;
4057                 g_hash_table_insert (info->loaded_classes, klass, klass);
4058         }
4059
4060         mono_loader_unlock ();
4061
4062         if (type_load)
4063                 emit_type_load (klass, klass, NULL);
4064 }
4065
4066 /*
4067  * Emit load events for all types currently loaded in the domain.
4068  * Takes the loader and domain locks.
4069  * user_data is unused.
4070  */
4071 static void
4072 send_types_for_domain (MonoDomain *domain, void *user_data)
4073 {
4074         MonoDomain* old_domain;
4075         AgentDomainInfo *info = NULL;
4076
4077         info = get_agent_domain_info (domain);
4078         g_assert (info);
4079
4080         old_domain = mono_domain_get ();
4081
4082         mono_domain_set (domain, TRUE);
4083
4084         mono_loader_lock ();
4085         g_hash_table_foreach (info->loaded_classes, emit_type_load, NULL);
4086         mono_loader_unlock ();
4087
4088         mono_domain_set (old_domain, TRUE);
4089 }
4090
4091 static void
4092 send_assemblies_for_domain (MonoDomain *domain, void *user_data)
4093 {
4094         GSList *tmp;
4095         MonoDomain* old_domain;
4096
4097         old_domain = mono_domain_get ();
4098
4099         mono_domain_set (domain, TRUE);
4100
4101         mono_domain_assemblies_lock (domain);
4102         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
4103                 MonoAssembly* ass = (MonoAssembly *)tmp->data;
4104                 emit_assembly_load (ass, NULL);
4105         }
4106         mono_domain_assemblies_unlock (domain);
4107
4108         mono_domain_set (old_domain, TRUE);
4109 }
4110
4111 static void
4112 jit_done (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo)
4113 {
4114         jit_end (prof, method, jinfo);
4115 }
4116
4117 static void
4118 jit_failed (MonoProfiler *prof, MonoMethod *method)
4119 {
4120         jit_end (prof, method, NULL);
4121 }
4122
4123 static void
4124 jit_end (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo)
4125 {
4126         /*
4127          * We emit type load events when the first method of the type is JITted,
4128          * since the class load profiler callbacks might be called with the
4129          * loader lock held. They could also occur in the debugger thread.
4130          * Same for assembly load events.
4131          */
4132         while (TRUE) {
4133                 MonoAssembly *assembly = NULL;
4134
4135                 // FIXME: Maybe store this in TLS so the thread of the event is correct ?
4136                 dbg_lock ();
4137                 if (pending_assembly_loads->len > 0) {
4138                         assembly = (MonoAssembly *)g_ptr_array_index (pending_assembly_loads, 0);
4139                         g_ptr_array_remove_index (pending_assembly_loads, 0);
4140                 }
4141                 dbg_unlock ();
4142
4143                 if (assembly) {
4144                         process_profiler_event (EVENT_KIND_ASSEMBLY_LOAD, assembly);
4145                 } else {
4146                         break;
4147                 }
4148         }
4149
4150         send_type_load (method->klass);
4151
4152         if (jinfo)
4153                 add_pending_breakpoints (method, jinfo);
4154 }
4155
4156 /*
4157  * BREAKPOINTS/SINGLE STEPPING
4158  */
4159
4160 /*
4161  * Contains information about an inserted breakpoint.
4162  */
4163 typedef struct {
4164         long il_offset, native_offset;
4165         guint8 *ip;
4166         MonoJitInfo *ji;
4167         MonoDomain *domain;
4168 } BreakpointInstance;
4169
4170 /*
4171  * Contains generic information about a breakpoint.
4172  */
4173 typedef struct {
4174         /*
4175          * The method where the breakpoint is placed. Can be NULL in which case it
4176          * is inserted into every method. This is used to implement method entry/
4177          * exit events. Can be a generic method definition, in which case the
4178          * breakpoint is inserted into every instance.
4179          */
4180         MonoMethod *method;
4181         long il_offset;
4182         EventRequest *req;
4183         /*
4184          * A list of BreakpointInstance structures describing where the breakpoint
4185          * was inserted. There could be more than one because of
4186          * generics/appdomains/method entry/exit.
4187          */
4188         GPtrArray *children;
4189 } MonoBreakpoint;
4190
4191 /* List of breakpoints */
4192 /* Protected by the loader lock */
4193 static GPtrArray *breakpoints;
4194 /* Maps breakpoint locations to the number of breakpoints at that location */
4195 static GHashTable *bp_locs;
4196
4197 static void
4198 breakpoints_init (void)
4199 {
4200         breakpoints = g_ptr_array_new ();
4201         bp_locs = g_hash_table_new (NULL, NULL);
4202 }
4203
4204 /*
4205  * insert_breakpoint:
4206  *
4207  *   Insert the breakpoint described by BP into the method described by
4208  * JI.
4209  */
4210 static void
4211 insert_breakpoint (MonoSeqPointInfo *seq_points, MonoDomain *domain, MonoJitInfo *ji, MonoBreakpoint *bp, MonoError *error)
4212 {
4213         int count;
4214         BreakpointInstance *inst;
4215         SeqPointIterator it;
4216         gboolean it_has_sp = FALSE;
4217
4218         if (error)
4219                 error_init (error);
4220
4221         mono_seq_point_iterator_init (&it, seq_points);
4222         while (mono_seq_point_iterator_next (&it)) {
4223                 if (it.seq_point.il_offset == bp->il_offset) {
4224                         it_has_sp = TRUE;
4225                         break;
4226                 }
4227         }
4228
4229         if (!it_has_sp) {
4230                 /*
4231                  * The set of IL offsets with seq points doesn't completely match the
4232                  * info returned by CMD_METHOD_GET_DEBUG_INFO (#407).
4233                  */
4234                 mono_seq_point_iterator_init (&it, seq_points);
4235                 while (mono_seq_point_iterator_next (&it)) {
4236                         if (it.seq_point.il_offset != METHOD_ENTRY_IL_OFFSET &&
4237                                 it.seq_point.il_offset != METHOD_EXIT_IL_OFFSET &&
4238                                 it.seq_point.il_offset + 1 == bp->il_offset) {
4239                                 it_has_sp = TRUE;
4240                                 break;
4241                         }
4242                 }
4243         }
4244
4245         if (!it_has_sp) {
4246                 char *s = g_strdup_printf ("Unable to insert breakpoint at %s:%d", mono_method_full_name (jinfo_get_method (ji), TRUE), bp->il_offset);
4247
4248                 mono_seq_point_iterator_init (&it, seq_points);
4249                 while (mono_seq_point_iterator_next (&it))
4250                         DEBUG_PRINTF (1, "%d\n", it.seq_point.il_offset);
4251
4252                 if (error) {
4253                         mono_error_set_error (error, MONO_ERROR_GENERIC, "%s", s);
4254                         g_warning ("%s", s);
4255                         g_free (s);
4256                         return;
4257                 } else {
4258                         g_warning ("%s", s);
4259                         g_free (s);
4260                         return;
4261                 }
4262         }
4263
4264         inst = g_new0 (BreakpointInstance, 1);
4265         inst->il_offset = it.seq_point.il_offset;
4266         inst->native_offset = it.seq_point.native_offset;
4267         inst->ip = (guint8*)ji->code_start + it.seq_point.native_offset;
4268         inst->ji = ji;
4269         inst->domain = domain;
4270
4271         mono_loader_lock ();
4272
4273         g_ptr_array_add (bp->children, inst);
4274
4275         mono_loader_unlock ();
4276
4277         dbg_lock ();
4278         count = GPOINTER_TO_INT (g_hash_table_lookup (bp_locs, inst->ip));
4279         g_hash_table_insert (bp_locs, inst->ip, GINT_TO_POINTER (count + 1));
4280         dbg_unlock ();
4281
4282         if (it.seq_point.native_offset == SEQ_POINT_NATIVE_OFFSET_DEAD_CODE) {
4283                 DEBUG_PRINTF (1, "[dbg] Attempting to insert seq point at dead IL offset %d, ignoring.\n", (int)bp->il_offset);
4284         } else if (count == 0) {
4285                 if (ji->is_interp) {
4286                         mono_interp_set_breakpoint (ji, inst->ip);
4287                 } else {
4288 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
4289                         mono_arch_set_breakpoint (ji, inst->ip);
4290 #else
4291                         NOT_IMPLEMENTED;
4292 #endif
4293                 }
4294         }
4295
4296         DEBUG_PRINTF (1, "[dbg] Inserted breakpoint at %s:[il=0x%x,native=0x%x] [%p](%d).\n", mono_method_full_name (jinfo_get_method (ji), TRUE), (int)it.seq_point.il_offset, (int)it.seq_point.native_offset, inst->ip, count);
4297 }
4298
4299 static void
4300 remove_breakpoint (BreakpointInstance *inst)
4301 {
4302 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
4303         int count;
4304         MonoJitInfo *ji = inst->ji;
4305         guint8 *ip = inst->ip;
4306
4307         dbg_lock ();
4308         count = GPOINTER_TO_INT (g_hash_table_lookup (bp_locs, ip));
4309         g_hash_table_insert (bp_locs, ip, GINT_TO_POINTER (count - 1));
4310         dbg_unlock ();
4311
4312         g_assert (count > 0);
4313
4314         if (count == 1 && inst->native_offset != SEQ_POINT_NATIVE_OFFSET_DEAD_CODE) {
4315                 if (ji->is_interp)
4316                         mono_interp_clear_breakpoint (ji, ip);
4317                 else
4318                         mono_arch_clear_breakpoint (ji, ip);
4319                 DEBUG_PRINTF (1, "[dbg] Clear breakpoint at %s [%p].\n", mono_method_full_name (jinfo_get_method (ji), TRUE), ip);
4320         }
4321 #else
4322         NOT_IMPLEMENTED;
4323 #endif
4324 }
4325
4326 /*
4327  * This doesn't take any locks.
4328  */
4329 static inline gboolean
4330 bp_matches_method (MonoBreakpoint *bp, MonoMethod *method)
4331 {
4332         int i;
4333
4334         if (!bp->method)
4335                 return TRUE;
4336         if (method == bp->method)
4337                 return TRUE;
4338         if (method->is_inflated && ((MonoMethodInflated*)method)->declaring == bp->method)
4339                 return TRUE;
4340
4341         if (bp->method->is_inflated && method->is_inflated) {
4342                 MonoMethodInflated *bpimethod = (MonoMethodInflated*)bp->method;
4343                 MonoMethodInflated *imethod = (MonoMethodInflated*)method;
4344
4345                 /* Open generic methods should match closed generic methods of the same class */
4346                 if (bpimethod->declaring == imethod->declaring && bpimethod->context.class_inst == imethod->context.class_inst && bpimethod->context.method_inst && bpimethod->context.method_inst->is_open) {
4347                         for (i = 0; i < bpimethod->context.method_inst->type_argc; ++i) {
4348                                 MonoType *t1 = bpimethod->context.method_inst->type_argv [i];
4349
4350                                 /* FIXME: Handle !mvar */
4351                                 if (t1->type != MONO_TYPE_MVAR)
4352                                         return FALSE;
4353                         }
4354                         return TRUE;
4355                 }
4356         }
4357
4358         return FALSE;
4359 }
4360
4361 /*
4362  * add_pending_breakpoints:
4363  *
4364  *   Insert pending breakpoints into the newly JITted method METHOD.
4365  */
4366 static void
4367 add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji)
4368 {
4369         int i, j;
4370         MonoSeqPointInfo *seq_points;
4371         MonoDomain *domain;
4372         MonoMethod *jmethod;
4373
4374         if (!breakpoints)
4375                 return;
4376
4377         domain = mono_domain_get ();
4378
4379         mono_loader_lock ();
4380
4381         for (i = 0; i < breakpoints->len; ++i) {
4382                 MonoBreakpoint *bp = (MonoBreakpoint *)g_ptr_array_index (breakpoints, i);
4383                 gboolean found = FALSE;
4384
4385                 if (!bp_matches_method (bp, method))
4386                         continue;
4387
4388                 for (j = 0; j < bp->children->len; ++j) {
4389                         BreakpointInstance *inst = (BreakpointInstance *)g_ptr_array_index (bp->children, j);
4390
4391                         if (inst->ji == ji)
4392                                 found = TRUE;
4393                 }
4394
4395                 if (!found) {
4396                         MonoMethod *declaring = NULL;
4397
4398                         jmethod = jinfo_get_method (ji);
4399                         if (jmethod->is_inflated)
4400                                 declaring = mono_method_get_declaring_generic_method (jmethod);
4401
4402                         mono_domain_lock (domain);
4403                         seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, jmethod);
4404                         if (!seq_points && declaring)
4405                                 seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, declaring);
4406                         mono_domain_unlock (domain);
4407                         if (!seq_points)
4408                                 /* Could be AOT code */
4409                                 continue;
4410                         g_assert (seq_points);
4411
4412                         insert_breakpoint (seq_points, domain, ji, bp, NULL);
4413                 }
4414         }
4415
4416         mono_loader_unlock ();
4417 }
4418
4419 static void
4420 set_bp_in_method (MonoDomain *domain, MonoMethod *method, MonoSeqPointInfo *seq_points, MonoBreakpoint *bp, MonoError *error)
4421 {
4422         gpointer code;
4423         MonoJitInfo *ji;
4424
4425         if (error)
4426                 error_init (error);
4427
4428         code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
4429         if (!code) {
4430                 MonoError oerror;
4431
4432                 /* Might be AOTed code */
4433                 mono_class_init (method->klass);
4434                 code = mono_aot_get_method_checked (domain, method, &oerror);
4435                 if (code) {
4436                         mono_error_assert_ok (&oerror);
4437                         ji = mono_jit_info_table_find (domain, (char *)code);
4438                 } else {
4439                         /* Might be interpreted */
4440                         ji = mono_interp_find_jit_info (domain, method);
4441                 }
4442                 g_assert (ji);
4443         }
4444
4445         insert_breakpoint (seq_points, domain, ji, bp, error);
4446 }
4447
4448 static void
4449 clear_breakpoint (MonoBreakpoint *bp);
4450
4451 /*
4452  * set_breakpoint:
4453  *
4454  *   Set a breakpoint at IL_OFFSET in METHOD.
4455  * METHOD can be NULL, in which case a breakpoint is placed in all methods.
4456  * METHOD can also be a generic method definition, in which case a breakpoint
4457  * is placed in all instances of the method.
4458  * If ERROR is non-NULL, then it is set and NULL is returnd if some breakpoints couldn't be
4459  * inserted.
4460  */
4461 static MonoBreakpoint*
4462 set_breakpoint (MonoMethod *method, long il_offset, EventRequest *req, MonoError *error)
4463 {
4464         MonoBreakpoint *bp;
4465         GHashTableIter iter, iter2;
4466         MonoDomain *domain;
4467         MonoMethod *m;
4468         MonoSeqPointInfo *seq_points;
4469         GPtrArray *methods;
4470         GPtrArray *method_domains;
4471         GPtrArray *method_seq_points;
4472         int i;
4473
4474         if (error)
4475                 error_init (error);
4476
4477         // FIXME:
4478         // - suspend/resume the vm to prevent code patching problems
4479         // - multiple breakpoints on the same location
4480         // - dynamic methods
4481         // - races
4482
4483         bp = g_new0 (MonoBreakpoint, 1);
4484         bp->method = method;
4485         bp->il_offset = il_offset;
4486         bp->req = req;
4487         bp->children = g_ptr_array_new ();
4488
4489         DEBUG_PRINTF (1, "[dbg] Setting %sbreakpoint at %s:0x%x.\n", (req->event_kind == EVENT_KIND_STEP) ? "single step " : "", method ? mono_method_full_name (method, TRUE) : "<all>", (int)il_offset);
4490
4491         methods = g_ptr_array_new ();
4492         method_domains = g_ptr_array_new ();
4493         method_seq_points = g_ptr_array_new ();
4494
4495         mono_loader_lock ();
4496         g_hash_table_iter_init (&iter, domains);
4497         while (g_hash_table_iter_next (&iter, (void**)&domain, NULL)) {
4498                 mono_domain_lock (domain);
4499                 g_hash_table_iter_init (&iter2, domain_jit_info (domain)->seq_points);
4500                 while (g_hash_table_iter_next (&iter2, (void**)&m, (void**)&seq_points)) {
4501                         if (bp_matches_method (bp, m)) {
4502                                 /* Save the info locally to simplify the code inside the domain lock */
4503                                 g_ptr_array_add (methods, m);
4504                                 g_ptr_array_add (method_domains, domain);
4505                                 g_ptr_array_add (method_seq_points, seq_points);
4506                         }
4507                 }
4508                 mono_domain_unlock (domain);
4509         }
4510
4511         for (i = 0; i < methods->len; ++i) {
4512                 m = (MonoMethod *)g_ptr_array_index (methods, i);
4513                 domain = (MonoDomain *)g_ptr_array_index (method_domains, i);
4514                 seq_points = (MonoSeqPointInfo *)g_ptr_array_index (method_seq_points, i);
4515                 set_bp_in_method (domain, m, seq_points, bp, error);
4516         }
4517
4518         g_ptr_array_add (breakpoints, bp);
4519         mono_loader_unlock ();
4520
4521         g_ptr_array_free (methods, TRUE);
4522         g_ptr_array_free (method_domains, TRUE);
4523         g_ptr_array_free (method_seq_points, TRUE);
4524
4525         if (error && !mono_error_ok (error)) {
4526                 clear_breakpoint (bp);
4527                 return NULL;
4528         }
4529
4530         return bp;
4531 }
4532
4533 static void
4534 clear_breakpoint (MonoBreakpoint *bp)
4535 {
4536         int i;
4537
4538         // FIXME: locking, races
4539         for (i = 0; i < bp->children->len; ++i) {
4540                 BreakpointInstance *inst = (BreakpointInstance *)g_ptr_array_index (bp->children, i);
4541
4542                 remove_breakpoint (inst);
4543
4544                 g_free (inst);
4545         }
4546
4547         mono_loader_lock ();
4548         g_ptr_array_remove (breakpoints, bp);
4549         mono_loader_unlock ();
4550
4551         g_ptr_array_free (bp->children, TRUE);
4552         g_free (bp);
4553 }
4554
4555 static void
4556 breakpoints_cleanup (void)
4557 {
4558         int i;
4559
4560         mono_loader_lock ();
4561         i = 0;
4562         while (i < event_requests->len) {
4563                 EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
4564
4565                 if (req->event_kind == EVENT_KIND_BREAKPOINT) {
4566                         clear_breakpoint ((MonoBreakpoint *)req->info);
4567                         g_ptr_array_remove_index_fast (event_requests, i);
4568                         g_free (req);
4569                 } else {
4570                         i ++;
4571                 }
4572         }
4573
4574         for (i = 0; i < breakpoints->len; ++i)
4575                 g_free (g_ptr_array_index (breakpoints, i));
4576
4577         g_ptr_array_free (breakpoints, TRUE);
4578         g_hash_table_destroy (bp_locs);
4579
4580         breakpoints = NULL;
4581         bp_locs = NULL;
4582
4583         mono_loader_unlock ();
4584 }
4585
4586 /*
4587  * clear_breakpoints_for_domain:
4588  *
4589  *   Clear breakpoint instances which reference DOMAIN.
4590  */
4591 static void
4592 clear_breakpoints_for_domain (MonoDomain *domain)
4593 {
4594         int i, j;
4595
4596         /* This could be called after shutdown */
4597         if (!breakpoints)
4598                 return;
4599
4600         mono_loader_lock ();
4601         for (i = 0; i < breakpoints->len; ++i) {
4602                 MonoBreakpoint *bp = (MonoBreakpoint *)g_ptr_array_index (breakpoints, i);
4603
4604                 j = 0;
4605                 while (j < bp->children->len) {
4606                         BreakpointInstance *inst = (BreakpointInstance *)g_ptr_array_index (bp->children, j);
4607
4608                         if (inst->domain == domain) {
4609                                 remove_breakpoint (inst);
4610
4611                                 g_free (inst);
4612
4613                                 g_ptr_array_remove_index_fast (bp->children, j);
4614                         } else {
4615                                 j ++;
4616                         }
4617                 }
4618         }
4619         mono_loader_unlock ();
4620 }
4621
4622 /*
4623  * ss_calculate_framecount:
4624  *
4625  * Ensure DebuggerTlsData fields are filled out.
4626  */
4627 static void ss_calculate_framecount (DebuggerTlsData *tls, MonoContext *ctx)
4628 {
4629         if (!tls->context.valid)
4630                 mono_thread_state_init_from_monoctx (&tls->context, ctx);
4631         compute_frame_info (tls->thread, tls);
4632 }
4633
4634 static gboolean
4635 ensure_jit (StackFrame* frame)
4636 {
4637         if (!frame->jit) {
4638                 frame->jit = mono_debug_find_method (frame->api_method, frame->domain);
4639                 if (!frame->jit && frame->api_method->is_inflated)
4640                         frame->jit = mono_debug_find_method(mono_method_get_declaring_generic_method (frame->api_method), frame->domain);
4641                 if (!frame->jit) {
4642                         char *s;
4643
4644                         /* This could happen for aot images with no jit debug info */
4645                         s = mono_method_full_name (frame->api_method, TRUE);
4646                         DEBUG_PRINTF(1, "[dbg] No debug information found for '%s'.\n", s);
4647                         g_free (s);
4648                         return FALSE;
4649                 }
4650         }
4651         return TRUE;
4652 }
4653
4654 /*
4655  * ss_update:
4656  *
4657  * Return FALSE if single stepping needs to continue.
4658  */
4659 static gboolean
4660 ss_update (SingleStepReq *req, MonoJitInfo *ji, SeqPoint *sp, DebuggerTlsData *tls, MonoContext *ctx, MonoMethod* method)
4661 {
4662         MonoDebugMethodInfo *minfo;
4663         MonoDebugSourceLocation *loc = NULL;
4664         gboolean hit = TRUE;
4665
4666         if (req->async_stepout_method == method) {
4667                 DEBUG_PRINTF (1, "[%p] Breakpoint hit during async step-out at %s hit, continuing stepping out.\n", (gpointer)(gsize)mono_native_thread_id_get (), method->name);
4668                 return FALSE;
4669         }
4670
4671         if (req->depth == STEP_DEPTH_OVER && (sp->flags & MONO_SEQ_POINT_FLAG_NONEMPTY_STACK)) {
4672                 /*
4673                  * These seq points are inserted by the JIT after calls, step over needs to skip them.
4674                  */
4675                 DEBUG_PRINTF (1, "[%p] Seq point at nonempty stack %x while stepping over, continuing single stepping.\n", (gpointer) (gsize) mono_native_thread_id_get (), sp->il_offset);
4676                 return FALSE;
4677         }
4678
4679         if ((req->depth == STEP_DEPTH_OVER || req->depth == STEP_DEPTH_OUT) && hit && !req->async_stepout_method) {
4680                 gboolean is_step_out = req->depth == STEP_DEPTH_OUT;
4681
4682                 ss_calculate_framecount (tls, ctx);
4683
4684                 // Because functions can call themselves recursively, we need to make sure we're stopping at the right stack depth.
4685                 // In case of step out, the target is the frame *enclosing* the one where the request was made.
4686                 int target_frames = req->nframes + (is_step_out ? -1 : 0);
4687                 if (req->nframes > 0 && tls->frame_count > 0 && tls->frame_count > target_frames) {
4688                         /* Hit the breakpoint in a recursive call, don't halt */
4689                         DEBUG_PRINTF (1, "[%p] Breakpoint at lower frame while stepping %s, continuing single stepping.\n", (gpointer) (gsize) mono_native_thread_id_get (), is_step_out ? "out" : "over");
4690                         return FALSE;
4691                 }
4692         }
4693
4694         if (req->depth == STEP_DEPTH_INTO && req->size == STEP_SIZE_MIN && (sp->flags & MONO_SEQ_POINT_FLAG_NONEMPTY_STACK) && ss_req->start_method){
4695                 ss_calculate_framecount (tls, ctx);
4696                 if (ss_req->start_method == method && req->nframes && tls->frame_count == req->nframes) {//Check also frame count(could be recursion)
4697                         DEBUG_PRINTF (1, "[%p] Seq point at nonempty stack %x while stepping in, continuing single stepping.\n", (gpointer) (gsize) mono_native_thread_id_get (), sp->il_offset);
4698                         return FALSE;
4699                 }
4700         }
4701
4702         MonoDebugMethodAsyncInfo* async_method = mono_debug_lookup_method_async_debug_info (method);
4703         if (async_method) {
4704                 for (int i = 0; i < async_method->num_awaits; i++) {
4705                         if (async_method->yield_offsets[i] == sp->il_offset || async_method->resume_offsets[i] == sp->il_offset) {
4706                                 mono_debug_free_method_async_debug_info (async_method);
4707                                 return FALSE;
4708                         }
4709                 }
4710                 mono_debug_free_method_async_debug_info (async_method);
4711         }
4712
4713         if (req->size != STEP_SIZE_LINE)
4714                 return TRUE;
4715
4716         /* Have to check whenever a different source line was reached */
4717         minfo = mono_debug_lookup_method (method);
4718
4719         if (minfo)
4720                 loc = mono_debug_method_lookup_location (minfo, sp->il_offset);
4721
4722         if (!loc) {
4723                 DEBUG_PRINTF (1, "[%p] No line number info for il offset %x, continuing single stepping.\n", (gpointer) (gsize) mono_native_thread_id_get (), sp->il_offset);
4724                 ss_req->last_method = method;
4725                 hit = FALSE;
4726         } else if (loc && method == ss_req->last_method && loc->row == ss_req->last_line) {
4727                 ss_calculate_framecount (tls, ctx);
4728                 if (tls->frame_count == req->nframes) { // If the frame has changed we're clearly not on the same source line.
4729                         DEBUG_PRINTF (1, "[%p] Same source line (%d), continuing single stepping.\n", (gpointer) (gsize) mono_native_thread_id_get (), loc->row);
4730                         hit = FALSE;
4731                 }
4732         }
4733
4734         if (loc) {
4735                 ss_req->last_method = method;
4736                 ss_req->last_line = loc->row;
4737                 mono_debug_free_source_location (loc);
4738         }
4739
4740         return hit;
4741 }
4742
4743 static gboolean
4744 breakpoint_matches_assembly (MonoBreakpoint *bp, MonoAssembly *assembly)
4745 {
4746         return bp->method && bp->method->klass->image->assembly == assembly;
4747 }
4748
4749 static MonoObject*
4750 get_this (StackFrame *frame)
4751 {
4752         //Logic inspiered by "add_var" method and took out path that happens in async method for getting this
4753         MonoDebugVarInfo *var = frame->jit->this_var;
4754         if ((var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS) != MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET)
4755                 return NULL;
4756
4757         guint8 * addr = (guint8 *)mono_arch_context_get_int_reg (&frame->ctx, var->index & ~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS);
4758         addr += (gint32)var->offset;
4759         return *(MonoObject**)addr;
4760 }
4761
4762 //This ID is used to figure out if breakpoint hit on resumeOffset belongs to us or not
4763 //since thread probably changed...
4764 static int
4765 get_this_async_id (StackFrame *frame)
4766 {
4767         return get_objid (get_this (frame));
4768 }
4769
4770 static MonoMethod*
4771 get_set_notification_method (MonoClass* async_builder_class)
4772 {
4773         MonoError error;
4774         GPtrArray* array = mono_class_get_methods_by_name (async_builder_class, "SetNotificationForWaitCompletion", 0x24, FALSE, FALSE, &error);
4775         mono_error_assert_ok (&error);
4776         g_assert (array->len == 1);
4777         MonoMethod* set_notification_method = (MonoMethod *)g_ptr_array_index (array, 0);
4778         g_ptr_array_free (array, TRUE);
4779         return set_notification_method;
4780 }
4781
4782 static void
4783 set_set_notification_for_wait_completion_flag (StackFrame *frame)
4784 {
4785         MonoObject* obj = get_this (frame);
4786         g_assert (obj);
4787         MonoClassField *builder_field = mono_class_get_field_from_name (obj->vtable->klass, "<>t__builder");
4788         g_assert (builder_field);
4789         MonoObject* builder;
4790         MonoError error;
4791         builder = mono_field_get_value_object_checked (frame->domain, builder_field, obj, &error);
4792         mono_error_assert_ok (&error);
4793         g_assert (builder);
4794
4795         void* args [1];
4796         gboolean arg = TRUE;
4797         args [0] = &arg;
4798         mono_runtime_invoke_checked (get_set_notification_method (builder->vtable->klass), mono_object_unbox (builder), args, &error);
4799         mono_error_assert_ok (&error);
4800         mono_field_set_value (obj, builder_field, mono_object_unbox (builder));
4801 }
4802
4803 static MonoMethod* notify_debugger_of_wait_completion_method_cache = NULL;
4804
4805 static MonoMethod*
4806 get_notify_debugger_of_wait_completion_method (void)
4807 {
4808         if (notify_debugger_of_wait_completion_method_cache != NULL)
4809                 return notify_debugger_of_wait_completion_method_cache;
4810         MonoError error;
4811         MonoClass* task_class = mono_class_load_from_name (mono_defaults.corlib, "System.Threading.Tasks", "Task");
4812         GPtrArray* array = mono_class_get_methods_by_name (task_class, "NotifyDebuggerOfWaitCompletion", 0x24, FALSE, FALSE, &error);
4813         mono_error_assert_ok (&error);
4814         g_assert (array->len == 1);
4815         notify_debugger_of_wait_completion_method_cache = (MonoMethod *)g_ptr_array_index (array, 0);
4816         g_ptr_array_free (array, TRUE);
4817         return notify_debugger_of_wait_completion_method_cache;
4818 }
4819
4820 static void
4821 process_breakpoint (DebuggerTlsData *tls, gboolean from_signal)
4822 {
4823         MonoJitInfo *ji;
4824         guint8 *ip;
4825         int i, j, suspend_policy;
4826         guint32 native_offset;
4827         MonoBreakpoint *bp;
4828         BreakpointInstance *inst;
4829         GPtrArray *bp_reqs, *ss_reqs_orig, *ss_reqs;
4830         GSList *bp_events = NULL, *ss_events = NULL, *enter_leave_events = NULL;
4831         EventKind kind = EVENT_KIND_BREAKPOINT;
4832         MonoContext *ctx = &tls->restore_state.ctx;
4833         MonoMethod *method;
4834         MonoSeqPointInfo *info;
4835         SeqPoint sp;
4836         gboolean found_sp;
4837
4838         // FIXME: Speed this up
4839
4840         ip = (guint8 *)MONO_CONTEXT_GET_IP (ctx);
4841         ji = mini_jit_info_table_find (mono_domain_get (), (char*)ip, NULL);
4842
4843         if (!ji) {
4844                 /* Interpreter */
4845                 // FIXME: Pass a flag instead to detect this
4846                 MonoLMF *lmf = mono_get_lmf ();
4847                 MonoInterpFrameHandle *frame;
4848
4849                 g_assert (((guint64)lmf->previous_lmf) & 2);
4850                 MonoLMFExt *ext = (MonoLMFExt*)lmf;
4851
4852                 g_assert (ext->interp_exit);
4853                 frame = ext->interp_exit_data;
4854                 ji = mono_interp_frame_get_jit_info (frame);
4855                 ip = mono_interp_frame_get_ip (frame);
4856         }
4857
4858         g_assert (ji && !ji->is_trampoline);
4859         method = jinfo_get_method (ji);
4860
4861         /* Compute the native offset of the breakpoint from the ip */
4862         native_offset = ip - (guint8*)ji->code_start;
4863
4864         /*
4865          * Skip the instruction causing the breakpoint signal.
4866          */
4867         if (from_signal)
4868                 mono_arch_skip_breakpoint (ctx, ji);
4869
4870         if (method->wrapper_type || tls->disable_breakpoints)
4871                 return;
4872
4873         bp_reqs = g_ptr_array_new ();
4874         ss_reqs = g_ptr_array_new ();
4875         ss_reqs_orig = g_ptr_array_new ();
4876
4877         mono_loader_lock ();
4878
4879         /*
4880          * The ip points to the instruction causing the breakpoint event, which is after
4881          * the offset recorded in the seq point map, so find the prev seq point before ip.
4882          */
4883         found_sp = mono_find_prev_seq_point_for_native_offset (mono_domain_get (), method, native_offset, &info, &sp);
4884
4885         if (!found_sp)
4886                 no_seq_points_found (method, native_offset);
4887
4888         g_assert (found_sp);
4889
4890         DEBUG_PRINTF (1, "[%p] Breakpoint hit, method=%s, ip=%p, [il=0x%x,native=0x%x].\n", (gpointer) (gsize) mono_native_thread_id_get (), method->name, ip, sp.il_offset, native_offset);
4891
4892         bp = NULL;
4893         for (i = 0; i < breakpoints->len; ++i) {
4894                 bp = (MonoBreakpoint *)g_ptr_array_index (breakpoints, i);
4895
4896                 if (!bp->method)
4897                         continue;
4898
4899                 for (j = 0; j < bp->children->len; ++j) {
4900                         inst = (BreakpointInstance *)g_ptr_array_index (bp->children, j);
4901                         if (inst->ji == ji && inst->il_offset == sp.il_offset && inst->native_offset == sp.native_offset) {
4902                                 if (bp->req->event_kind == EVENT_KIND_STEP) {
4903                                         g_ptr_array_add (ss_reqs_orig, bp->req);
4904                                 } else {
4905                                         g_ptr_array_add (bp_reqs, bp->req);
4906                                 }
4907                         }
4908                 }
4909         }
4910         if (bp_reqs->len == 0 && ss_reqs_orig->len == 0) {
4911                 /* Maybe a method entry/exit event */
4912                 if (sp.il_offset == METHOD_ENTRY_IL_OFFSET)
4913                         kind = EVENT_KIND_METHOD_ENTRY;
4914                 else if (sp.il_offset == METHOD_EXIT_IL_OFFSET)
4915                         kind = EVENT_KIND_METHOD_EXIT;
4916         }
4917
4918         /* Process single step requests */
4919         for (i = 0; i < ss_reqs_orig->len; ++i) {
4920                 EventRequest *req = (EventRequest *)g_ptr_array_index (ss_reqs_orig, i);
4921                 SingleStepReq *ss_req = (SingleStepReq *)req->info;
4922                 gboolean hit;
4923
4924                 //if we hit async_stepout_method, it's our no matter which thread
4925                 if ((ss_req->async_stepout_method != method) && (ss_req->async_id || mono_thread_internal_current () != ss_req->thread)) {
4926                         //We have different thread and we don't have async stepping in progress
4927                         //it's breakpoint in parallel thread, ignore it
4928                         if (ss_req->async_id == 0)
4929                                 continue;
4930
4931                         tls->context.valid = FALSE;
4932                         tls->async_state.valid = FALSE;
4933                         invalidate_frames (tls);
4934                         ss_calculate_framecount(tls, ctx);
4935                         //make sure we have enough data to get current async method instance id
4936                         if (tls->frame_count == 0 || !ensure_jit (tls->frames [0]))
4937                                 continue;
4938
4939                         //Check method is async before calling get_this_async_id
4940                         MonoDebugMethodAsyncInfo* asyncMethod = mono_debug_lookup_method_async_debug_info (method);
4941                         if (!asyncMethod)
4942                                 continue;
4943                         else
4944                                 mono_debug_free_method_async_debug_info (asyncMethod);
4945
4946                         //breakpoint was hit in parallelly executing async method, ignore it
4947                         if (ss_req->async_id != get_this_async_id (tls->frames [0]))
4948                                 continue;
4949                 }
4950
4951                 //Update stepping request to new thread/frame_count that we are continuing on
4952                 //so continuing with normal stepping works as expected
4953                 if (ss_req->async_stepout_method || ss_req->async_id) {
4954                         tls->context.valid = FALSE;
4955                         tls->async_state.valid = FALSE;
4956                         invalidate_frames (tls);
4957                         ss_calculate_framecount (tls, ctx);
4958                         ss_req->thread = mono_thread_internal_current ();
4959                         ss_req->nframes = tls->frame_count;
4960                 }
4961
4962                 hit = ss_update (ss_req, ji, &sp, tls, ctx, method);
4963                 if (hit)
4964                         g_ptr_array_add (ss_reqs, req);
4965
4966                 /* Start single stepping again from the current sequence point */
4967                 ss_start (ss_req, method, &sp, info, ctx, tls, FALSE, NULL, 0);
4968         }
4969
4970         if (ss_reqs->len > 0)
4971                 ss_events = create_event_list (EVENT_KIND_STEP, ss_reqs, ji, NULL, &suspend_policy);
4972         if (bp_reqs->len > 0)
4973                 bp_events = create_event_list (EVENT_KIND_BREAKPOINT, bp_reqs, ji, NULL, &suspend_policy);
4974         if (kind != EVENT_KIND_BREAKPOINT)
4975                 enter_leave_events = create_event_list (kind, NULL, ji, NULL, &suspend_policy);
4976
4977         mono_loader_unlock ();
4978
4979         g_ptr_array_free (bp_reqs, TRUE);
4980         g_ptr_array_free (ss_reqs, TRUE);
4981
4982         /*
4983          * FIXME: The first event will suspend, so the second will only be sent after the
4984          * resume.
4985          */
4986         if (ss_events)
4987                 process_event (EVENT_KIND_STEP, method, 0, ctx, ss_events, suspend_policy);
4988         if (bp_events)
4989                 process_event (kind, method, 0, ctx, bp_events, suspend_policy);
4990         if (enter_leave_events)
4991                 process_event (kind, method, 0, ctx, enter_leave_events, suspend_policy);
4992 }
4993
4994 /* Process a breakpoint/single step event after resuming from a signal handler */
4995 static void
4996 process_signal_event (void (*func) (DebuggerTlsData*, gboolean))
4997 {
4998         DebuggerTlsData *tls;
4999         MonoThreadUnwindState orig_restore_state;
5000         MonoContext ctx;
5001
5002         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
5003         /* Have to save/restore the restore_ctx as we can be called recursively during invokes etc. */
5004         memcpy (&orig_restore_state, &tls->restore_state, sizeof (MonoThreadUnwindState));
5005         mono_thread_state_init_from_monoctx (&tls->restore_state, &tls->handler_ctx);
5006
5007         func (tls, TRUE);
5008
5009         /* This is called when resuming from a signal handler, so it shouldn't return */
5010         memcpy (&ctx, &tls->restore_state.ctx, sizeof (MonoContext));
5011         memcpy (&tls->restore_state, &orig_restore_state, sizeof (MonoThreadUnwindState));
5012         mono_restore_context (&ctx);
5013         g_assert_not_reached ();
5014 }
5015
5016 static void
5017 process_breakpoint_from_signal (void)
5018 {
5019         process_signal_event (process_breakpoint);
5020 }
5021
5022 static void
5023 resume_from_signal_handler (void *sigctx, void *func)
5024 {
5025         DebuggerTlsData *tls;
5026         MonoContext ctx;
5027
5028         /* Save the original context in TLS */
5029         // FIXME: This might not work on an altstack ?
5030         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
5031         if (!tls)
5032                 fprintf (stderr, "Thread %p is not attached to the JIT.\n", (gpointer) (gsize) mono_native_thread_id_get ());
5033         g_assert (tls);
5034
5035         // FIXME: MonoContext usually doesn't include the fp registers, so these are
5036         // clobbered by a single step/breakpoint event. If this turns out to be a problem,
5037         // clob:c could be added to op_seq_point.
5038
5039         mono_sigctx_to_monoctx (sigctx, &ctx);
5040         memcpy (&tls->handler_ctx, &ctx, sizeof (MonoContext));
5041 #ifdef MONO_ARCH_HAVE_SETUP_RESUME_FROM_SIGNAL_HANDLER_CTX
5042         mono_arch_setup_resume_sighandler_ctx (&ctx, func);
5043 #else
5044         MONO_CONTEXT_SET_IP (&ctx, func);
5045 #endif
5046         mono_monoctx_to_sigctx (&ctx, sigctx);
5047
5048 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
5049         mono_ppc_set_func_into_sigctx (sigctx, func);
5050 #endif
5051 }
5052
5053 void
5054 mono_debugger_agent_breakpoint_hit (void *sigctx)
5055 {
5056         /*
5057          * We are called from a signal handler, and running code there causes all kinds of
5058          * problems, like the original signal is disabled, libgc can't handle altstack, etc.
5059          * So set up the signal context to return to the real breakpoint handler function.
5060          */
5061         resume_from_signal_handler (sigctx, process_breakpoint_from_signal);
5062 }
5063
5064 typedef struct {
5065         gboolean found;
5066         MonoContext *ctx;
5067 } UserBreakCbData;
5068
5069 static gboolean
5070 user_break_cb (StackFrameInfo *frame, MonoContext *ctx, gpointer user_data)
5071 {
5072         UserBreakCbData *data = user_data;
5073
5074         if (frame->type == FRAME_TYPE_INTERP_TO_MANAGED) {
5075                 data->found = TRUE;
5076                 return TRUE;
5077         }
5078         if (frame->managed) {
5079                 data->found = TRUE;
5080                 *data->ctx = *ctx;
5081
5082                 return TRUE;
5083         }
5084         return FALSE;
5085 }
5086
5087 /*
5088  * Called by System.Diagnostics.Debugger:Break ().
5089  */
5090 void
5091 mono_debugger_agent_user_break (void)
5092 {
5093         if (agent_config.enabled) {
5094                 MonoContext ctx;
5095                 int suspend_policy;
5096                 GSList *events;
5097                 UserBreakCbData data;
5098
5099                 memset (&data, 0, sizeof (UserBreakCbData));
5100                 data.ctx = &ctx;
5101
5102                 /* Obtain a context */
5103                 MONO_CONTEXT_SET_IP (&ctx, NULL);
5104                 mono_walk_stack_with_ctx (user_break_cb, NULL, (MonoUnwindOptions)0, &data);
5105                 g_assert (data.found);
5106
5107                 mono_loader_lock ();
5108                 events = create_event_list (EVENT_KIND_USER_BREAK, NULL, NULL, NULL, &suspend_policy);
5109                 mono_loader_unlock ();
5110
5111                 process_event (EVENT_KIND_USER_BREAK, NULL, 0, &ctx, events, suspend_policy);
5112         } else if (debug_options.native_debugger_break) {
5113                 G_BREAKPOINT ();
5114         }
5115 }
5116
5117 static const char*
5118 ss_depth_to_string (StepDepth depth)
5119 {
5120         switch (depth) {
5121         case STEP_DEPTH_OVER:
5122                 return "over";
5123         case STEP_DEPTH_OUT:
5124                 return "out";
5125         case STEP_DEPTH_INTO:
5126                 return "into";
5127         default:
5128                 g_assert_not_reached ();
5129                 return NULL;
5130         }
5131 }
5132
5133 static void
5134 process_single_step_inner (DebuggerTlsData *tls, gboolean from_signal)
5135 {
5136         MonoJitInfo *ji;
5137         guint8 *ip;
5138         GPtrArray *reqs;
5139         int il_offset, suspend_policy;
5140         MonoDomain *domain;
5141         GSList *events;
5142         MonoContext *ctx = &tls->restore_state.ctx;
5143         MonoMethod *method;
5144         SeqPoint sp;
5145         MonoSeqPointInfo *info;
5146
5147         /* Skip the instruction causing the single step */
5148         if (from_signal)
5149                 mono_arch_skip_single_step (ctx);
5150
5151         if (suspend_count > 0) {
5152                 /* Fastpath during invokes, see in process_suspend () */
5153                 if (suspend_count - tls->resume_count == 0)
5154                         return;
5155                 process_suspend (tls, ctx);
5156                 return;
5157         }
5158
5159         if (!ss_req)
5160                 // FIXME: A suspend race
5161                 return;
5162
5163         if (mono_thread_internal_current () != ss_req->thread)
5164                 return;
5165
5166         ip = (guint8 *)MONO_CONTEXT_GET_IP (ctx);
5167
5168         ji = get_top_method_ji (ip, &domain, (gpointer*)&ip);
5169         g_assert (ji && !ji->is_trampoline);
5170
5171         if (log_level > 0) {
5172                 DEBUG_PRINTF (1, "[%p] Single step event (depth=%s) at %s (%p)[0x%x], sp %p, last sp %p\n", (gpointer) (gsize) mono_native_thread_id_get (), ss_depth_to_string (ss_req->depth), mono_method_full_name (jinfo_get_method (ji), TRUE), MONO_CONTEXT_GET_IP (ctx), (int)((guint8*)MONO_CONTEXT_GET_IP (ctx) - (guint8*)ji->code_start), MONO_CONTEXT_GET_SP (ctx), ss_req->last_sp);
5173         }
5174
5175         method = jinfo_get_method (ji);
5176         g_assert (method);
5177
5178         if (method->wrapper_type && method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD)
5179                 return;
5180
5181         /*
5182          * FIXME:
5183          * Stopping in memset makes half-initialized vtypes visible.
5184          * Stopping in memcpy makes half-copied vtypes visible.
5185          */
5186         if (method->klass == mono_defaults.string_class && (!strcmp (method->name, "memset") || strstr (method->name, "memcpy")))
5187                 return;
5188
5189         /*
5190          * This could be in ss_update method, but mono_find_next_seq_point_for_native_offset is pretty expensive method,
5191          * hence we prefer this check here.
5192          */
5193         if (ss_req->user_assemblies) {
5194                 gboolean found = FALSE;
5195                 for (int k = 0; ss_req->user_assemblies[k]; k++)
5196                         if (ss_req->user_assemblies[k] == method->klass->image->assembly) {
5197                                 found = TRUE;
5198                                 break;
5199                         }
5200                 if (!found)
5201                         return;
5202         }
5203
5204
5205         /*
5206          * The ip points to the instruction causing the single step event, which is before
5207          * the offset recorded in the seq point map, so find the next seq point after ip.
5208          */
5209         if (!mono_find_next_seq_point_for_native_offset (domain, method, (guint8*)ip - (guint8*)ji->code_start, &info, &sp)) {
5210                 g_assert_not_reached ();
5211                 return;
5212         }
5213
5214         il_offset = sp.il_offset;
5215
5216         if (!ss_update (ss_req, ji, &sp, tls, ctx, method))
5217                 return;
5218
5219         /* Start single stepping again from the current sequence point */
5220         ss_start (ss_req, method, &sp, info, ctx, tls, FALSE, NULL, 0);
5221
5222         if ((ss_req->filter & STEP_FILTER_STATIC_CTOR) &&
5223                 (method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME) &&
5224                 !strcmp (method->name, ".cctor"))
5225                 return;
5226
5227         // FIXME: Has to lock earlier
5228
5229         reqs = g_ptr_array_new ();
5230
5231         mono_loader_lock ();
5232
5233         g_ptr_array_add (reqs, ss_req->req);
5234
5235         events = create_event_list (EVENT_KIND_STEP, reqs, ji, NULL, &suspend_policy);
5236
5237         g_ptr_array_free (reqs, TRUE);
5238
5239         mono_loader_unlock ();
5240
5241         process_event (EVENT_KIND_STEP, jinfo_get_method (ji), il_offset, ctx, events, suspend_policy);
5242 }
5243
5244 static void
5245 process_single_step (void)
5246 {
5247         process_signal_event (process_single_step_inner);
5248 }
5249
5250 /*
5251  * mono_debugger_agent_single_step_event:
5252  *
5253  *   Called from a signal handler to handle a single step event.
5254  */
5255 void
5256 mono_debugger_agent_single_step_event (void *sigctx)
5257 {
5258         /* Resume to process_single_step through the signal context */
5259
5260         // FIXME: Since step out/over is implemented using step in, the step in case should
5261         // be as fast as possible. Move the relevant code from process_single_step_inner ()
5262         // here
5263
5264         if (is_debugger_thread ()) {
5265                 /*
5266                  * This could happen despite our best effors when the runtime calls
5267                  * assembly/type resolve hooks.
5268                  * FIXME: Breakpoints too.
5269                  */
5270                 MonoContext ctx;
5271
5272                 mono_sigctx_to_monoctx (sigctx, &ctx);
5273                 mono_arch_skip_single_step (&ctx);
5274                 mono_monoctx_to_sigctx (&ctx, sigctx);
5275                 return;
5276         }
5277
5278         resume_from_signal_handler (sigctx, process_single_step);
5279 }
5280
5281 void
5282 debugger_agent_single_step_from_context (MonoContext *ctx)
5283 {
5284         DebuggerTlsData *tls;
5285         MonoThreadUnwindState orig_restore_state;
5286
5287         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
5288         /* Fastpath during invokes, see in process_suspend () */
5289         if (tls && suspend_count && suspend_count - tls->resume_count == 0)
5290                 return;
5291
5292         if (is_debugger_thread ())
5293                 return;
5294
5295         g_assert (tls);
5296
5297         /* Have to save/restore the restore_ctx as we can be called recursively during invokes etc. */
5298         memcpy (&orig_restore_state, &tls->restore_state, sizeof (MonoThreadUnwindState));
5299         mono_thread_state_init_from_monoctx (&tls->restore_state, ctx);
5300         memcpy (&tls->handler_ctx, ctx, sizeof (MonoContext));
5301
5302         process_single_step_inner (tls, FALSE);
5303
5304         memcpy (ctx, &tls->restore_state.ctx, sizeof (MonoContext));
5305         memcpy (&tls->restore_state, &orig_restore_state, sizeof (MonoThreadUnwindState));
5306 }
5307
5308 void
5309 debugger_agent_breakpoint_from_context (MonoContext *ctx)
5310 {
5311         DebuggerTlsData *tls;
5312         MonoThreadUnwindState orig_restore_state;
5313         guint8 *orig_ip;
5314
5315         if (is_debugger_thread ())
5316                 return;
5317
5318         orig_ip = (guint8 *)MONO_CONTEXT_GET_IP (ctx);
5319         MONO_CONTEXT_SET_IP (ctx, orig_ip - 1);
5320
5321         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
5322         g_assert (tls);
5323         memcpy (&orig_restore_state, &tls->restore_state, sizeof (MonoThreadUnwindState));
5324         mono_thread_state_init_from_monoctx (&tls->restore_state, ctx);
5325         memcpy (&tls->handler_ctx, ctx, sizeof (MonoContext));
5326
5327         process_breakpoint (tls, FALSE);
5328
5329         memcpy (ctx, &tls->restore_state.ctx, sizeof (MonoContext));
5330         memcpy (&tls->restore_state, &orig_restore_state, sizeof (MonoThreadUnwindState));
5331         if (MONO_CONTEXT_GET_IP (ctx) == orig_ip - 1)
5332                 MONO_CONTEXT_SET_IP (ctx, orig_ip);
5333 }
5334
5335 /*
5336  * start_single_stepping:
5337  *
5338  *   Turn on single stepping. Can be called multiple times, for example,
5339  * by a single step event request + a suspend.
5340  */
5341 static void
5342 start_single_stepping (void)
5343 {
5344 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
5345         int val = InterlockedIncrement (&ss_count);
5346
5347         if (val == 1) {
5348                 mono_arch_start_single_stepping ();
5349                 mono_interp_start_single_stepping ();
5350         }
5351 #else
5352         g_assert_not_reached ();
5353 #endif
5354 }
5355
5356 static void
5357 stop_single_stepping (void)
5358 {
5359 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
5360         int val = InterlockedDecrement (&ss_count);
5361
5362         if (val == 0) {
5363                 mono_arch_stop_single_stepping ();
5364                 mono_interp_stop_single_stepping ();
5365         }
5366 #else
5367         g_assert_not_reached ();
5368 #endif
5369 }
5370
5371 /*
5372  * ss_stop:
5373  *
5374  *   Stop the single stepping operation given by SS_REQ.
5375  */
5376 static void
5377 ss_stop (SingleStepReq *ss_req)
5378 {
5379         if (ss_req->bps) {
5380                 GSList *l;
5381
5382                 for (l = ss_req->bps; l; l = l->next) {
5383                         clear_breakpoint ((MonoBreakpoint *)l->data);
5384                 }
5385                 g_slist_free (ss_req->bps);
5386                 ss_req->bps = NULL;
5387         }
5388
5389         ss_req->async_id = 0;
5390         ss_req->async_stepout_method = NULL;
5391         if (ss_req->global) {
5392                 stop_single_stepping ();
5393                 ss_req->global = FALSE;
5394         }
5395 }
5396
5397 /*
5398  * ss_bp_is_unique:
5399  *
5400  * Reject breakpoint if it is a duplicate of one already in list or hash table.
5401  */
5402 static gboolean
5403 ss_bp_is_unique (GSList *bps, GHashTable *ss_req_bp_cache, MonoMethod *method, guint32 il_offset)
5404 {
5405         if (ss_req_bp_cache) {
5406                 MonoBreakpoint dummy = {method, il_offset, NULL, NULL};
5407                 return !g_hash_table_lookup (ss_req_bp_cache, &dummy);
5408         }
5409         for (GSList *l = bps; l; l = l->next) {
5410                 MonoBreakpoint *bp = (MonoBreakpoint *)l->data;
5411                 if (bp->method == method && bp->il_offset == il_offset)
5412                         return FALSE;
5413         }
5414         return TRUE;
5415 }
5416
5417 /*
5418  * ss_bp_eq:
5419  *
5420  * GHashTable equality for a MonoBreakpoint (only care about method and il_offset fields)
5421  */
5422 static gint
5423 ss_bp_eq (gconstpointer ka, gconstpointer kb)
5424 {
5425         const MonoBreakpoint *s1 = (const MonoBreakpoint *)ka;
5426         const MonoBreakpoint *s2 = (const MonoBreakpoint *)kb;
5427         return (s1->method == s2->method && s1->il_offset == s2->il_offset) ? 1 : 0;
5428 }
5429
5430 /*
5431  * ss_bp_eq:
5432  *
5433  * GHashTable hash for a MonoBreakpoint (only care about method and il_offset fields)
5434  */
5435 static guint
5436 ss_bp_hash (gconstpointer data)
5437 {
5438         const MonoBreakpoint *s = (const MonoBreakpoint *)data;
5439         guint hash = (guint) (uintptr_t) s->method;
5440         hash ^= ((guint)s->il_offset) << 16; // Assume low bits are more interesting
5441         hash ^= ((guint)s->il_offset) >> 16;
5442         return hash;
5443 }
5444
5445 #define MAX_LINEAR_SCAN_BPS 7
5446
5447 /*
5448  * ss_bp_add_one:
5449  *
5450  * Create a new breakpoint and add it to a step request.
5451  * Will adjust the bp count and cache used by ss_start.
5452  */
5453 static void
5454 ss_bp_add_one (SingleStepReq *ss_req, int *ss_req_bp_count, GHashTable **ss_req_bp_cache,
5455                   MonoMethod *method, guint32 il_offset)
5456 {
5457         // This list is getting too long, switch to using the hash table
5458         if (!*ss_req_bp_cache && *ss_req_bp_count > MAX_LINEAR_SCAN_BPS) {
5459                 *ss_req_bp_cache = g_hash_table_new (ss_bp_hash, ss_bp_eq);
5460                 for (GSList *l = ss_req->bps; l; l = l->next)
5461                         g_hash_table_insert (*ss_req_bp_cache, l->data, l->data);
5462         }
5463
5464         if (ss_bp_is_unique (ss_req->bps, *ss_req_bp_cache, method, il_offset)) {
5465                 // Create and add breakpoint
5466                 MonoBreakpoint *bp = set_breakpoint (method, il_offset, ss_req->req, NULL);
5467                 ss_req->bps = g_slist_append (ss_req->bps, bp);
5468                 if (*ss_req_bp_cache)
5469                         g_hash_table_insert (*ss_req_bp_cache, bp, bp);
5470                 (*ss_req_bp_count)++;
5471         } else {
5472                 DEBUG_PRINTF (1, "[dbg] Candidate breakpoint at %s:[il=0x%x] is a duplicate for this step request, will not add.\n", mono_method_full_name (method, TRUE), (int)il_offset);
5473         }
5474 }
5475
5476 static gboolean
5477 is_last_non_empty (SeqPoint* sp, MonoSeqPointInfo *info)
5478 {
5479         if (!sp->next_len)
5480                 return TRUE;
5481         SeqPoint* next = g_new (SeqPoint, sp->next_len);
5482         mono_seq_point_init_next (info, *sp, next);
5483         for (int i = 0; i < sp->next_len; i++) {
5484                 if (next [i].flags & MONO_SEQ_POINT_FLAG_NONEMPTY_STACK) {
5485                         if (!is_last_non_empty (&next [i], info)) {
5486                                 g_free (next);
5487                                 return FALSE;
5488                         }
5489                 } else {
5490                         g_free (next);
5491                         return FALSE;
5492                 }
5493         }
5494         g_free (next);
5495         return TRUE;
5496 }
5497
5498 /*
5499  * ss_start:
5500  *
5501  *   Start the single stepping operation given by SS_REQ from the sequence point SP.
5502  * If CTX is not set, then this can target any thread. If CTX is set, then TLS should
5503  * belong to the same thread as CTX.
5504  * If FRAMES is not-null, use that instead of tls->frames for placing breakpoints etc.
5505  */
5506 static void
5507 ss_start (SingleStepReq *ss_req, MonoMethod *method, SeqPoint* sp, MonoSeqPointInfo *info, MonoContext *ctx, DebuggerTlsData *tls,
5508                   gboolean step_to_catch, StackFrame **frames, int nframes)
5509 {
5510         int i, j, frame_index;
5511         SeqPoint *next_sp, *parent_sp = NULL;
5512         SeqPoint local_sp, local_parent_sp;
5513         gboolean found_sp;
5514         MonoSeqPointInfo *parent_info;
5515         MonoMethod *parent_sp_method = NULL;
5516         gboolean enable_global = FALSE;
5517
5518         // When 8 or more entries are in bps, we build a hash table to serve as a set of breakpoints.
5519         // Recreating this on each pass is a little wasteful but at least keeps behavior linear.
5520         int ss_req_bp_count = g_slist_length (ss_req->bps);
5521         GHashTable *ss_req_bp_cache = NULL;
5522
5523         /* Stop the previous operation */
5524         ss_stop (ss_req);
5525
5526         /*
5527          * Implement single stepping using breakpoints if possible.
5528          */
5529         if (step_to_catch) {
5530                 ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, method, sp->il_offset);
5531         } else {
5532                 frame_index = 1;
5533
5534                 if (ctx && !frames) {
5535                         /* Need parent frames */
5536                         if (!tls->context.valid)
5537                                 mono_thread_state_init_from_monoctx (&tls->context, ctx);
5538                         compute_frame_info (tls->thread, tls);
5539                         frames = tls->frames;
5540                         nframes = tls->frame_count;
5541                 }
5542
5543                 MonoDebugMethodAsyncInfo* asyncMethod = mono_debug_lookup_method_async_debug_info (method);
5544
5545                 /* Need to stop in catch clauses as well */
5546                 for (i = ss_req->depth == STEP_DEPTH_OUT ? 1 : 0; i < nframes; ++i) {
5547                         StackFrame *frame = frames [i];
5548
5549                         if (frame->ji) {
5550                                 MonoJitInfo *jinfo = frame->ji;
5551                                 for (j = 0; j < jinfo->num_clauses; ++j) {
5552                                         // In case of async method we don't want to place breakpoint on last catch handler(which state machine added for whole method)
5553                                         if (asyncMethod && asyncMethod->num_awaits && i == 0 && j + 1 == jinfo->num_clauses)
5554                                                 break;
5555                                         MonoJitExceptionInfo *ei = &jinfo->clauses [j];
5556
5557                                         if (mono_find_next_seq_point_for_native_offset (frame->domain, frame->method, (char*)ei->handler_start - (char*)jinfo->code_start, NULL, &local_sp))
5558                                                 ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, frame->method, local_sp.il_offset);
5559                                 }
5560                         }
5561                 }
5562
5563                 if (asyncMethod && asyncMethod->num_awaits && nframes && ensure_jit (frames [0])) {
5564                         //asyncMethod has value and num_awaits > 0, this means we are inside async method with awaits
5565
5566                         // Check if we hit yield_offset during normal stepping, because if we did...
5567                         // Go into special async stepping mode which places breakpoint on resumeOffset
5568                         // of this await call and sets async_id so we can distinguish it from parallel executions
5569                         for (i = 0; i < asyncMethod->num_awaits; i++) {
5570                                 if (sp->il_offset == asyncMethod->yield_offsets [i]) {
5571                                         ss_req->async_id = get_this_async_id (frames [0]);
5572                                         ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, method, asyncMethod->resume_offsets [i]);
5573                                         if (ss_req_bp_cache)
5574                                                 g_hash_table_destroy (ss_req_bp_cache);
5575                                         mono_debug_free_method_async_debug_info (asyncMethod);
5576                                         return;
5577                                 }
5578                         }
5579                         //If we are at end of async method and doing step-in or step-over...
5580                         //Switch to step-out, so whole NotifyDebuggerOfWaitCompletion magic happens...
5581                         if (is_last_non_empty (sp, info)) {
5582                                 ss_req->depth = STEP_DEPTH_OUT;//setting depth to step-out is important, don't inline IF, because code later depends on this
5583                         }
5584                         if (ss_req->depth == STEP_DEPTH_OUT) {
5585                                 set_set_notification_for_wait_completion_flag (frames [0]);
5586                                 ss_req->async_id = get_this_async_id (frames [0]);
5587                                 ss_req->async_stepout_method = get_notify_debugger_of_wait_completion_method ();
5588                                 ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, ss_req->async_stepout_method, 0);
5589                                 if (ss_req_bp_cache)
5590                                         g_hash_table_destroy (ss_req_bp_cache);
5591                                 mono_debug_free_method_async_debug_info (asyncMethod);
5592                                 return;
5593                         }
5594                 }
5595
5596                 if (asyncMethod)
5597                         mono_debug_free_method_async_debug_info (asyncMethod);
5598
5599                 /*
5600                 * Find the first sequence point in the current or in a previous frame which
5601                 * is not the last in its method.
5602                 */
5603                 if (ss_req->depth == STEP_DEPTH_OUT) {
5604                         /* Ignore seq points in current method */
5605                         while (frame_index < nframes) {
5606                                 StackFrame *frame = frames [frame_index];
5607
5608                                 method = frame->method;
5609                                 found_sp = mono_find_prev_seq_point_for_native_offset (frame->domain, frame->method, frame->native_offset, &info, &local_sp);
5610                                 sp = (found_sp)? &local_sp : NULL;
5611                                 frame_index ++;
5612                                 if (sp && sp->next_len != 0)
5613                                         break;
5614                         }
5615                         // There could be method calls before the next seq point in the caller when using nested calls
5616                         //enable_global = TRUE;
5617                 } else {
5618                         if (sp && sp->next_len == 0) {
5619                                 sp = NULL;
5620                                 while (frame_index < nframes) {
5621                                         StackFrame *frame = frames [frame_index];
5622
5623                                         method = frame->method;
5624                                         found_sp = mono_find_prev_seq_point_for_native_offset (frame->domain, frame->method, frame->native_offset, &info, &local_sp);
5625                                         sp = (found_sp)? &local_sp : NULL;
5626                                         if (sp && sp->next_len != 0)
5627                                                 break;
5628                                         sp = NULL;
5629                                         frame_index ++;
5630                                 }
5631                         } else {
5632                                 /* Have to put a breakpoint into a parent frame since the seq points might not cover all control flow out of the method */
5633                                 while (frame_index < nframes) {
5634                                         StackFrame *frame = frames [frame_index];
5635
5636                                         parent_sp_method = frame->method;
5637                                         found_sp = mono_find_prev_seq_point_for_native_offset (frame->domain, frame->method, frame->native_offset, &parent_info, &local_parent_sp);
5638                                         parent_sp = found_sp ? &local_parent_sp : NULL;
5639                                         if (found_sp && parent_sp->next_len != 0)
5640                                                 break;
5641                                         parent_sp = NULL;
5642                                         frame_index ++;
5643                                 }
5644                         }
5645                 }
5646
5647                 if (sp && sp->next_len > 0) {
5648                         SeqPoint* next = g_new(SeqPoint, sp->next_len);
5649
5650                         mono_seq_point_init_next (info, *sp, next);
5651                         for (i = 0; i < sp->next_len; i++) {
5652                                 next_sp = &next[i];
5653
5654                                 ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, method, next_sp->il_offset);
5655                         }
5656                         g_free (next);
5657                 }
5658
5659                 if (parent_sp) {
5660                         SeqPoint* next = g_new(SeqPoint, parent_sp->next_len);
5661
5662                         mono_seq_point_init_next (parent_info, *parent_sp, next);
5663                         for (i = 0; i < parent_sp->next_len; i++) {
5664                                 next_sp = &next[i];
5665
5666                                 ss_bp_add_one (ss_req, &ss_req_bp_count, &ss_req_bp_cache, parent_sp_method, next_sp->il_offset);
5667                         }
5668                         g_free (next);
5669                 }
5670
5671                 if (ss_req->nframes == 0)
5672                         ss_req->nframes = nframes;
5673
5674                 if ((ss_req->depth == STEP_DEPTH_OVER) && (!sp && !parent_sp)) {
5675                         DEBUG_PRINTF (1, "[dbg] No parent frame for step over, transition to step into.\n");
5676                         /*
5677                          * This is needed since if we leave managed code, and later return to it, step over
5678                          * is not going to stop.
5679                          * This approach is a bit ugly, since we change the step depth, but it only affects
5680                          * clients who reuse the same step request, and only in this special case.
5681                          */
5682                         ss_req->depth = STEP_DEPTH_INTO;
5683                 }
5684
5685                 if (ss_req->depth == STEP_DEPTH_INTO) {
5686                         /* Enable global stepping so we stop at method entry too */
5687                         enable_global = TRUE;
5688                 }
5689
5690                 /*
5691                  * The ctx/frame info computed above will become invalid when we continue.
5692                  */
5693                 tls->context.valid = FALSE;
5694                 tls->async_state.valid = FALSE;
5695                 invalidate_frames (tls);
5696         }
5697
5698         if (enable_global) {
5699                 DEBUG_PRINTF (1, "[dbg] Turning on global single stepping.\n");
5700                 ss_req->global = TRUE;
5701                 start_single_stepping ();
5702         } else if (!ss_req->bps) {
5703                 DEBUG_PRINTF (1, "[dbg] Turning on global single stepping.\n");
5704                 ss_req->global = TRUE;
5705                 start_single_stepping ();
5706         } else {
5707                 ss_req->global = FALSE;
5708         }
5709
5710         if (ss_req_bp_cache)
5711                 g_hash_table_destroy (ss_req_bp_cache);
5712 }
5713
5714 /*
5715  * Start single stepping of thread THREAD
5716  */
5717 static ErrorCode
5718 ss_create (MonoInternalThread *thread, StepSize size, StepDepth depth, StepFilter filter, EventRequest *req)
5719 {
5720         DebuggerTlsData *tls;
5721         MonoSeqPointInfo *info = NULL;
5722         SeqPoint *sp = NULL;
5723         SeqPoint local_sp;
5724         gboolean found_sp;
5725         MonoMethod *method = NULL;
5726         MonoDebugMethodInfo *minfo;
5727         gboolean step_to_catch = FALSE;
5728         gboolean set_ip = FALSE;
5729         StackFrame **frames = NULL;
5730         int nframes = 0;
5731
5732         if (suspend_count == 0)
5733                 return ERR_NOT_SUSPENDED;
5734
5735         wait_for_suspend ();
5736
5737         // FIXME: Multiple requests
5738         if (ss_req) {
5739                 DEBUG_PRINTF (0, "Received a single step request while the previous one was still active.\n");
5740                 return ERR_NOT_IMPLEMENTED;
5741         }
5742
5743         DEBUG_PRINTF (1, "[dbg] Starting single step of thread %p (depth=%s).\n", thread, ss_depth_to_string (depth));
5744
5745         ss_req = g_new0 (SingleStepReq, 1);
5746         ss_req->req = req;
5747         ss_req->thread = thread;
5748         ss_req->size = size;
5749         ss_req->depth = depth;
5750         ss_req->filter = filter;
5751         req->info = ss_req;
5752
5753         for (int i = 0; i < req->nmodifiers; i++) {
5754                 if (req->modifiers[i].kind == MOD_KIND_ASSEMBLY_ONLY) {
5755                         ss_req->user_assemblies = req->modifiers[i].data.assemblies;
5756                         break;
5757                 }
5758         }
5759
5760         mono_loader_lock ();
5761         tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
5762         mono_loader_unlock ();
5763         g_assert (tls);
5764         if (!tls->context.valid) {
5765                 DEBUG_PRINTF (1, "Received a single step request on a thread with no managed frames.");
5766                 return ERR_INVALID_ARGUMENT;
5767         }
5768
5769         if (tls->restore_state.valid && MONO_CONTEXT_GET_IP (&tls->context.ctx) != MONO_CONTEXT_GET_IP (&tls->restore_state.ctx)) {
5770                 /*
5771                  * Need to start single stepping from restore_state and not from the current state
5772                  */
5773                 set_ip = TRUE;
5774                 frames = compute_frame_info_from (thread, tls, &tls->restore_state, &nframes);
5775         }
5776
5777         ss_req->start_sp = ss_req->last_sp = MONO_CONTEXT_GET_SP (&tls->context.ctx);
5778
5779         if (tls->catch_state.valid) {
5780                 gboolean res;
5781                 StackFrameInfo frame;
5782                 MonoContext new_ctx;
5783                 MonoLMF *lmf = NULL;
5784
5785                 /*
5786                  * We are stopped at a throw site. Stepping should go to the catch site.
5787                  */
5788
5789                 /* Find the the jit info for the catch context */
5790                 res = mono_find_jit_info_ext (
5791                         (MonoDomain *)tls->catch_state.unwind_data [MONO_UNWIND_DATA_DOMAIN],
5792                         (MonoJitTlsData *)((MonoThreadInfo*)thread->thread_info)->jit_data,
5793                         NULL, &tls->catch_state.ctx, &new_ctx, NULL, &lmf, NULL, &frame);
5794                 g_assert (res);
5795                 g_assert (frame.type == FRAME_TYPE_MANAGED);
5796
5797                 /*
5798                  * Find the seq point corresponding to the landing site ip, which is the first seq
5799                  * point after ip.
5800                  */
5801                 found_sp = mono_find_next_seq_point_for_native_offset (frame.domain, frame.method, frame.native_offset, &info, &local_sp);
5802                 sp = (found_sp)? &local_sp : NULL;
5803                 if (!sp)
5804                         no_seq_points_found (frame.method, frame.native_offset);
5805                 g_assert (sp);
5806
5807                 method = frame.method;
5808
5809                 step_to_catch = TRUE;
5810                 /* This make sure the seq point is not skipped by process_single_step () */
5811                 ss_req->last_sp = NULL;
5812         }
5813
5814         if (!step_to_catch) {
5815                 StackFrame *frame = NULL;
5816
5817                 if (set_ip) {
5818                         if (frames && nframes)
5819                                 frame = frames [0];
5820                 } else {
5821                         compute_frame_info (thread, tls);
5822
5823                         if (tls->frame_count)
5824                                 frame = tls->frames [0];
5825                 }
5826
5827                 if (ss_req->size == STEP_SIZE_LINE) {
5828                         if (frame) {
5829                                 ss_req->last_method = frame->method;
5830                                 ss_req->last_line = -1;
5831
5832                                 minfo = mono_debug_lookup_method (frame->method);
5833                                 if (minfo && frame->il_offset != -1) {
5834                                         MonoDebugSourceLocation *loc = mono_debug_method_lookup_location (minfo, frame->il_offset);
5835
5836                                         if (loc) {
5837                                                 ss_req->last_line = loc->row;
5838                                                 g_free (loc);
5839                                         }
5840                                 }
5841                         }
5842                 }
5843
5844                 if (frame) {
5845                         if (!method && frame->il_offset != -1) {
5846                                 /* FIXME: Sort the table and use a binary search */
5847                                 found_sp = mono_find_prev_seq_point_for_native_offset (frame->domain, frame->method, frame->native_offset, &info, &local_sp);
5848                                 sp = (found_sp)? &local_sp : NULL;
5849                                 if (!sp)
5850                                         no_seq_points_found (frame->method, frame->native_offset);
5851                                 g_assert (sp);
5852                                 method = frame->method;
5853                         }
5854                 }
5855         }
5856
5857         ss_req->start_method = method;
5858
5859         ss_start (ss_req, method, sp, info, set_ip ? &tls->restore_state.ctx : &tls->context.ctx, tls, step_to_catch, frames, nframes);
5860
5861         if (frames)
5862                 free_frames (frames, nframes);
5863
5864         return ERR_NONE;
5865 }
5866
5867 static void
5868 ss_destroy (SingleStepReq *req)
5869 {
5870         // FIXME: Locking
5871         g_assert (ss_req == req);
5872
5873         ss_stop (ss_req);
5874
5875         g_free (ss_req);
5876         ss_req = NULL;
5877 }
5878
5879 static void
5880 ss_clear_for_assembly (SingleStepReq *req, MonoAssembly *assembly)
5881 {
5882         GSList *l;
5883         gboolean found = TRUE;
5884
5885         while (found) {
5886                 found = FALSE;
5887                 for (l = ss_req->bps; l; l = l->next) {
5888                         if (breakpoint_matches_assembly ((MonoBreakpoint *)l->data, assembly)) {
5889                                 clear_breakpoint ((MonoBreakpoint *)l->data);
5890                                 ss_req->bps = g_slist_delete_link (ss_req->bps, l);
5891                                 found = TRUE;
5892                                 break;
5893                         }
5894                 }
5895         }
5896 }
5897
5898 /*
5899  * Called from metadata by the icall for System.Diagnostics.Debugger:Log ().
5900  */
5901 void
5902 mono_debugger_agent_debug_log (int level, MonoString *category, MonoString *message)
5903 {
5904         MonoError error;
5905         int suspend_policy;
5906         GSList *events;
5907         EventInfo ei;
5908
5909         if (!agent_config.enabled)
5910                 return;
5911
5912         mono_loader_lock ();
5913         events = create_event_list (EVENT_KIND_USER_LOG, NULL, NULL, NULL, &suspend_policy);
5914         mono_loader_unlock ();
5915
5916         ei.level = level;
5917         ei.category = NULL;
5918         if (category) {
5919                 ei.category = mono_string_to_utf8_checked (category, &error);
5920                 mono_error_cleanup (&error);
5921         }
5922         ei.message = NULL;
5923         if (message) {
5924                 ei.message = mono_string_to_utf8_checked (message, &error);
5925                 mono_error_cleanup  (&error);
5926         }
5927
5928         process_event (EVENT_KIND_USER_LOG, &ei, 0, NULL, events, suspend_policy);
5929
5930         g_free (ei.category);
5931         g_free (ei.message);
5932 }
5933
5934 gboolean
5935 mono_debugger_agent_debug_log_is_enabled (void)
5936 {
5937         /* Treat this as true even if there is no event request for EVENT_KIND_USER_LOG */
5938         return agent_config.enabled;
5939 }
5940
5941 #if defined(HOST_ANDROID) || defined(TARGET_ANDROID)
5942 void
5943 mono_debugger_agent_unhandled_exception (MonoException *exc)
5944 {
5945         int suspend_policy;
5946         GSList *events;
5947         EventInfo ei;
5948
5949         if (!inited)
5950                 return;
5951
5952         memset (&ei, 0, sizeof (EventInfo));
5953         ei.exc = (MonoObject*)exc;
5954
5955         mono_loader_lock ();
5956         events = create_event_list (EVENT_KIND_EXCEPTION, NULL, NULL, &ei, &suspend_policy);
5957         mono_loader_unlock ();
5958
5959         process_event (EVENT_KIND_EXCEPTION, &ei, 0, NULL, events, suspend_policy);
5960 }
5961 #endif
5962
5963 void
5964 mono_debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx,
5965                                       MonoContext *catch_ctx)
5966 {
5967         int i, j, suspend_policy;
5968         GSList *events;
5969         MonoJitInfo *ji, *catch_ji;
5970         EventInfo ei;
5971         DebuggerTlsData *tls = NULL;
5972
5973         if (thread_to_tls != NULL) {
5974                 MonoInternalThread *thread = mono_thread_internal_current ();
5975
5976                 mono_loader_lock ();
5977                 tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
5978                 mono_loader_unlock ();
5979
5980                 if (tls && tls->abort_requested)
5981                         return;
5982                 if (tls && tls->disable_breakpoints)
5983                         return;
5984         }
5985
5986         memset (&ei, 0, sizeof (EventInfo));
5987
5988         /* Just-In-Time debugging */
5989         if (!catch_ctx) {
5990                 if (agent_config.onuncaught && !inited) {
5991                         finish_agent_init (FALSE);
5992
5993                         /*
5994                          * Send an unsolicited EXCEPTION event with a dummy request id.
5995                          */
5996                         events = g_slist_append (NULL, GUINT_TO_POINTER (0xffffff));
5997                         ei.exc = (MonoObject*)exc;
5998                         process_event (EVENT_KIND_EXCEPTION, &ei, 0, throw_ctx, events, SUSPEND_POLICY_ALL);
5999                         return;
6000                 }
6001         } else if (agent_config.onthrow && !inited) {
6002                 GSList *l;
6003                 gboolean found = FALSE;
6004
6005                 for (l = agent_config.onthrow; l; l = l->next) {
6006                         char *ex_type = (char *)l->data;
6007                         char *f = mono_type_full_name (&exc->object.vtable->klass->byval_arg);
6008
6009                         if (!strcmp (ex_type, "") || !strcmp (ex_type, f))
6010                                 found = TRUE;
6011
6012                         g_free (f);
6013                 }
6014
6015                 if (found) {
6016                         finish_agent_init (FALSE);
6017
6018                         /*
6019                          * Send an unsolicited EXCEPTION event with a dummy request id.
6020                          */
6021                         events = g_slist_append (NULL, GUINT_TO_POINTER (0xffffff));
6022                         ei.exc = (MonoObject*)exc;
6023                         process_event (EVENT_KIND_EXCEPTION, &ei, 0, throw_ctx, events, SUSPEND_POLICY_ALL);
6024                         return;
6025                 }
6026         }
6027
6028         if (!inited)
6029                 return;
6030
6031         ji = mini_jit_info_table_find (mono_domain_get (), (char *)MONO_CONTEXT_GET_IP (throw_ctx), NULL);
6032         if (catch_ctx)
6033                 catch_ji = mini_jit_info_table_find (mono_domain_get (), (char *)MONO_CONTEXT_GET_IP (catch_ctx), NULL);
6034         else
6035                 catch_ji = NULL;
6036
6037         ei.exc = (MonoObject*)exc;
6038         ei.caught = catch_ctx != NULL;
6039
6040         mono_loader_lock ();
6041
6042         /* Treat exceptions which are caught in non-user code as unhandled */
6043         for (i = 0; i < event_requests->len; ++i) {
6044                 EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
6045                 if (req->event_kind != EVENT_KIND_EXCEPTION)
6046                         continue;
6047
6048                 for (j = 0; j < req->nmodifiers; ++j) {
6049                         Modifier *mod = &req->modifiers [j];
6050
6051                         if (mod->kind == MOD_KIND_ASSEMBLY_ONLY && catch_ji) {
6052                                 int k;
6053                                 gboolean found = FALSE;
6054                                 MonoAssembly **assemblies = mod->data.assemblies;
6055
6056                                 if (assemblies) {
6057                                         for (k = 0; assemblies [k]; ++k)
6058                                                 if (assemblies [k] == jinfo_get_method (catch_ji)->klass->image->assembly)
6059                                                         found = TRUE;
6060                                 }
6061                                 if (!found)
6062                                         ei.caught = FALSE;
6063                         }
6064                 }
6065         }
6066
6067         events = create_event_list (EVENT_KIND_EXCEPTION, NULL, ji, &ei, &suspend_policy);
6068         mono_loader_unlock ();
6069
6070         if (tls && ei.caught && catch_ctx) {
6071                 memset (&tls->catch_state, 0, sizeof (tls->catch_state));
6072                 tls->catch_state.ctx = *catch_ctx;
6073                 tls->catch_state.unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
6074                 tls->catch_state.valid = TRUE;
6075         }
6076
6077         process_event (EVENT_KIND_EXCEPTION, &ei, 0, throw_ctx, events, suspend_policy);
6078
6079         if (tls)
6080                 tls->catch_state.valid = FALSE;
6081 }
6082
6083 void
6084 mono_debugger_agent_begin_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx)
6085 {
6086         DebuggerTlsData *tls;
6087
6088         if (!inited)
6089                 return;
6090
6091         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
6092         if (!tls)
6093                 return;
6094
6095         /*
6096          * We're about to invoke an exception filter during the first pass of exception handling.
6097          *
6098          * 'ctx' is the context that'll get passed to the filter ('call_filter (ctx, ei->data.filter)'),
6099          * 'orig_ctx' is the context where the exception has been thrown.
6100          *
6101          *
6102          * See mcs/class/Mono.Debugger.Soft/Tests/dtest-excfilter.il for an example.
6103          *
6104          * If we're stopped in Filter(), normal stack unwinding would first unwind to
6105          * the call site (line 37) and then continue to Main(), but it would never
6106          * include the throw site (line 32).
6107          *
6108          * Since exception filters are invoked during the first pass of exception handling,
6109          * the stack frames of the throw site are still intact, so we should include them
6110          * in a stack trace.
6111          *
6112          * We do this here by saving the context of the throw site in 'tls->filter_state'.
6113          *
6114          * Exception filters are used by MonoDroid, where we want to stop inside a call filter,
6115          * but report the location of the 'throw' to the user.
6116          *
6117          */
6118
6119         g_assert (mono_thread_state_init_from_monoctx (&tls->filter_state, orig_ctx));
6120 }
6121
6122 void
6123 mono_debugger_agent_end_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx)
6124 {
6125         DebuggerTlsData *tls;
6126
6127         if (!inited)
6128                 return;
6129
6130         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
6131         if (!tls)
6132                 return;
6133
6134         tls->filter_state.valid = FALSE;
6135 }
6136
6137 /*
6138  * buffer_add_value_full:
6139  *
6140  *   Add the encoding of the value at ADDR described by T to the buffer.
6141  * AS_VTYPE determines whenever to treat primitive types as primitive types or
6142  * vtypes.
6143  */
6144 static void
6145 buffer_add_value_full (Buffer *buf, MonoType *t, void *addr, MonoDomain *domain,
6146                                            gboolean as_vtype, GHashTable *parent_vtypes)
6147 {
6148         MonoObject *obj;
6149         gboolean boxed_vtype = FALSE;
6150
6151         if (t->byref) {
6152                 if (!(*(void**)addr)) {
6153                         /* This can happen with compiler generated locals */
6154                         //printf ("%s\n", mono_type_full_name (t));
6155                         buffer_add_byte (buf, VALUE_TYPE_ID_NULL);
6156                         return;
6157                 }
6158                 g_assert (*(void**)addr);
6159                 addr = *(void**)addr;
6160         }
6161
6162         if (as_vtype) {
6163                 switch (t->type) {
6164                 case MONO_TYPE_BOOLEAN:
6165                 case MONO_TYPE_I1:
6166                 case MONO_TYPE_U1:
6167                 case MONO_TYPE_CHAR:
6168                 case MONO_TYPE_I2:
6169                 case MONO_TYPE_U2:
6170                 case MONO_TYPE_I4:
6171                 case MONO_TYPE_U4:
6172                 case MONO_TYPE_R4:
6173                 case MONO_TYPE_I8:
6174                 case MONO_TYPE_U8:
6175                 case MONO_TYPE_R8:
6176                 case MONO_TYPE_I:
6177                 case MONO_TYPE_U:
6178                 case MONO_TYPE_PTR:
6179                         goto handle_vtype;
6180                         break;
6181                 default:
6182                         break;
6183                 }
6184         }
6185
6186         switch (t->type) {
6187         case MONO_TYPE_VOID:
6188                 buffer_add_byte (buf, t->type);
6189                 break;
6190         case MONO_TYPE_BOOLEAN:
6191         case MONO_TYPE_I1:
6192         case MONO_TYPE_U1:
6193                 buffer_add_byte (buf, t->type);
6194                 buffer_add_int (buf, *(gint8*)addr);
6195                 break;
6196         case MONO_TYPE_CHAR:
6197         case MONO_TYPE_I2:
6198         case MONO_TYPE_U2:
6199                 buffer_add_byte (buf, t->type);
6200                 buffer_add_int (buf, *(gint16*)addr);
6201                 break;
6202         case MONO_TYPE_I4:
6203         case MONO_TYPE_U4:
6204         case MONO_TYPE_R4:
6205                 buffer_add_byte (buf, t->type);
6206                 buffer_add_int (buf, *(gint32*)addr);
6207                 break;
6208         case MONO_TYPE_I8:
6209         case MONO_TYPE_U8:
6210         case MONO_TYPE_R8:
6211                 buffer_add_byte (buf, t->type);
6212                 buffer_add_long (buf, *(gint64*)addr);
6213                 break;
6214         case MONO_TYPE_I:
6215         case MONO_TYPE_U:
6216                 /* Treat it as a vtype */
6217                 goto handle_vtype;
6218         case MONO_TYPE_PTR: {
6219                 gssize val = *(gssize*)addr;
6220
6221                 buffer_add_byte (buf, t->type);
6222                 buffer_add_long (buf, val);
6223                 break;
6224         }
6225         handle_ref:
6226         case MONO_TYPE_STRING:
6227         case MONO_TYPE_SZARRAY:
6228         case MONO_TYPE_OBJECT:
6229         case MONO_TYPE_CLASS:
6230         case MONO_TYPE_ARRAY:
6231                 obj = *(MonoObject**)addr;
6232
6233                 if (!obj) {
6234                         buffer_add_byte (buf, VALUE_TYPE_ID_NULL);
6235                 } else {
6236                         if (obj->vtable->klass->valuetype) {
6237                                 t = &obj->vtable->klass->byval_arg;
6238                                 addr = mono_object_unbox (obj);
6239                                 boxed_vtype = TRUE;
6240                                 goto handle_vtype;
6241                         } else if (obj->vtable->klass->rank) {
6242                                 buffer_add_byte (buf, obj->vtable->klass->byval_arg.type);
6243                         } else if (obj->vtable->klass->byval_arg.type == MONO_TYPE_GENERICINST) {
6244                                 buffer_add_byte (buf, MONO_TYPE_CLASS);
6245                         } else {
6246                                 buffer_add_byte (buf, obj->vtable->klass->byval_arg.type);
6247                         }
6248                         buffer_add_objid (buf, obj);
6249                 }
6250                 break;
6251         handle_vtype:
6252         case MONO_TYPE_VALUETYPE:
6253         case MONO_TYPE_TYPEDBYREF: {
6254                 int nfields;
6255                 gpointer iter;
6256                 MonoClassField *f;
6257                 MonoClass *klass = mono_class_from_mono_type (t);
6258                 int vtype_index;
6259
6260                 if (boxed_vtype) {
6261                         /*
6262                          * Handle boxed vtypes recursively referencing themselves using fields.
6263                          */
6264                         if (!parent_vtypes)
6265                                 parent_vtypes = g_hash_table_new (NULL, NULL);
6266                         vtype_index = GPOINTER_TO_INT (g_hash_table_lookup (parent_vtypes, addr));
6267                         if (vtype_index) {
6268                                 if (CHECK_PROTOCOL_VERSION (2, 33)) {
6269                                         buffer_add_byte (buf, VALUE_TYPE_ID_PARENT_VTYPE);
6270                                         buffer_add_int (buf, vtype_index - 1);
6271                                 } else {
6272                                         /* The client can't handle PARENT_VTYPE */
6273                                         buffer_add_byte (buf, VALUE_TYPE_ID_NULL);
6274                                 }
6275                                 break;
6276                         } else {
6277                                 g_hash_table_insert (parent_vtypes, addr, GINT_TO_POINTER (g_hash_table_size (parent_vtypes) + 1));
6278                         }
6279                 }
6280
6281                 buffer_add_byte (buf, MONO_TYPE_VALUETYPE);
6282                 buffer_add_byte (buf, klass->enumtype);
6283                 buffer_add_typeid (buf, domain, klass);
6284
6285                 nfields = 0;
6286                 iter = NULL;
6287                 while ((f = mono_class_get_fields (klass, &iter))) {
6288                         if (f->type->attrs & FIELD_ATTRIBUTE_STATIC)
6289                                 continue;
6290                         if (mono_field_is_deleted (f))
6291                                 continue;
6292                         nfields ++;
6293                 }
6294                 buffer_add_int (buf, nfields);
6295
6296                 iter = NULL;
6297                 while ((f = mono_class_get_fields (klass, &iter))) {
6298                         if (f->type->attrs & FIELD_ATTRIBUTE_STATIC)
6299                                 continue;
6300                         if (mono_field_is_deleted (f))
6301                                 continue;
6302                         buffer_add_value_full (buf, f->type, (guint8*)addr + f->offset - sizeof (MonoObject), domain, FALSE, parent_vtypes);
6303                 }
6304
6305                 if (boxed_vtype) {
6306                         g_hash_table_remove (parent_vtypes, addr);
6307                         if (g_hash_table_size (parent_vtypes) == 0) {
6308                                 g_hash_table_destroy (parent_vtypes);
6309                                 parent_vtypes = NULL;
6310                         }
6311                 }
6312                 break;
6313         }
6314         case MONO_TYPE_GENERICINST:
6315                 if (mono_type_generic_inst_is_valuetype (t)) {
6316                         goto handle_vtype;
6317                 } else {
6318                         goto handle_ref;
6319                 }
6320                 break;
6321         default:
6322                 NOT_IMPLEMENTED;
6323         }
6324 }
6325
6326 static void
6327 buffer_add_value (Buffer *buf, MonoType *t, void *addr, MonoDomain *domain)
6328 {
6329         buffer_add_value_full (buf, t, addr, domain, FALSE, NULL);
6330 }
6331
6332 static gboolean
6333 obj_is_of_type (MonoObject *obj, MonoType *t)
6334 {
6335         MonoClass *klass = obj->vtable->klass;
6336         if (!mono_class_is_assignable_from (mono_class_from_mono_type (t), klass)) {
6337                 if (mono_class_is_transparent_proxy (klass)) {
6338                         klass = ((MonoTransparentProxy *)obj)->remote_class->proxy_class;
6339                         if (mono_class_is_assignable_from (mono_class_from_mono_type (t), klass)) {
6340                                 return TRUE;
6341                         }
6342                 }
6343                 return FALSE;
6344         }
6345         return TRUE;
6346 }
6347
6348 static ErrorCode
6349 decode_value (MonoType *t, MonoDomain *domain, guint8 *addr, guint8 *buf, guint8 **endbuf, guint8 *limit);
6350
6351 static ErrorCode
6352 decode_vtype (MonoType *t, MonoDomain *domain, guint8 *addr, guint8 *buf, guint8 **endbuf, guint8 *limit)
6353 {
6354         gboolean is_enum;
6355         MonoClass *klass;
6356         MonoClassField *f;
6357         int nfields;
6358         gpointer iter = NULL;
6359         MonoDomain *d;
6360         ErrorCode err;
6361
6362         is_enum = decode_byte (buf, &buf, limit);
6363         /* Enums are sent as a normal vtype */
6364         if (is_enum)
6365                 return ERR_NOT_IMPLEMENTED;
6366         klass = decode_typeid (buf, &buf, limit, &d, &err);
6367         if (err != ERR_NONE)
6368                 return err;
6369
6370         if (t && klass != mono_class_from_mono_type (t)) {
6371                 char *name = mono_type_full_name (t);
6372                 char *name2 = mono_type_full_name (&klass->byval_arg);
6373                 DEBUG_PRINTF (1, "[%p] Expected value of type %s, got %s.\n", (gpointer) (gsize) mono_native_thread_id_get (), name, name2);
6374                 g_free (name);
6375                 g_free (name2);
6376                 return ERR_INVALID_ARGUMENT;
6377         }
6378
6379         nfields = decode_int (buf, &buf, limit);
6380         while ((f = mono_class_get_fields (klass, &iter))) {
6381                 if (f->type->attrs & FIELD_ATTRIBUTE_STATIC)
6382                         continue;
6383                 if (mono_field_is_deleted (f))
6384                         continue;
6385                 err = decode_value (f->type, domain, (guint8*)addr + f->offset - sizeof (MonoObject), buf, &buf, limit);
6386                 if (err != ERR_NONE)
6387                         return err;
6388                 nfields --;
6389         }
6390         g_assert (nfields == 0);
6391
6392         *endbuf = buf;
6393
6394         return ERR_NONE;
6395 }
6396
6397 static ErrorCode
6398 decode_value_internal (MonoType *t, int type, MonoDomain *domain, guint8 *addr, guint8 *buf, guint8 **endbuf, guint8 *limit)
6399 {
6400         ErrorCode err;
6401
6402         if (type != t->type && !MONO_TYPE_IS_REFERENCE (t) &&
6403                 !(t->type == MONO_TYPE_I && type == MONO_TYPE_VALUETYPE) &&
6404                 !(t->type == MONO_TYPE_U && type == MONO_TYPE_VALUETYPE) &&
6405                 !(t->type == MONO_TYPE_PTR && type == MONO_TYPE_I8) &&
6406                 !(t->type == MONO_TYPE_GENERICINST && type == MONO_TYPE_VALUETYPE) &&
6407                 !(t->type == MONO_TYPE_VALUETYPE && type == MONO_TYPE_OBJECT)) {
6408                 char *name = mono_type_full_name (t);
6409                 DEBUG_PRINTF (1, "[%p] Expected value of type %s, got 0x%0x.\n", (gpointer) (gsize) mono_native_thread_id_get (), name, type);
6410                 g_free (name);
6411                 return ERR_INVALID_ARGUMENT;
6412         }
6413
6414         switch (t->type) {
6415         case MONO_TYPE_BOOLEAN:
6416                 *(guint8*)addr = decode_int (buf, &buf, limit);
6417                 break;
6418         case MONO_TYPE_CHAR:
6419                 *(gunichar2*)addr = decode_int (buf, &buf, limit);
6420                 break;
6421         case MONO_TYPE_I1:
6422                 *(gint8*)addr = decode_int (buf, &buf, limit);
6423                 break;
6424         case MONO_TYPE_U1:
6425                 *(guint8*)addr = decode_int (buf, &buf, limit);
6426                 break;
6427         case MONO_TYPE_I2:
6428                 *(gint16*)addr = decode_int (buf, &buf, limit);
6429                 break;
6430         case MONO_TYPE_U2:
6431                 *(guint16*)addr = decode_int (buf, &buf, limit);
6432                 break;
6433         case MONO_TYPE_I4:
6434                 *(gint32*)addr = decode_int (buf, &buf, limit);
6435                 break;
6436         case MONO_TYPE_U4:
6437                 *(guint32*)addr = decode_int (buf, &buf, limit);
6438                 break;
6439         case MONO_TYPE_I8:
6440                 *(gint64*)addr = decode_long (buf, &buf, limit);
6441                 break;
6442         case MONO_TYPE_U8:
6443                 *(guint64*)addr = decode_long (buf, &buf, limit);
6444                 break;
6445         case MONO_TYPE_R4:
6446                 *(guint32*)addr = decode_int (buf, &buf, limit);
6447                 break;
6448         case MONO_TYPE_R8:
6449                 *(guint64*)addr = decode_long (buf, &buf, limit);
6450                 break;
6451         case MONO_TYPE_PTR:
6452                 /* We send these as I8, so we get them back as such */
6453                 g_assert (type == MONO_TYPE_I8);
6454                 *(gssize*)addr = decode_long (buf, &buf, limit);
6455                 break;
6456         case MONO_TYPE_GENERICINST:
6457                 if (MONO_TYPE_ISSTRUCT (t)) {
6458                         /* The client sends these as a valuetype */
6459                         goto handle_vtype;
6460                 } else {
6461                         goto handle_ref;
6462                 }
6463                 break;
6464         case MONO_TYPE_I:
6465         case MONO_TYPE_U:
6466                 /* We send these as vtypes, so we get them back as such */
6467                 g_assert (type == MONO_TYPE_VALUETYPE);
6468                 /* Fall through */
6469                 handle_vtype:
6470         case MONO_TYPE_VALUETYPE:
6471                 if (type == MONO_TYPE_OBJECT) {
6472                         /* Boxed vtype */
6473                         int objid = decode_objid (buf, &buf, limit);
6474                         ErrorCode err;
6475                         MonoObject *obj;
6476
6477                         err = get_object (objid, (MonoObject**)&obj);
6478                         if (err != ERR_NONE)
6479                                 return err;
6480                         if (!obj)
6481                                 return ERR_INVALID_ARGUMENT;
6482                         if (obj->vtable->klass != mono_class_from_mono_type (t)) {
6483                                 DEBUG_PRINTF (1, "Expected type '%s', got object '%s'\n", mono_type_full_name (t), obj->vtable->klass->name);
6484                                 return ERR_INVALID_ARGUMENT;
6485                         }
6486                         memcpy (addr, mono_object_unbox (obj), mono_class_value_size (obj->vtable->klass, NULL));
6487                 } else {
6488                         err = decode_vtype (t, domain, addr, buf, &buf, limit);
6489                         if (err != ERR_NONE)
6490                                 return err;
6491                 }
6492                 break;
6493         handle_ref:
6494         default:
6495                 if (MONO_TYPE_IS_REFERENCE (t)) {
6496                         if (type == MONO_TYPE_OBJECT) {
6497                                 int objid = decode_objid (buf, &buf, limit);
6498                                 ErrorCode err;
6499                                 MonoObject *obj;
6500
6501                                 err = get_object (objid, (MonoObject**)&obj);
6502                                 if (err != ERR_NONE)
6503                                         return err;
6504
6505                                 if (obj) {
6506                                         if (!obj_is_of_type (obj, t)) {
6507                                                 DEBUG_PRINTF (1, "Expected type '%s', got '%s'\n", mono_type_full_name (t), obj->vtable->klass->name);
6508                                                 return ERR_INVALID_ARGUMENT;
6509                                         }
6510                                 }
6511                                 if (obj && obj->vtable->domain != domain)
6512                                         return ERR_INVALID_ARGUMENT;
6513
6514                                 mono_gc_wbarrier_generic_store (addr, obj);
6515                         } else if (type == VALUE_TYPE_ID_NULL) {
6516                                 *(MonoObject**)addr = NULL;
6517                         } else if (type == MONO_TYPE_VALUETYPE) {
6518                                 MonoError error;
6519                                 guint8 *buf2;
6520                                 gboolean is_enum;
6521                                 MonoClass *klass;
6522                                 MonoDomain *d;
6523                                 guint8 *vtype_buf;
6524                                 int vtype_buf_size;
6525
6526                                 /* This can happen when round-tripping boxed vtypes */
6527                                 /*
6528                                  * Obtain vtype class.
6529                                  * Same as the beginning of the handle_vtype case above.
6530                                  */
6531                                 buf2 = buf;
6532                                 is_enum = decode_byte (buf, &buf, limit);
6533                                 if (is_enum)
6534                                         return ERR_NOT_IMPLEMENTED;
6535                                 klass = decode_typeid (buf, &buf, limit, &d, &err);
6536                                 if (err != ERR_NONE)
6537                                         return err;
6538
6539                                 /* Decode the vtype into a temporary buffer, then box it. */
6540                                 vtype_buf_size = mono_class_value_size (klass, NULL);
6541                                 vtype_buf = (guint8 *)g_malloc0 (vtype_buf_size);
6542                                 g_assert (vtype_buf);
6543
6544                                 buf = buf2;
6545                                 err = decode_vtype (NULL, domain, vtype_buf, buf, &buf, limit);
6546                                 if (err != ERR_NONE) {
6547                                         g_free (vtype_buf);
6548                                         return err;
6549                                 }
6550                                 *(MonoObject**)addr = mono_value_box_checked (d, klass, vtype_buf, &error);
6551                                 mono_error_cleanup (&error);
6552                                 g_free (vtype_buf);
6553                         } else {
6554                                 char *name = mono_type_full_name (t);
6555                                 DEBUG_PRINTF (1, "[%p] Expected value of type %s, got 0x%0x.\n", (gpointer) (gsize) mono_native_thread_id_get (), name, type);
6556                                 g_free (name);
6557                                 return ERR_INVALID_ARGUMENT;
6558                         }
6559                 } else {
6560                         NOT_IMPLEMENTED;
6561                 }
6562                 break;
6563         }
6564
6565         *endbuf = buf;
6566
6567         return ERR_NONE;
6568 }
6569
6570 static ErrorCode
6571 decode_value (MonoType *t, MonoDomain *domain, guint8 *addr, guint8 *buf, guint8 **endbuf, guint8 *limit)
6572 {
6573         MonoError error;
6574         ErrorCode err;
6575         int type = decode_byte (buf, &buf, limit);
6576
6577         if (t->type == MONO_TYPE_GENERICINST && mono_class_is_nullable (mono_class_from_mono_type (t))) {
6578                 MonoType *targ = t->data.generic_class->context.class_inst->type_argv [0];
6579                 guint8 *nullable_buf;
6580
6581                 /*
6582                  * First try decoding it as a Nullable`1
6583                  */
6584                 err = decode_value_internal (t, type, domain, addr, buf, endbuf, limit);
6585                 if (err == ERR_NONE)
6586                         return err;
6587
6588                 /*
6589                  * Then try decoding as a primitive value or null.
6590                  */
6591                 if (targ->type == type) {
6592                         nullable_buf = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (targ)));
6593                         err = decode_value_internal (targ, type, domain, nullable_buf, buf, endbuf, limit);
6594                         if (err != ERR_NONE) {
6595                                 g_free (nullable_buf);
6596                                 return err;
6597                         }
6598                         MonoObject *boxed = mono_value_box_checked (domain, mono_class_from_mono_type (targ), nullable_buf, &error);
6599                         if (!is_ok (&error)) {
6600                                 mono_error_cleanup (&error);
6601                                 return ERR_INVALID_OBJECT;
6602                         }
6603                         mono_nullable_init (addr, boxed, mono_class_from_mono_type (t));
6604                         g_free (nullable_buf);
6605                         *endbuf = buf;
6606                         return ERR_NONE;
6607                 } else if (type == VALUE_TYPE_ID_NULL) {
6608                         mono_nullable_init (addr, NULL, mono_class_from_mono_type (t));
6609                         *endbuf = buf;
6610                         return ERR_NONE;
6611                 }
6612         }
6613
6614         return decode_value_internal (t, type, domain, addr, buf, endbuf, limit);
6615 }
6616
6617 static void
6618 add_var (Buffer *buf, MonoDebugMethodJitInfo *jit, MonoType *t, MonoDebugVarInfo *var, MonoContext *ctx, MonoDomain *domain, gboolean as_vtype)
6619 {
6620         guint32 flags;
6621         int reg;
6622         guint8 *addr, *gaddr;
6623         mgreg_t reg_val;
6624
6625         flags = var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
6626         reg = var->index & ~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
6627
6628         switch (flags) {
6629         case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
6630                 reg_val = mono_arch_context_get_int_reg (ctx, reg);
6631
6632                 buffer_add_value_full (buf, t, &reg_val, domain, as_vtype, NULL);
6633                 break;
6634         case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
6635                 addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
6636                 addr += (gint32)var->offset;
6637
6638                 //printf ("[R%d+%d] = %p\n", reg, var->offset, addr);
6639
6640                 buffer_add_value_full (buf, t, addr, domain, as_vtype, NULL);
6641                 break;
6642         case MONO_DEBUG_VAR_ADDRESS_MODE_DEAD:
6643                 NOT_IMPLEMENTED;
6644                 break;
6645         case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR:
6646         case MONO_DEBUG_VAR_ADDRESS_MODE_VTADDR:
6647                 /* Same as regoffset, but with an indirection */
6648                 addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
6649                 addr += (gint32)var->offset;
6650
6651                 gaddr = (guint8 *)*(gpointer*)addr;
6652                 g_assert (gaddr);
6653                 buffer_add_value_full (buf, t, gaddr, domain, as_vtype, NULL);
6654                 break;
6655         case MONO_DEBUG_VAR_ADDRESS_MODE_GSHAREDVT_LOCAL: {
6656                 MonoDebugVarInfo *info_var = jit->gsharedvt_info_var;
6657                 MonoDebugVarInfo *locals_var = jit->gsharedvt_locals_var;
6658                 MonoGSharedVtMethodRuntimeInfo *info;
6659                 guint8 *locals;
6660                 int idx;
6661
6662                 idx = reg;
6663
6664                 g_assert (info_var);
6665                 g_assert (locals_var);
6666
6667                 flags = info_var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
6668                 reg = info_var->index & ~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
6669                 if (flags == MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET) {
6670                         addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
6671                         addr += (gint32)info_var->offset;
6672                         info = (MonoGSharedVtMethodRuntimeInfo *)*(gpointer*)addr;
6673                 } else if (flags == MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER) {
6674                         info = (MonoGSharedVtMethodRuntimeInfo *)mono_arch_context_get_int_reg (ctx, reg);
6675                 } else {
6676                         g_assert_not_reached ();
6677                 }
6678                 g_assert (info);
6679
6680                 flags = locals_var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
6681                 reg = locals_var->index & ~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
6682                 if (flags == MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET) {
6683                         addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
6684                         addr += (gint32)locals_var->offset;
6685                         locals = (guint8 *)*(gpointer*)addr;
6686                 } else if (flags == MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER) {
6687                         locals = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
6688                 } else {
6689                         g_assert_not_reached ();
6690                 }
6691                 g_assert (locals);
6692
6693                 addr = locals + GPOINTER_TO_INT (info->entries [idx]);
6694
6695                 buffer_add_value_full (buf, t, addr, domain, as_vtype, NULL);
6696                 break;
6697         }
6698
6699         default:
6700                 g_assert_not_reached ();
6701         }
6702 }
6703
6704 static void
6705 set_var (MonoType *t, MonoDebugVarInfo *var, MonoContext *ctx, MonoDomain *domain, guint8 *val, mgreg_t **reg_locations, MonoContext *restore_ctx)
6706 {
6707         guint32 flags;
6708         int reg, size;
6709         guint8 *addr, *gaddr;
6710
6711         flags = var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
6712         reg = var->index & ~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
6713
6714         if (MONO_TYPE_IS_REFERENCE (t))
6715                 size = sizeof (gpointer);
6716         else
6717                 size = mono_class_value_size (mono_class_from_mono_type (t), NULL);
6718
6719         switch (flags) {
6720         case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER: {
6721 #ifdef MONO_ARCH_HAVE_CONTEXT_SET_INT_REG
6722                 mgreg_t v;
6723                 gboolean is_signed = FALSE;
6724
6725                 if (t->byref) {
6726                         addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
6727
6728                         if (addr) {
6729                                 // FIXME: Write barriers
6730                                 mono_gc_memmove_atomic (addr, val, size);
6731                         }
6732                         break;
6733                 }
6734
6735                 if (!t->byref && (t->type == MONO_TYPE_I1 || t->type == MONO_TYPE_I2 || t->type == MONO_TYPE_I4 || t->type == MONO_TYPE_I8))
6736                         is_signed = TRUE;
6737
6738                 switch (size) {
6739                 case 1:
6740                         v = is_signed ? *(gint8*)val : *(guint8*)val;
6741                         break;
6742                 case 2:
6743                         v = is_signed ? *(gint16*)val : *(guint16*)val;
6744                         break;
6745                 case 4:
6746                         v = is_signed ? *(gint32*)val : *(guint32*)val;
6747                         break;
6748                 case 8:
6749                         v = is_signed ? *(gint64*)val : *(guint64*)val;
6750                         break;
6751                 default:
6752                         g_assert_not_reached ();
6753                 }
6754
6755                 /* Set value on the stack or in the return ctx */
6756                 if (reg_locations [reg]) {
6757                         /* Saved on the stack */
6758                         DEBUG_PRINTF (1, "[dbg] Setting stack location %p for reg %x to %p.\n", reg_locations [reg], reg, (gpointer)v);
6759                         *(reg_locations [reg]) = v;
6760                 } else {
6761                         /* Not saved yet */
6762                         DEBUG_PRINTF (1, "[dbg] Setting context location for reg %x to %p.\n", reg, (gpointer)v);
6763                         mono_arch_context_set_int_reg (restore_ctx, reg, v);
6764                 }
6765
6766                 // FIXME: Move these to mono-context.h/c.
6767                 mono_arch_context_set_int_reg (ctx, reg, v);
6768 #else
6769                 // FIXME: Can't set registers, so we disable linears
6770                 NOT_IMPLEMENTED;
6771 #endif
6772                 break;
6773         }
6774         case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
6775                 addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
6776                 addr += (gint32)var->offset;
6777
6778                 //printf ("[R%d+%d] = %p\n", reg, var->offset, addr);
6779
6780                 if (t->byref) {
6781                         addr = *(guint8**)addr;
6782
6783                         if (!addr)
6784                                 break;
6785                 }
6786
6787                 // FIXME: Write barriers
6788                 mono_gc_memmove_atomic (addr, val, size);
6789                 break;
6790         case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR:
6791                 /* Same as regoffset, but with an indirection */
6792                 addr = (guint8 *)mono_arch_context_get_int_reg (ctx, reg);
6793                 addr += (gint32)var->offset;
6794
6795                 gaddr = (guint8 *)*(gpointer*)addr;
6796                 g_assert (gaddr);
6797                 // FIXME: Write barriers
6798                 mono_gc_memmove_atomic (gaddr, val, size);
6799                 break;
6800         case MONO_DEBUG_VAR_ADDRESS_MODE_DEAD:
6801                 NOT_IMPLEMENTED;
6802                 break;
6803         default:
6804                 g_assert_not_reached ();
6805         }
6806 }
6807
6808 static void
6809 set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf)
6810 {
6811         int size;
6812
6813         if (t->byref) {
6814                 addr = *(gpointer*)addr;
6815                 g_assert (addr);
6816         }
6817
6818         if (MONO_TYPE_IS_REFERENCE (t))
6819                 size = sizeof (gpointer);
6820         else
6821                 size = mono_class_value_size (mono_class_from_mono_type (t), NULL);
6822
6823         memcpy (addr, val_buf, size);
6824 }
6825
6826 static void
6827 clear_event_request (int req_id, int etype)
6828 {
6829         int i;
6830
6831         mono_loader_lock ();
6832         for (i = 0; i < event_requests->len; ++i) {
6833                 EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
6834
6835                 if (req->id == req_id && req->event_kind == etype) {
6836                         if (req->event_kind == EVENT_KIND_BREAKPOINT)
6837                                 clear_breakpoint ((MonoBreakpoint *)req->info);
6838                         if (req->event_kind == EVENT_KIND_STEP)
6839                                 ss_destroy ((SingleStepReq *)req->info);
6840                         if (req->event_kind == EVENT_KIND_METHOD_ENTRY)
6841                                 clear_breakpoint ((MonoBreakpoint *)req->info);
6842                         if (req->event_kind == EVENT_KIND_METHOD_EXIT)
6843                                 clear_breakpoint ((MonoBreakpoint *)req->info);
6844                         g_ptr_array_remove_index_fast (event_requests, i);
6845                         g_free (req);
6846                         break;
6847                 }
6848         }
6849         mono_loader_unlock ();
6850 }
6851
6852 static void
6853 clear_assembly_from_modifier (EventRequest *req, Modifier *m, MonoAssembly *assembly)
6854 {
6855         int i;
6856
6857         if (m->kind == MOD_KIND_EXCEPTION_ONLY && m->data.exc_class && m->data.exc_class->image->assembly == assembly)
6858                 m->kind = MOD_KIND_NONE;
6859         if (m->kind == MOD_KIND_ASSEMBLY_ONLY && m->data.assemblies) {
6860                 int count = 0, match_count = 0, pos;
6861                 MonoAssembly **newassemblies;
6862
6863                 for (i = 0; m->data.assemblies [i]; ++i) {
6864                         count ++;
6865                         if (m->data.assemblies [i] == assembly)
6866                                 match_count ++;
6867                 }
6868
6869                 if (match_count) {
6870                         // +1 because we don't know length and we use last element to check for end
6871                         newassemblies = g_new0 (MonoAssembly*, count - match_count + 1);
6872
6873                         pos = 0;
6874                         for (i = 0; i < count; ++i)
6875                                 if (m->data.assemblies [i] != assembly)
6876                                         newassemblies [pos ++] = m->data.assemblies [i];
6877                         g_assert (pos == count - match_count);
6878                         g_free (m->data.assemblies);
6879                         m->data.assemblies = newassemblies;
6880                 }
6881         }
6882 }
6883
6884 static void
6885 clear_assembly_from_modifiers (EventRequest *req, MonoAssembly *assembly)
6886 {
6887         int i;
6888
6889         for (i = 0; i < req->nmodifiers; ++i) {
6890                 Modifier *m = &req->modifiers [i];
6891
6892                 clear_assembly_from_modifier (req, m, assembly);
6893         }
6894 }
6895
6896 /*
6897  * clear_event_requests_for_assembly:
6898  *
6899  *   Clear all events requests which reference ASSEMBLY.
6900  */
6901 static void
6902 clear_event_requests_for_assembly (MonoAssembly *assembly)
6903 {
6904         int i;
6905         gboolean found;
6906
6907         mono_loader_lock ();
6908         found = TRUE;
6909         while (found) {
6910                 found = FALSE;
6911                 for (i = 0; i < event_requests->len; ++i) {
6912                         EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
6913
6914                         clear_assembly_from_modifiers (req, assembly);
6915
6916                         if (req->event_kind == EVENT_KIND_BREAKPOINT && breakpoint_matches_assembly ((MonoBreakpoint *)req->info, assembly)) {
6917                                 clear_event_request (req->id, req->event_kind);
6918                                 found = TRUE;
6919                                 break;
6920                         }
6921
6922                         if (req->event_kind == EVENT_KIND_STEP)
6923                                 ss_clear_for_assembly ((SingleStepReq *)req->info, assembly);
6924                 }
6925         }
6926         mono_loader_unlock ();
6927 }
6928
6929 /*
6930  * type_comes_from_assembly:
6931  *
6932  *   GHRFunc that returns TRUE if klass comes from assembly
6933  */
6934 static gboolean
6935 type_comes_from_assembly (gpointer klass, gpointer also_klass, gpointer assembly)
6936 {
6937         return (mono_class_get_image ((MonoClass*)klass) == mono_assembly_get_image ((MonoAssembly*)assembly));
6938 }
6939
6940 /*
6941  * clear_types_for_assembly:
6942  *
6943  *   Clears types from loaded_classes for a given assembly
6944  */
6945 static void
6946 clear_types_for_assembly (MonoAssembly *assembly)
6947 {
6948         MonoDomain *domain = mono_domain_get ();
6949         AgentDomainInfo *info = NULL;
6950
6951         if (!domain || !domain_jit_info (domain))
6952                 /* Can happen during shutdown */
6953                 return;
6954
6955         info = get_agent_domain_info (domain);
6956
6957         mono_loader_lock ();
6958         g_hash_table_foreach_remove (info->loaded_classes, type_comes_from_assembly, assembly);
6959         mono_loader_unlock ();
6960 }
6961
6962 static void
6963 add_thread (gpointer key, gpointer value, gpointer user_data)
6964 {
6965         MonoInternalThread *thread = (MonoInternalThread *)value;
6966         Buffer *buf = (Buffer *)user_data;
6967
6968         buffer_add_objid (buf, (MonoObject*)thread);
6969 }
6970
6971 static ErrorCode
6972 do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 *p, guint8 **endp)
6973 {
6974         MonoError error;
6975         guint8 *end = invoke->endp;
6976         MonoMethod *m;
6977         int i, nargs;
6978         ErrorCode err;
6979         MonoMethodSignature *sig;
6980         guint8 **arg_buf;
6981         void **args;
6982         MonoObject *this_arg, *res, *exc = NULL;
6983         MonoDomain *domain;
6984         guint8 *this_buf;
6985 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
6986         MonoLMFExt ext;
6987 #endif
6988         MonoStopwatch watch;
6989
6990         if (invoke->method) {
6991                 /*
6992                  * Invoke this method directly, currently only Environment.Exit () is supported.
6993                  */
6994                 this_arg = NULL;
6995                 DEBUG_PRINTF (1, "[%p] Invoking method '%s' on receiver '%s'.\n", (gpointer) (gsize) mono_native_thread_id_get (), mono_method_full_name (invoke->method, TRUE), this_arg ? this_arg->vtable->klass->name : "<null>");
6996
6997                 mono_runtime_try_invoke (invoke->method, NULL, invoke->args, &exc, &error);
6998                 mono_error_assert_ok (&error);
6999
7000                 g_assert_not_reached ();
7001         }
7002
7003         m = decode_methodid (p, &p, end, &domain, &err);
7004         if (err != ERR_NONE)
7005                 return err;
7006         sig = mono_method_signature (m);
7007
7008         if (m->klass->valuetype)
7009                 this_buf = (guint8 *)g_alloca (mono_class_instance_size (m->klass));
7010         else
7011                 this_buf = (guint8 *)g_alloca (sizeof (MonoObject*));
7012         if (m->klass->valuetype && (m->flags & METHOD_ATTRIBUTE_STATIC)) {
7013                 /* Should be null */
7014                 int type = decode_byte (p, &p, end);
7015                 if (type != VALUE_TYPE_ID_NULL) {
7016                         DEBUG_PRINTF (1, "[%p] Error: Static vtype method invoked with this argument.\n", (gpointer) (gsize) mono_native_thread_id_get ());
7017                         return ERR_INVALID_ARGUMENT;
7018                 }
7019                 memset (this_buf, 0, mono_class_instance_size (m->klass));
7020         } else if (m->klass->valuetype && !strcmp (m->name, ".ctor")) {
7021                         /* Could be null */
7022                         guint8 *tmp_p;
7023
7024                         int type = decode_byte (p, &tmp_p, end);
7025                         if (type == VALUE_TYPE_ID_NULL) {
7026                                 memset (this_buf, 0, mono_class_instance_size (m->klass));
7027                                 p = tmp_p;
7028                         } else {
7029                                 err = decode_value (&m->klass->byval_arg, domain, this_buf, p, &p, end);
7030                                 if (err != ERR_NONE)
7031                                         return err;
7032                         }
7033         } else {
7034                 err = decode_value (&m->klass->byval_arg, domain, this_buf, p, &p, end);
7035                 if (err != ERR_NONE)
7036                         return err;
7037         }
7038
7039         if (!m->klass->valuetype)
7040                 this_arg = *(MonoObject**)this_buf;
7041         else
7042                 this_arg = NULL;
7043
7044         if (MONO_CLASS_IS_INTERFACE (m->klass)) {
7045                 if (!this_arg) {
7046                         DEBUG_PRINTF (1, "[%p] Error: Interface method invoked without this argument.\n", (gpointer) (gsize) mono_native_thread_id_get ());
7047                         return ERR_INVALID_ARGUMENT;
7048                 }
7049                 m = mono_object_get_virtual_method (this_arg, m);
7050                 /* Transform this to the format the rest of the code expects it to be */
7051                 if (m->klass->valuetype) {
7052                         this_buf = (guint8 *)g_alloca (mono_class_instance_size (m->klass));
7053                         memcpy (this_buf, mono_object_unbox (this_arg), mono_class_instance_size (m->klass));
7054                 }
7055         } else if ((m->flags & METHOD_ATTRIBUTE_VIRTUAL) && !m->klass->valuetype && invoke->flags & INVOKE_FLAG_VIRTUAL) {
7056                 if (!this_arg) {
7057                         DEBUG_PRINTF (1, "[%p] Error: invoke with INVOKE_FLAG_VIRTUAL flag set without this argument.\n", (gpointer) (gsize) mono_native_thread_id_get ());
7058                         return ERR_INVALID_ARGUMENT;
7059                 }
7060                 m = mono_object_get_virtual_method (this_arg, m);
7061                 if (m->klass->valuetype) {
7062                         this_buf = (guint8 *)g_alloca (mono_class_instance_size (m->klass));
7063                         memcpy (this_buf, mono_object_unbox (this_arg), mono_class_instance_size (m->klass));
7064                 }
7065         }
7066
7067         DEBUG_PRINTF (1, "[%p] Invoking method '%s' on receiver '%s'.\n", (gpointer) (gsize) mono_native_thread_id_get (), mono_method_full_name (m, TRUE), this_arg ? this_arg->vtable->klass->name : "<null>");
7068
7069         if (this_arg && this_arg->vtable->domain != domain)
7070                 NOT_IMPLEMENTED;
7071
7072         if (!m->klass->valuetype && !(m->flags & METHOD_ATTRIBUTE_STATIC) && !this_arg) {
7073                 if (!strcmp (m->name, ".ctor")) {
7074                         if (mono_class_is_abstract (m->klass))
7075                                 return ERR_INVALID_ARGUMENT;
7076                         else {
7077                                 MonoError error;
7078                                 this_arg = mono_object_new_checked (domain, m->klass, &error);
7079                                 mono_error_assert_ok (&error);
7080                         }
7081                 } else {
7082                         return ERR_INVALID_ARGUMENT;
7083                 }
7084         }
7085
7086         if (this_arg && !obj_is_of_type (this_arg, &m->klass->byval_arg))
7087                 return ERR_INVALID_ARGUMENT;
7088
7089         nargs = decode_int (p, &p, end);
7090         if (nargs != sig->param_count)
7091                 return ERR_INVALID_ARGUMENT;
7092         /* Use alloca to get gc tracking */
7093         arg_buf = (guint8 **)g_alloca (nargs * sizeof (gpointer));
7094         memset (arg_buf, 0, nargs * sizeof (gpointer));
7095         args = (gpointer *)g_alloca (nargs * sizeof (gpointer));
7096         for (i = 0; i < nargs; ++i) {
7097                 if (MONO_TYPE_IS_REFERENCE (sig->params [i])) {
7098                         err = decode_value (sig->params [i], domain, (guint8*)&args [i], p, &p, end);
7099                         if (err != ERR_NONE)
7100                                 break;
7101                         if (args [i] && ((MonoObject*)args [i])->vtable->domain != domain)
7102                                 NOT_IMPLEMENTED;
7103
7104                         if (sig->params [i]->byref) {
7105                                 arg_buf [i] = (guint8 *)g_alloca (sizeof (mgreg_t));
7106                                 *(gpointer*)arg_buf [i] = args [i];
7107                                 args [i] = arg_buf [i];
7108                         }
7109                 } else {
7110                         MonoClass *arg_class = mono_class_from_mono_type (sig->params [i]);
7111                         arg_buf [i] = (guint8 *)g_alloca (mono_class_instance_size (arg_class));
7112                         err = decode_value (sig->params [i], domain, arg_buf [i], p, &p, end);
7113                         if (err != ERR_NONE)
7114                                 break;
7115                         if (mono_class_is_nullable (arg_class)) {
7116                                 args [i] = mono_nullable_box (arg_buf [i], arg_class, &error);
7117                                 mono_error_assert_ok (&error);
7118                         } else {
7119                                 args [i] = arg_buf [i];
7120                         }
7121                 }
7122         }
7123
7124         if (i < nargs)
7125                 return err;
7126
7127         if (invoke->flags & INVOKE_FLAG_DISABLE_BREAKPOINTS)
7128                 tls->disable_breakpoints = TRUE;
7129         else
7130                 tls->disable_breakpoints = FALSE;
7131
7132         /*
7133          * Add an LMF frame to link the stack frames on the invoke method with our caller.
7134          */
7135 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
7136         if (invoke->has_ctx) {
7137                 MonoLMF **lmf_addr;
7138
7139                 lmf_addr = mono_get_lmf_addr ();
7140
7141                 /* Setup our lmf */
7142                 memset (&ext, 0, sizeof (ext));
7143                 mono_arch_init_lmf_ext (&ext, *lmf_addr);
7144
7145                 ext.debugger_invoke = TRUE;
7146                 memcpy (&ext.ctx, &invoke->ctx, sizeof (MonoContext));
7147
7148                 mono_set_lmf ((MonoLMF*)&ext);
7149         }
7150 #endif
7151
7152         mono_stopwatch_start (&watch);
7153         res = mono_runtime_try_invoke (m, m->klass->valuetype ? (gpointer) this_buf : (gpointer) this_arg, args, &exc, &error);
7154         if (!mono_error_ok (&error) && exc == NULL) {
7155                 exc = (MonoObject*) mono_error_convert_to_exception (&error);
7156         } else {
7157                 mono_error_cleanup (&error); /* FIXME report error */
7158         }
7159         mono_stopwatch_stop (&watch);
7160         DEBUG_PRINTF (1, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", (gpointer) (gsize) mono_native_thread_id_get (), res, exc ? exc->vtable->klass->name : NULL, (long)mono_stopwatch_elapsed_ms (&watch));
7161         if (exc) {
7162                 buffer_add_byte (buf, 0);
7163                 buffer_add_value (buf, &mono_defaults.object_class->byval_arg, &exc, domain);
7164         } else {
7165                 gboolean out_this = FALSE;
7166                 gboolean out_args = FALSE;
7167
7168                 if ((invoke->flags & INVOKE_FLAG_RETURN_OUT_THIS) && CHECK_PROTOCOL_VERSION (2, 35))
7169                         out_this = TRUE;
7170                 if ((invoke->flags & INVOKE_FLAG_RETURN_OUT_ARGS) && CHECK_PROTOCOL_VERSION (2, 35))
7171                         out_args = TRUE;
7172                 buffer_add_byte (buf, 1 + (out_this ? 2 : 0) + (out_args ? 4 : 0));
7173                 if (m->string_ctor) {
7174                         buffer_add_value (buf, &mono_get_string_class ()->byval_arg, &res, domain);
7175                 } else if (sig->ret->type == MONO_TYPE_VOID && !m->string_ctor) {
7176                         if (!strcmp (m->name, ".ctor")) {
7177                                 if (!m->klass->valuetype)
7178                                         buffer_add_value (buf, &mono_defaults.object_class->byval_arg, &this_arg, domain);
7179                                 else
7180                                         buffer_add_value (buf, &m->klass->byval_arg, this_buf, domain);
7181                         } else {
7182                                 buffer_add_value (buf, &mono_defaults.void_class->byval_arg, NULL, domain);
7183                         }
7184                 } else if (MONO_TYPE_IS_REFERENCE (sig->ret)) {
7185                         buffer_add_value (buf, sig->ret, &res, domain);
7186                 } else if (mono_class_from_mono_type (sig->ret)->valuetype || sig->ret->type == MONO_TYPE_PTR || sig->ret->type == MONO_TYPE_FNPTR) {
7187                         if (mono_class_is_nullable (mono_class_from_mono_type (sig->ret))) {
7188                                 MonoClass *k = mono_class_from_mono_type (sig->ret);
7189                                 guint8 *nullable_buf = (guint8 *)g_alloca (mono_class_value_size (k, NULL));
7190
7191                                 g_assert (nullable_buf);
7192                                 mono_nullable_init (nullable_buf, res, k);
7193                                 buffer_add_value (buf, sig->ret, nullable_buf, domain);
7194                         } else {
7195                                 g_assert (res);
7196                                 buffer_add_value (buf, sig->ret, mono_object_unbox (res), domain);
7197                         }
7198                 } else {
7199                         NOT_IMPLEMENTED;
7200                 }
7201                 if (out_this)
7202                         /* Return the new value of the receiver after the call */
7203                         buffer_add_value (buf, &m->klass->byval_arg, this_buf, domain);
7204                 if (out_args) {
7205                         buffer_add_int (buf, nargs);
7206                         for (i = 0; i < nargs; ++i) {
7207                                 if (MONO_TYPE_IS_REFERENCE (sig->params [i]))
7208                                         buffer_add_value (buf, sig->params [i], &args [i], domain);
7209                                 else if (sig->params [i]->byref)
7210                                         /* add_value () does an indirection */
7211                                         buffer_add_value (buf, sig->params [i], &arg_buf [i], domain);
7212                                 else
7213                                         buffer_add_value (buf, sig->params [i], arg_buf [i], domain);
7214                         }
7215                 }
7216         }
7217
7218         tls->disable_breakpoints = FALSE;
7219
7220 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
7221         if (invoke->has_ctx)
7222                 mono_set_lmf ((MonoLMF *)(((gssize)ext.lmf.previous_lmf) & ~3));
7223 #endif
7224
7225         *endp = p;
7226         // FIXME: byref arguments
7227         // FIXME: varargs
7228         return ERR_NONE;
7229 }
7230
7231 /*
7232  * invoke_method:
7233  *
7234  *   Invoke the method given by tls->pending_invoke in the current thread.
7235  */
7236 static void
7237 invoke_method (void)
7238 {
7239         DebuggerTlsData *tls;
7240         InvokeData *invoke;
7241         int id;
7242         int i, mindex;
7243         ErrorCode err;
7244         Buffer buf;
7245         MonoContext restore_ctx;
7246         guint8 *p;
7247
7248         tls = (DebuggerTlsData *)mono_native_tls_get_value (debugger_tls_id);
7249         g_assert (tls);
7250
7251         /*
7252          * Store the `InvokeData *' in `tls->invoke' until we're done with
7253          * the invocation, so CMD_VM_ABORT_INVOKE can check it.
7254          */
7255
7256         mono_loader_lock ();
7257
7258         invoke = tls->pending_invoke;
7259         g_assert (invoke);
7260         tls->pending_invoke = NULL;
7261
7262         invoke->last_invoke = tls->invoke;
7263         tls->invoke = invoke;
7264
7265         mono_loader_unlock ();
7266
7267         tls->frames_up_to_date = FALSE;
7268
7269         id = invoke->id;
7270
7271         p = invoke->p;
7272         err = ERR_NONE;
7273         for (mindex = 0; mindex < invoke->nmethods; ++mindex) {
7274                 buffer_init (&buf, 128);
7275
7276                 if (err) {
7277                         /* Fail the other invokes as well */
7278                 } else {
7279                         err = do_invoke_method (tls, &buf, invoke, p, &p);
7280                 }
7281
7282                 if (tls->abort_requested) {
7283                         if (CHECK_PROTOCOL_VERSION (2, 42))
7284                                 err = ERR_INVOKE_ABORTED;
7285                 }
7286
7287                 /* Start suspending before sending the reply */
7288                 if (mindex == invoke->nmethods - 1) {
7289                         if (!(invoke->flags & INVOKE_FLAG_SINGLE_THREADED)) {
7290                                 for (i = 0; i < invoke->suspend_count; ++i)
7291                                         suspend_vm ();
7292                         }
7293                 }
7294
7295                 send_reply_packet (id, err, &buf);
7296
7297                 buffer_free (&buf);
7298         }
7299
7300         memcpy (&restore_ctx, &invoke->ctx, sizeof (MonoContext));
7301
7302         if (invoke->has_ctx)
7303                 save_thread_context (&restore_ctx);
7304
7305         if (invoke->flags & INVOKE_FLAG_SINGLE_THREADED) {
7306                 g_assert (tls->resume_count);
7307                 tls->resume_count -= invoke->suspend_count;
7308         }
7309
7310         DEBUG_PRINTF (1, "[%p] Invoke finished (%d), resume_count = %d.\n", (gpointer) (gsize) mono_native_thread_id_get (), err, tls->resume_count);
7311
7312         /*
7313          * Take the loader lock to avoid race conditions with CMD_VM_ABORT_INVOKE:
7314          *
7315          * It is possible that mono_thread_internal_abort () was called
7316          * after the mono_runtime_invoke_checked() already returned, but it doesn't matter
7317          * because we reset the abort here.
7318          */
7319
7320         mono_loader_lock ();
7321
7322         if (tls->abort_requested)
7323                 mono_thread_internal_reset_abort (tls->thread);
7324
7325         tls->invoke = tls->invoke->last_invoke;
7326         tls->abort_requested = FALSE;
7327
7328         mono_loader_unlock ();
7329
7330         g_free (invoke->p);
7331         g_free (invoke);
7332
7333         suspend_current ();
7334 }
7335
7336 static gboolean
7337 is_really_suspended (gpointer key, gpointer value, gpointer user_data)
7338 {
7339         MonoThread *thread = (MonoThread *)value;
7340         DebuggerTlsData *tls;
7341         gboolean res;
7342
7343         mono_loader_lock ();
7344         tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
7345         g_assert (tls);
7346         res = tls->really_suspended;
7347         mono_loader_unlock ();
7348
7349         return res;
7350 }
7351
7352 static GPtrArray*
7353 get_source_files_for_type (MonoClass *klass)
7354 {
7355         gpointer iter = NULL;
7356         MonoMethod *method;
7357         MonoDebugSourceInfo *sinfo;
7358         GPtrArray *files;
7359         int i, j;
7360
7361         files = g_ptr_array_new ();
7362
7363         while ((method = mono_class_get_methods (klass, &iter))) {
7364                 MonoDebugMethodInfo *minfo = mono_debug_lookup_method (method);
7365                 GPtrArray *source_file_list;
7366
7367                 if (minfo) {
7368                         mono_debug_get_seq_points (minfo, NULL, &source_file_list, NULL, NULL, NULL);
7369                         for (j = 0; j < source_file_list->len; ++j) {
7370                                 sinfo = (MonoDebugSourceInfo *)g_ptr_array_index (source_file_list, j);
7371                                 for (i = 0; i < files->len; ++i)
7372                                         if (!strcmp (g_ptr_array_index (files, i), sinfo->source_file))
7373                                                 break;
7374                                 if (i == files->len)
7375                                         g_ptr_array_add (files, g_strdup (sinfo->source_file));
7376                         }
7377                         g_ptr_array_free (source_file_list, TRUE);
7378                 }
7379         }
7380
7381         return files;
7382 }
7383
7384 static ErrorCode
7385 vm_commands (int command, int id, guint8 *p, guint8 *end, Buffer *buf)
7386 {
7387         switch (command) {
7388         case CMD_VM_VERSION: {
7389                 char *build_info, *version;
7390
7391                 build_info = mono_get_runtime_build_info ();
7392                 version = g_strdup_printf ("mono %s", build_info);
7393
7394                 buffer_add_string (buf, version); /* vm version */
7395                 buffer_add_int (buf, MAJOR_VERSION);
7396                 buffer_add_int (buf, MINOR_VERSION);
7397                 g_free (build_info);
7398                 g_free (version);
7399                 break;
7400         }
7401         case CMD_VM_SET_PROTOCOL_VERSION: {
7402                 major_version = decode_int (p, &p, end);
7403                 minor_version = decode_int (p, &p, end);
7404                 protocol_version_set = TRUE;
7405                 DEBUG_PRINTF (1, "[dbg] Protocol version %d.%d, client protocol version %d.%d.\n", MAJOR_VERSION, MINOR_VERSION, major_version, minor_version);
7406                 break;
7407         }
7408         case CMD_VM_ALL_THREADS: {
7409                 // FIXME: Domains
7410                 mono_loader_lock ();
7411                 buffer_add_int (buf, mono_g_hash_table_size (tid_to_thread_obj));
7412                 mono_g_hash_table_foreach (tid_to_thread_obj, add_thread, buf);
7413                 mono_loader_unlock ();
7414                 break;
7415         }
7416         case CMD_VM_SUSPEND:
7417                 suspend_vm ();
7418                 wait_for_suspend ();
7419                 break;
7420         case CMD_VM_RESUME:
7421                 if (suspend_count == 0)
7422                         return ERR_NOT_SUSPENDED;
7423                 resume_vm ();
7424                 clear_suspended_objs ();
7425                 break;
7426         case CMD_VM_DISPOSE:
7427                 /* Clear all event requests */
7428                 mono_loader_lock ();
7429                 while (event_requests->len > 0) {
7430                         EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, 0);
7431
7432                         clear_event_request (req->id, req->event_kind);
7433                 }
7434                 mono_loader_unlock ();
7435
7436                 while (suspend_count > 0)
7437                         resume_vm ();
7438                 disconnected = TRUE;
7439                 vm_start_event_sent = FALSE;
7440                 break;
7441         case CMD_VM_EXIT: {
7442                 MonoInternalThread *thread;
7443                 DebuggerTlsData *tls;
7444 #ifdef TRY_MANAGED_SYSTEM_ENVIRONMENT_EXIT
7445                 MonoClass *env_class;
7446 #endif
7447                 MonoMethod *exit_method = NULL;
7448                 gpointer *args;
7449                 int exit_code;
7450
7451                 exit_code = decode_int (p, &p, end);
7452
7453                 // FIXME: What if there is a VM_DEATH event request with SUSPEND_ALL ?
7454
7455                 /* Have to send a reply before exiting */
7456                 send_reply_packet (id, 0, buf);
7457
7458                 /* Clear all event requests */
7459                 mono_loader_lock ();
7460                 while (event_requests->len > 0) {
7461                         EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, 0);
7462
7463                         clear_event_request (req->id, req->event_kind);
7464                 }
7465                 mono_loader_unlock ();
7466
7467                 /*
7468                  * The JDWP documentation says that the shutdown is not orderly. It doesn't
7469                  * specify whenever a VM_DEATH event is sent. We currently do an orderly
7470                  * shutdown by hijacking a thread to execute Environment.Exit (). This is
7471                  * better than doing the shutdown ourselves, since it avoids various races.
7472                  */
7473
7474                 suspend_vm ();
7475                 wait_for_suspend ();
7476
7477 #ifdef TRY_MANAGED_SYSTEM_ENVIRONMENT_EXIT
7478                 env_class = mono_class_try_load_from_name (mono_defaults.corlib, "System", "Environment");
7479                 if (env_class)
7480                         exit_method = mono_class_get_method_from_name (env_class, "Exit", 1);
7481 #endif
7482
7483                 mono_loader_lock ();
7484                 thread = (MonoInternalThread *)mono_g_hash_table_find (tid_to_thread, is_really_suspended, NULL);
7485                 mono_loader_unlock ();
7486
7487                 if (thread && exit_method) {
7488                         mono_loader_lock ();
7489                         tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
7490                         mono_loader_unlock ();
7491
7492                         args = g_new0 (gpointer, 1);
7493                         args [0] = g_malloc (sizeof (int));
7494                         *(int*)(args [0]) = exit_code;
7495
7496                         tls->pending_invoke = g_new0 (InvokeData, 1);
7497                         tls->pending_invoke->method = exit_method;
7498                         tls->pending_invoke->args = args;
7499                         tls->pending_invoke->nmethods = 1;
7500
7501                         while (suspend_count > 0)
7502                                 resume_vm ();
7503                 } else {
7504                         /*
7505                          * No thread found, do it ourselves.
7506                          * FIXME: This can race with normal shutdown etc.
7507                          */
7508                         while (suspend_count > 0)
7509                                 resume_vm ();
7510
7511                         if (!mono_runtime_try_shutdown ())
7512                                 break;
7513
7514                         mono_environment_exitcode_set (exit_code);
7515
7516                         /* Suspend all managed threads since the runtime is going away */
7517                         DEBUG_PRINTF (1, "Suspending all threads...\n");
7518                         mono_thread_suspend_all_other_threads ();
7519                         DEBUG_PRINTF (1, "Shutting down the runtime...\n");
7520                         mono_runtime_quit ();
7521                         transport_close2 ();
7522                         DEBUG_PRINTF (1, "Exiting...\n");
7523
7524                         exit (exit_code);
7525                 }
7526                 break;
7527         }
7528         case CMD_VM_INVOKE_METHOD:
7529         case CMD_VM_INVOKE_METHODS: {
7530                 int objid = decode_objid (p, &p, end);
7531                 MonoThread *thread;
7532                 DebuggerTlsData *tls;
7533                 int i, count, flags, nmethods;
7534                 ErrorCode err;
7535
7536                 err = get_object (objid, (MonoObject**)&thread);
7537                 if (err != ERR_NONE)
7538                         return err;
7539
7540                 flags = decode_int (p, &p, end);
7541
7542                 if (command == CMD_VM_INVOKE_METHODS)
7543                         nmethods = decode_int (p, &p, end);
7544                 else
7545                         nmethods = 1;
7546
7547                 // Wait for suspending if it already started
7548                 if (suspend_count)
7549                         wait_for_suspend ();
7550                 if (!is_suspended ())
7551                         return ERR_NOT_SUSPENDED;
7552
7553                 mono_loader_lock ();
7554                 tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, THREAD_TO_INTERNAL (thread));
7555                 mono_loader_unlock ();
7556                 g_assert (tls);
7557
7558                 if (!tls->really_suspended)
7559                         /* The thread is still running native code, can't do invokes */
7560                         return ERR_NOT_SUSPENDED;
7561
7562                 /*
7563                  * Store the invoke data into tls, the thread will execute it after it is
7564                  * resumed.
7565                  */
7566                 if (tls->pending_invoke)
7567                         return ERR_NOT_SUSPENDED;
7568                 tls->pending_invoke = g_new0 (InvokeData, 1);
7569                 tls->pending_invoke->id = id;
7570                 tls->pending_invoke->flags = flags;
7571                 tls->pending_invoke->p = (guint8 *)g_malloc (end - p);
7572                 memcpy (tls->pending_invoke->p, p, end - p);
7573                 tls->pending_invoke->endp = tls->pending_invoke->p + (end - p);
7574                 tls->pending_invoke->suspend_count = suspend_count;
7575                 tls->pending_invoke->nmethods = nmethods;
7576
7577                 if (flags & INVOKE_FLAG_SINGLE_THREADED) {
7578                         resume_thread (THREAD_TO_INTERNAL (thread));
7579                 }
7580                 else {
7581                         count = suspend_count;
7582                         for (i = 0; i < count; ++i)
7583                                 resume_vm ();
7584                 }
7585                 break;
7586         }
7587         case CMD_VM_ABORT_INVOKE: {
7588                 int objid = decode_objid (p, &p, end);
7589                 MonoThread *thread;
7590                 DebuggerTlsData *tls;
7591                 int invoke_id;
7592                 ErrorCode err;
7593
7594                 err = get_object (objid, (MonoObject**)&thread);
7595                 if (err != ERR_NONE)
7596                         return err;
7597
7598                 invoke_id = decode_int (p, &p, end);
7599
7600                 mono_loader_lock ();
7601                 tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, THREAD_TO_INTERNAL (thread));
7602                 g_assert (tls);
7603
7604                 if (tls->abort_requested) {
7605                         DEBUG_PRINTF (1, "Abort already requested.\n");
7606                         mono_loader_unlock ();
7607                         break;
7608                 }
7609
7610                 /*
7611                  * Check whether we're still inside the mono_runtime_invoke_checked() and that it's
7612                  * actually the correct invocation.
7613                  *
7614                  * Careful, we do not stop the thread that's doing the invocation, so we can't
7615                  * inspect its stack.  However, invoke_method() also acquires the loader lock
7616                  * when it's done, so we're safe here.
7617                  *
7618                  */
7619
7620                 if (!tls->invoke || (tls->invoke->id != invoke_id)) {
7621                         mono_loader_unlock ();
7622                         return ERR_NO_INVOCATION;
7623                 }
7624
7625                 tls->abort_requested = TRUE;
7626
7627                 mono_thread_internal_abort (THREAD_TO_INTERNAL (thread));
7628                 mono_loader_unlock ();
7629                 break;
7630         }
7631
7632         case CMD_VM_SET_KEEPALIVE: {
7633                 int timeout = decode_int (p, &p, end);
7634                 agent_config.keepalive = timeout;
7635                 // FIXME:
7636 #ifndef DISABLE_SOCKET_TRANSPORT
7637                 set_keepalive ();
7638 #else
7639                 NOT_IMPLEMENTED;
7640 #endif
7641                 break;
7642         }
7643         case CMD_VM_GET_TYPES_FOR_SOURCE_FILE: {
7644                 GHashTableIter iter, kiter;
7645                 MonoDomain *domain;
7646                 MonoClass *klass;
7647                 GPtrArray *files;
7648                 int i;
7649                 char *fname, *basename;
7650                 gboolean ignore_case;
7651                 GSList *class_list, *l;
7652                 GPtrArray *res_classes, *res_domains;
7653
7654                 fname = decode_string (p, &p, end);
7655                 ignore_case = decode_byte (p, &p, end);
7656
7657                 basename = dbg_path_get_basename (fname);
7658
7659                 res_classes = g_ptr_array_new ();
7660                 res_domains = g_ptr_array_new ();
7661
7662                 mono_loader_lock ();
7663                 g_hash_table_iter_init (&iter, domains);
7664                 while (g_hash_table_iter_next (&iter, NULL, (void**)&domain)) {
7665                         AgentDomainInfo *info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info;
7666
7667                         /* Update 'source_file_to_class' cache */
7668                         g_hash_table_iter_init (&kiter, info->loaded_classes);
7669                         while (g_hash_table_iter_next (&kiter, NULL, (void**)&klass)) {
7670                                 if (!g_hash_table_lookup (info->source_files, klass)) {
7671                                         files = get_source_files_for_type (klass);
7672                                         g_hash_table_insert (info->source_files, klass, files);
7673
7674                                         for (i = 0; i < files->len; ++i) {
7675                                                 char *s = (char *)g_ptr_array_index (files, i);
7676                                                 char *s2 = dbg_path_get_basename (s);
7677                                                 char *s3;
7678
7679                                                 class_list = (GSList *)g_hash_table_lookup (info->source_file_to_class, s2);
7680                                                 if (!class_list) {
7681                                                         class_list = g_slist_prepend (class_list, klass);
7682                                                         g_hash_table_insert (info->source_file_to_class, g_strdup (s2), class_list);
7683                                                 } else {
7684                                                         class_list = g_slist_prepend (class_list, klass);
7685                                                         g_hash_table_insert (info->source_file_to_class, s2, class_list);
7686                                                 }
7687
7688                                                 /* The _ignorecase hash contains the lowercase path */
7689                                                 s3 = strdup_tolower (s2);
7690                                                 class_list = (GSList *)g_hash_table_lookup (info->source_file_to_class_ignorecase, s3);
7691                                                 if (!class_list) {
7692                                                         class_list = g_slist_prepend (class_list, klass);
7693                                                         g_hash_table_insert (info->source_file_to_class_ignorecase, g_strdup (s3), class_list);
7694                                                 } else {
7695                                                         class_list = g_slist_prepend (class_list, klass);
7696                                                         g_hash_table_insert (info->source_file_to_class_ignorecase, s3, class_list);
7697                                                 }
7698
7699                                                 g_free (s2);
7700                                                 g_free (s3);
7701                                         }
7702                                 }
7703                         }
7704
7705                         if (ignore_case) {
7706                                 char *s;
7707
7708                                 s = strdup_tolower (basename);
7709                                 class_list = (GSList *)g_hash_table_lookup (info->source_file_to_class_ignorecase, s);
7710                                 g_free (s);
7711                         } else {
7712                                 class_list = (GSList *)g_hash_table_lookup (info->source_file_to_class, basename);
7713                         }
7714
7715                         for (l = class_list; l; l = l->next) {
7716                                 klass = (MonoClass *)l->data;
7717
7718                                 g_ptr_array_add (res_classes, klass);
7719                                 g_ptr_array_add (res_domains, domain);
7720                         }
7721                 }
7722                 mono_loader_unlock ();
7723
7724                 g_free (fname);
7725                 g_free (basename);
7726
7727                 buffer_add_int (buf, res_classes->len);
7728                 for (i = 0; i < res_classes->len; ++i)
7729                         buffer_add_typeid (buf, (MonoDomain *)g_ptr_array_index (res_domains, i), (MonoClass *)g_ptr_array_index (res_classes, i));
7730                 g_ptr_array_free (res_classes, TRUE);
7731                 g_ptr_array_free (res_domains, TRUE);
7732                 break;
7733         }
7734         case CMD_VM_GET_TYPES: {
7735                 GHashTableIter iter;
7736                 MonoDomain *domain;
7737                 int i;
7738                 char *name;
7739                 gboolean ignore_case;
7740                 GPtrArray *res_classes, *res_domains;
7741                 MonoTypeNameParse info;
7742
7743                 name = decode_string (p, &p, end);
7744                 ignore_case = decode_byte (p, &p, end);
7745
7746                 if (!mono_reflection_parse_type (name, &info)) {
7747                         g_free (name);
7748                         mono_reflection_free_type_info (&info);
7749                         return ERR_INVALID_ARGUMENT;
7750                 }
7751
7752                 res_classes = g_ptr_array_new ();
7753                 res_domains = g_ptr_array_new ();
7754
7755                 mono_loader_lock ();
7756                 g_hash_table_iter_init (&iter, domains);
7757                 while (g_hash_table_iter_next (&iter, NULL, (void**)&domain)) {
7758                         MonoAssembly *ass;
7759                         gboolean type_resolve;
7760                         MonoType *t;
7761                         GSList *tmp;
7762
7763                         mono_domain_assemblies_lock (domain);
7764                         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
7765                                 ass = (MonoAssembly *)tmp->data;
7766
7767                                 if (ass->image) {
7768                                         MonoError error;
7769                                         type_resolve = TRUE;
7770                                         /* FIXME really okay to call while holding locks? */
7771                                         t = mono_reflection_get_type_checked (ass->image, ass->image, &info, ignore_case, &type_resolve, &error);
7772                                         mono_error_cleanup (&error);
7773                                         if (t) {
7774                                                 g_ptr_array_add (res_classes, mono_type_get_class (t));
7775                                                 g_ptr_array_add (res_domains, domain);
7776                                         }
7777                                 }
7778                         }
7779                         mono_domain_assemblies_unlock (domain);
7780                 }
7781                 mono_loader_unlock ();
7782
7783                 g_free (name);
7784                 mono_reflection_free_type_info (&info);
7785
7786                 buffer_add_int (buf, res_classes->len);
7787                 for (i = 0; i < res_classes->len; ++i)
7788                         buffer_add_typeid (buf, (MonoDomain *)g_ptr_array_index (res_domains, i), (MonoClass *)g_ptr_array_index (res_classes, i));
7789                 g_ptr_array_free (res_classes, TRUE);
7790                 g_ptr_array_free (res_domains, TRUE);
7791                 break;
7792         }
7793         case CMD_VM_START_BUFFERING:
7794         case CMD_VM_STOP_BUFFERING:
7795                 /* Handled in the main loop */
7796                 break;
7797         default:
7798                 return ERR_NOT_IMPLEMENTED;
7799         }
7800
7801         return ERR_NONE;
7802 }
7803
7804 static ErrorCode
7805 event_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
7806 {
7807         ErrorCode err;
7808         MonoError error;
7809
7810         switch (command) {
7811         case CMD_EVENT_REQUEST_SET: {
7812                 EventRequest *req;
7813                 int i, event_kind, suspend_policy, nmodifiers;
7814                 ModifierKind mod;
7815                 MonoMethod *method;
7816                 long location = 0;
7817                 MonoThread *step_thread;
7818                 int step_thread_id = 0;
7819                 StepDepth depth = STEP_DEPTH_INTO;
7820                 StepSize size = STEP_SIZE_MIN;
7821                 StepFilter filter = STEP_FILTER_NONE;
7822                 MonoDomain *domain;
7823                 Modifier *modifier;
7824
7825                 event_kind = decode_byte (p, &p, end);
7826                 suspend_policy = decode_byte (p, &p, end);
7827                 nmodifiers = decode_byte (p, &p, end);
7828
7829                 req = (EventRequest *)g_malloc0 (sizeof (EventRequest) + (nmodifiers * sizeof (Modifier)));
7830                 req->id = InterlockedIncrement (&event_request_id);
7831                 req->event_kind = event_kind;
7832                 req->suspend_policy = suspend_policy;
7833                 req->nmodifiers = nmodifiers;
7834
7835                 method = NULL;
7836                 for (i = 0; i < nmodifiers; ++i) {
7837                         mod = (ModifierKind)decode_byte (p, &p, end);
7838
7839                         req->modifiers [i].kind = mod;
7840                         if (mod == MOD_KIND_COUNT) {
7841                                 req->modifiers [i].data.count = decode_int (p, &p, end);
7842                         } else if (mod == MOD_KIND_LOCATION_ONLY) {
7843                                 method = decode_methodid (p, &p, end, &domain, &err);
7844                                 if (err != ERR_NONE)
7845                                         return err;
7846                                 location = decode_long (p, &p, end);
7847                         } else if (mod == MOD_KIND_STEP) {
7848                                 step_thread_id = decode_id (p, &p, end);
7849                                 size = (StepSize)decode_int (p, &p, end);
7850                                 depth = (StepDepth)decode_int (p, &p, end);
7851                                 if (CHECK_PROTOCOL_VERSION (2, 16))
7852                                         filter = (StepFilter)decode_int (p, &p, end);
7853                                 req->modifiers [i].data.filter = filter;
7854                                 if (!CHECK_PROTOCOL_VERSION (2, 26) && (req->modifiers [i].data.filter & STEP_FILTER_DEBUGGER_HIDDEN))
7855                                         /* Treat STEP_THOUGH the same as HIDDEN */
7856                                         req->modifiers [i].data.filter = (StepFilter)(req->modifiers [i].data.filter | STEP_FILTER_DEBUGGER_STEP_THROUGH);
7857                         } else if (mod == MOD_KIND_THREAD_ONLY) {
7858                                 int id = decode_id (p, &p, end);
7859
7860                                 err = get_object (id, (MonoObject**)&req->modifiers [i].data.thread);
7861                                 if (err != ERR_NONE) {
7862                                         g_free (req);
7863                                         return err;
7864                                 }
7865                         } else if (mod == MOD_KIND_EXCEPTION_ONLY) {
7866                                 MonoClass *exc_class = decode_typeid (p, &p, end, &domain, &err);
7867
7868                                 if (err != ERR_NONE)
7869                                         return err;
7870                                 req->modifiers [i].caught = decode_byte (p, &p, end);
7871                                 req->modifiers [i].uncaught = decode_byte (p, &p, end);
7872                                 if (CHECK_PROTOCOL_VERSION (2, 25))
7873                                         req->modifiers [i].subclasses = decode_byte (p, &p, end);
7874                                 else
7875                                         req->modifiers [i].subclasses = TRUE;
7876                                 DEBUG_PRINTF (1, "[dbg] \tEXCEPTION_ONLY filter (%s%s%s%s).\n", exc_class ? exc_class->name : "all", req->modifiers [i].caught ? ", caught" : "", req->modifiers [i].uncaught ? ", uncaught" : "", req->modifiers [i].subclasses ? ", include-subclasses" : "");
7877                                 if (exc_class) {
7878                                         req->modifiers [i].data.exc_class = exc_class;
7879
7880                                         if (!mono_class_is_assignable_from (mono_defaults.exception_class, exc_class)) {
7881                                                 g_free (req);
7882                                                 return ERR_INVALID_ARGUMENT;
7883                                         }
7884                                 }
7885                         } else if (mod == MOD_KIND_ASSEMBLY_ONLY) {
7886                                 int n = decode_int (p, &p, end);
7887                                 int j;
7888
7889                                 // +1 because we don't know length and we use last element to check for end
7890                                 req->modifiers [i].data.assemblies = g_new0 (MonoAssembly*, n + 1);
7891                                 for (j = 0; j < n; ++j) {
7892                                         req->modifiers [i].data.assemblies [j] = decode_assemblyid (p, &p, end, &domain, &err);
7893                                         if (err != ERR_NONE) {
7894                                                 g_free (req->modifiers [i].data.assemblies);
7895                                                 return err;
7896                                         }
7897                                 }
7898                         } else if (mod == MOD_KIND_SOURCE_FILE_ONLY) {
7899                                 int n = decode_int (p, &p, end);
7900                                 int j;
7901
7902                                 modifier = &req->modifiers [i];
7903                                 modifier->data.source_files = g_hash_table_new (g_str_hash, g_str_equal);
7904                                 for (j = 0; j < n; ++j) {
7905                                         char *s = decode_string (p, &p, end);
7906                                         char *s2;
7907
7908                                         if (s) {
7909                                                 s2 = strdup_tolower (s);
7910                                                 g_hash_table_insert (modifier->data.source_files, s2, s2);
7911                                                 g_free (s);
7912                                         }
7913                                 }
7914                         } else if (mod == MOD_KIND_TYPE_NAME_ONLY) {
7915                                 int n = decode_int (p, &p, end);
7916                                 int j;
7917
7918                                 modifier = &req->modifiers [i];
7919                                 modifier->data.type_names = g_hash_table_new (g_str_hash, g_str_equal);
7920                                 for (j = 0; j < n; ++j) {
7921                                         char *s = decode_string (p, &p, end);
7922
7923                                         if (s)
7924                                                 g_hash_table_insert (modifier->data.type_names, s, s);
7925                                 }
7926                         } else {
7927                                 g_free (req);
7928                                 return ERR_NOT_IMPLEMENTED;
7929                         }
7930                 }
7931
7932                 if (req->event_kind == EVENT_KIND_BREAKPOINT) {
7933                         g_assert (method);
7934
7935                         req->info = set_breakpoint (method, location, req, &error);
7936                         if (!mono_error_ok (&error)) {
7937                                 g_free (req);
7938                                 DEBUG_PRINTF (1, "[dbg] Failed to set breakpoint: %s\n", mono_error_get_message (&error));
7939                                 mono_error_cleanup (&error);
7940                                 return ERR_NO_SEQ_POINT_AT_IL_OFFSET;
7941                         }
7942                 } else if (req->event_kind == EVENT_KIND_STEP) {
7943                         g_assert (step_thread_id);
7944
7945                         err = get_object (step_thread_id, (MonoObject**)&step_thread);
7946                         if (err != ERR_NONE) {
7947                                 g_free (req);
7948                                 return err;
7949                         }
7950
7951                         err = ss_create (THREAD_TO_INTERNAL (step_thread), size, depth, filter, req);
7952                         if (err != ERR_NONE) {
7953                                 g_free (req);
7954                                 return err;
7955                         }
7956                 } else if (req->event_kind == EVENT_KIND_METHOD_ENTRY) {
7957                         req->info = set_breakpoint (NULL, METHOD_ENTRY_IL_OFFSET, req, NULL);
7958                 } else if (req->event_kind == EVENT_KIND_METHOD_EXIT) {
7959                         req->info = set_breakpoint (NULL, METHOD_EXIT_IL_OFFSET, req, NULL);
7960                 } else if (req->event_kind == EVENT_KIND_EXCEPTION) {
7961                 } else if (req->event_kind == EVENT_KIND_TYPE_LOAD) {
7962                 } else {
7963                         if (req->nmodifiers) {
7964                                 g_free (req);
7965                                 return ERR_NOT_IMPLEMENTED;
7966                         }
7967                 }
7968
7969                 mono_loader_lock ();
7970                 g_ptr_array_add (event_requests, req);
7971
7972                 if (agent_config.defer) {
7973                         /* Transmit cached data to the client on receipt of the event request */
7974                         switch (req->event_kind) {
7975                         case EVENT_KIND_APPDOMAIN_CREATE:
7976                                 /* Emit load events for currently loaded domains */
7977                                 g_hash_table_foreach (domains, emit_appdomain_load, NULL);
7978                                 break;
7979                         case EVENT_KIND_ASSEMBLY_LOAD:
7980                                 /* Emit load events for currently loaded assemblies */
7981                                 mono_domain_foreach (send_assemblies_for_domain, NULL);
7982                                 break;
7983                         case EVENT_KIND_THREAD_START:
7984                                 /* Emit start events for currently started threads */
7985                                 mono_g_hash_table_foreach (tid_to_thread, emit_thread_start, NULL);
7986                                 break;
7987                         case EVENT_KIND_TYPE_LOAD:
7988                                 /* Emit type load events for currently loaded types */
7989                                 mono_domain_foreach (send_types_for_domain, NULL);
7990                                 break;
7991                         default:
7992                                 break;
7993                         }
7994                 }
7995                 mono_loader_unlock ();
7996
7997                 buffer_add_int (buf, req->id);
7998                 break;
7999         }
8000         case CMD_EVENT_REQUEST_CLEAR: {
8001                 int etype = decode_byte (p, &p, end);
8002                 int req_id = decode_int (p, &p, end);
8003
8004                 // FIXME: Make a faster mapping from req_id to request
8005                 mono_loader_lock ();
8006                 clear_event_request (req_id, etype);
8007                 mono_loader_unlock ();
8008                 break;
8009         }
8010         case CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS: {
8011                 int i;
8012
8013                 mono_loader_lock ();
8014                 i = 0;
8015                 while (i < event_requests->len) {
8016                         EventRequest *req = (EventRequest *)g_ptr_array_index (event_requests, i);
8017
8018                         if (req->event_kind == EVENT_KIND_BREAKPOINT) {
8019                                 clear_breakpoint ((MonoBreakpoint *)req->info);
8020
8021                                 g_ptr_array_remove_index_fast (event_requests, i);
8022                                 g_free (req);
8023                         } else {
8024                                 i ++;
8025                         }
8026                 }
8027                 mono_loader_unlock ();
8028                 break;
8029         }
8030         default:
8031                 return ERR_NOT_IMPLEMENTED;
8032         }
8033
8034         return ERR_NONE;
8035 }
8036
8037 static ErrorCode
8038 domain_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
8039 {
8040         ErrorCode err;
8041         MonoDomain *domain;
8042
8043         switch (command) {
8044         case CMD_APPDOMAIN_GET_ROOT_DOMAIN: {
8045                 buffer_add_domainid (buf, mono_get_root_domain ());
8046                 break;
8047         }
8048         case CMD_APPDOMAIN_GET_FRIENDLY_NAME: {
8049                 domain = decode_domainid (p, &p, end, NULL, &err);
8050                 if (err != ERR_NONE)
8051                         return err;
8052                 buffer_add_string (buf, domain->friendly_name);
8053                 break;
8054         }
8055         case CMD_APPDOMAIN_GET_ASSEMBLIES: {
8056                 GSList *tmp;
8057                 MonoAssembly *ass;
8058                 int count;
8059
8060                 domain = decode_domainid (p, &p, end, NULL, &err);
8061                 if (err != ERR_NONE)
8062                         return err;
8063                 mono_loader_lock ();
8064                 count = 0;
8065                 for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
8066                         count ++;
8067                 }
8068                 buffer_add_int (buf, count);
8069                 for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
8070                         ass = (MonoAssembly *)tmp->data;
8071                         buffer_add_assemblyid (buf, domain, ass);
8072                 }
8073                 mono_loader_unlock ();
8074                 break;
8075         }
8076         case CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY: {
8077                 domain = decode_domainid (p, &p, end, NULL, &err);
8078                 if (err != ERR_NONE)
8079                         return err;
8080
8081                 buffer_add_assemblyid (buf, domain, domain->entry_assembly);
8082                 break;
8083         }
8084         case CMD_APPDOMAIN_GET_CORLIB: {
8085                 domain = decode_domainid (p, &p, end, NULL, &err);
8086                 if (err != ERR_NONE)
8087                         return err;
8088
8089                 buffer_add_assemblyid (buf, domain, domain->domain->mbr.obj.vtable->klass->image->assembly);
8090                 break;
8091         }
8092         case CMD_APPDOMAIN_CREATE_STRING: {
8093                 char *s;
8094                 MonoString *o;
8095                 MonoError error;
8096
8097                 domain = decode_domainid (p, &p, end, NULL, &err);
8098                 if (err != ERR_NONE)
8099                         return err;
8100                 s = decode_string (p, &p, end);
8101
8102                 o = mono_string_new_checked (domain, s, &error);
8103                 if (!is_ok (&error)) {
8104                         DEBUG_PRINTF (1, "[dbg] Failed to allocate String object '%s': %s\n", s, mono_error_get_message (&error));
8105                         mono_error_cleanup (&error);
8106                         return ERR_INVALID_OBJECT;
8107                 }
8108                 buffer_add_objid (buf, (MonoObject*)o);
8109                 break;
8110         }
8111         case CMD_APPDOMAIN_CREATE_BOXED_VALUE: {
8112                 MonoError error;
8113                 MonoClass *klass;
8114                 MonoDomain *domain2;
8115                 MonoObject *o;
8116
8117                 domain = decode_domainid (p, &p, end, NULL, &err);
8118                 if (err != ERR_NONE)
8119                         return err;
8120                 klass = decode_typeid (p, &p, end, &domain2, &err);
8121                 if (err != ERR_NONE)
8122                         return err;
8123
8124                 // FIXME:
8125                 g_assert (domain == domain2);
8126
8127                 o = mono_object_new_checked (domain, klass, &error);
8128                 mono_error_assert_ok (&error);
8129
8130                 err = decode_value (&klass->byval_arg, domain, (guint8 *)mono_object_unbox (o), p, &p, end);
8131                 if (err != ERR_NONE)
8132                         return err;
8133
8134                 buffer_add_objid (buf, o);
8135                 break;
8136         }
8137         default:
8138                 return ERR_NOT_IMPLEMENTED;
8139         }
8140
8141         return ERR_NONE;
8142 }
8143
8144 static ErrorCode
8145 get_assembly_object_command (MonoDomain *domain, MonoAssembly *ass, Buffer *buf, MonoError *error)
8146 {
8147         HANDLE_FUNCTION_ENTER();
8148         ErrorCode err = ERR_NONE;
8149         error_init (error);
8150         MonoReflectionAssemblyHandle o = mono_assembly_get_object_handle (domain, ass, error);
8151         if (MONO_HANDLE_IS_NULL (o)) {
8152                 err = ERR_INVALID_OBJECT;
8153                 goto leave;
8154         }
8155         buffer_add_objid (buf, MONO_HANDLE_RAW (MONO_HANDLE_CAST (MonoObject, o)));
8156 leave:
8157         HANDLE_FUNCTION_RETURN_VAL (err);
8158 }
8159
8160
8161 static ErrorCode
8162 assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
8163 {
8164         ErrorCode err;
8165         MonoAssembly *ass;
8166         MonoDomain *domain;
8167
8168         ass = decode_assemblyid (p, &p, end, &domain, &err);
8169         if (err != ERR_NONE)
8170                 return err;
8171
8172         switch (command) {
8173         case CMD_ASSEMBLY_GET_LOCATION: {
8174                 buffer_add_string (buf, mono_image_get_filename (ass->image));
8175                 break;
8176         }
8177         case CMD_ASSEMBLY_GET_ENTRY_POINT: {
8178                 guint32 token;
8179                 MonoMethod *m;
8180
8181                 if (ass->image->dynamic) {
8182                         buffer_add_id (buf, 0);
8183                 } else {
8184                         token = mono_image_get_entry_point (ass->image);
8185                         if (token == 0) {
8186                                 buffer_add_id (buf, 0);
8187                         } else {
8188                                 MonoError error;
8189                                 m = mono_get_method_checked (ass->image, token, NULL, NULL, &error);
8190                                 if (!m)
8191                                         mono_error_cleanup (&error); /* FIXME don't swallow the error */
8192                                 buffer_add_methodid (buf, domain, m);
8193                         }
8194                 }
8195                 break;
8196         }
8197         case CMD_ASSEMBLY_GET_MANIFEST_MODULE: {
8198                 buffer_add_moduleid (buf, domain, ass->image);
8199                 break;
8200         }
8201         case CMD_ASSEMBLY_GET_OBJECT: {
8202                 MonoError error;
8203                 err = get_assembly_object_command (domain, ass, buf, &error);
8204                 mono_error_cleanup (&error);
8205                 return err;
8206         }
8207         case CMD_ASSEMBLY_GET_DOMAIN: {
8208                 buffer_add_domainid (buf, domain);
8209                 break;
8210         }
8211         case CMD_ASSEMBLY_GET_TYPE: {
8212                 MonoError error;
8213                 char *s = decode_string (p, &p, end);
8214                 gboolean ignorecase = decode_byte (p, &p, end);
8215                 MonoTypeNameParse info;
8216                 MonoType *t;
8217                 gboolean type_resolve, res;
8218                 MonoDomain *d = mono_domain_get ();
8219
8220                 /* This is needed to be able to find referenced assemblies */
8221                 res = mono_domain_set (domain, FALSE);
8222                 g_assert (res);
8223
8224                 if (!mono_reflection_parse_type (s, &info)) {
8225                         t = NULL;
8226                 } else {
8227                         if (info.assembly.name)
8228                                 NOT_IMPLEMENTED;
8229                         t = mono_reflection_get_type_checked (ass->image, ass->image, &info, ignorecase, &type_resolve, &error);
8230                         if (!is_ok (&error)) {
8231                                 mono_error_cleanup (&error); /* FIXME don't swallow the error */
8232                                 mono_reflection_free_type_info (&info);
8233                                 g_free (s);
8234                                 return ERR_INVALID_ARGUMENT;
8235                         }
8236                 }
8237                 buffer_add_typeid (buf, domain, t ? mono_class_from_mono_type (t) : NULL);
8238                 mono_reflection_free_type_info (&info);
8239                 g_free (s);
8240
8241                 mono_domain_set (d, TRUE);
8242
8243                 break;
8244         }
8245         case CMD_ASSEMBLY_GET_NAME: {
8246                 gchar *name;
8247                 MonoAssembly *mass = ass;
8248
8249                 name = g_strdup_printf (
8250                   "%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s",
8251                   mass->aname.name,
8252                   mass->aname.major, mass->aname.minor, mass->aname.build, mass->aname.revision,
8253                   mass->aname.culture && *mass->aname.culture? mass->aname.culture: "neutral",
8254                   mass->aname.public_key_token [0] ? (char *)mass->aname.public_key_token : "null",
8255                   (mass->aname.flags & ASSEMBLYREF_RETARGETABLE_FLAG) ? ", Retargetable=Yes" : "");
8256
8257                 buffer_add_string (buf, name);
8258                 g_free (name);
8259                 break;
8260         }
8261         default:
8262                 return ERR_NOT_IMPLEMENTED;
8263         }
8264
8265         return ERR_NONE;
8266 }
8267
8268 static ErrorCode
8269 module_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
8270 {
8271         ErrorCode err;
8272         MonoDomain *domain;
8273
8274         switch (command) {
8275         case CMD_MODULE_GET_INFO: {
8276                 MonoImage *image = decode_moduleid (p, &p, end, &domain, &err);
8277                 char *basename;
8278
8279                 basename = g_path_get_basename (image->name);
8280                 buffer_add_string (buf, basename); // name
8281                 buffer_add_string (buf, image->module_name); // scopename
8282                 buffer_add_string (buf, image->name); // fqname
8283                 buffer_add_string (buf, mono_image_get_guid (image)); // guid
8284                 buffer_add_assemblyid (buf, domain, image->assembly); // assembly
8285                 g_free (basename);
8286                 break;
8287         }
8288         default:
8289                 return ERR_NOT_IMPLEMENTED;
8290         }
8291
8292         return ERR_NONE;
8293 }
8294
8295 static ErrorCode
8296 field_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
8297 {
8298         ErrorCode err;
8299         MonoDomain *domain;
8300
8301         switch (command) {
8302         case CMD_FIELD_GET_INFO: {
8303                 MonoClassField *f = decode_fieldid (p, &p, end, &domain, &err);
8304
8305                 buffer_add_string (buf, f->name);
8306                 buffer_add_typeid (buf, domain, f->parent);
8307                 buffer_add_typeid (buf, domain, mono_class_from_mono_type (f->type));
8308                 buffer_add_int (buf, f->type->attrs);
8309                 break;
8310         }
8311         default:
8312                 return ERR_NOT_IMPLEMENTED;
8313         }
8314
8315         return ERR_NONE;
8316 }
8317
8318 static void
8319 buffer_add_cattr_arg (Buffer *buf, MonoType *t, MonoDomain *domain, MonoObject *val)
8320 {
8321         if (val && val->vtable->klass == mono_defaults.runtimetype_class) {
8322                 /* Special case these so the client doesn't have to handle Type objects */
8323
8324                 buffer_add_byte (buf, VALUE_TYPE_ID_TYPE);
8325                 buffer_add_typeid (buf, domain, mono_class_from_mono_type (((MonoReflectionType*)val)->type));
8326         } else if (MONO_TYPE_IS_REFERENCE (t))
8327                 buffer_add_value (buf, t, &val, domain);
8328         else
8329                 buffer_add_value (buf, t, mono_object_unbox (val), domain);
8330 }
8331
8332 static ErrorCode
8333 buffer_add_cattrs (Buffer *buf, MonoDomain *domain, MonoImage *image, MonoClass *attr_klass, MonoCustomAttrInfo *cinfo)
8334 {
8335         int i, j;
8336         int nattrs = 0;
8337
8338         if (!cinfo) {
8339                 buffer_add_int (buf, 0);
8340                 return ERR_NONE;
8341         }
8342
8343         for (i = 0; i < cinfo->num_attrs; ++i) {
8344                 if (!attr_klass || mono_class_has_parent (cinfo->attrs [i].ctor->klass, attr_klass))
8345                         nattrs ++;
8346         }
8347         buffer_add_int (buf, nattrs);
8348
8349         for (i = 0; i < cinfo->num_attrs; ++i) {
8350                 MonoCustomAttrEntry *attr = &cinfo->attrs [i];
8351                 if (!attr_klass || mono_class_has_parent (attr->ctor->klass, attr_klass)) {
8352                         MonoArray *typed_args, *named_args;
8353                         MonoType *t;
8354                         CattrNamedArg *arginfo = NULL;
8355                         MonoError error;
8356
8357                         mono_reflection_create_custom_attr_data_args (image, attr->ctor, attr->data, attr->data_size, &typed_args, &named_args, &arginfo, &error);
8358                         if (!mono_error_ok (&error)) {
8359                                 DEBUG_PRINTF (2, "[dbg] mono_reflection_create_custom_attr_data_args () failed with: '%s'\n", mono_error_get_message (&error));
8360                                 mono_error_cleanup (&error);
8361                                 return ERR_LOADER_ERROR;
8362                         }
8363
8364                         buffer_add_methodid (buf, domain, attr->ctor);
8365
8366                         /* Ctor args */
8367                         if (typed_args) {
8368                                 buffer_add_int (buf, mono_array_length (typed_args));
8369                                 for (j = 0; j < mono_array_length (typed_args); ++j) {
8370                                         MonoObject *val = mono_array_get (typed_args, MonoObject*, j);
8371
8372                                         t = mono_method_signature (attr->ctor)->params [j];
8373
8374                                         buffer_add_cattr_arg (buf, t, domain, val);
8375                                 }
8376                         } else {
8377                                 buffer_add_int (buf, 0);
8378                         }
8379
8380                         /* Named args */
8381                         if (named_args) {
8382                                 buffer_add_int (buf, mono_array_length (named_args));
8383
8384                                 for (j = 0; j < mono_array_length (named_args); ++j) {
8385                                         MonoObject *val = mono_array_get (named_args, MonoObject*, j);
8386
8387                                         if (arginfo [j].prop) {
8388                                                 buffer_add_byte (buf, 0x54);
8389                                                 buffer_add_propertyid (buf, domain, arginfo [j].prop);
8390                                         } else if (arginfo [j].field) {
8391                                                 buffer_add_byte (buf, 0x53);
8392                                                 buffer_add_fieldid (buf, domain, arginfo [j].field);
8393                                         } else {
8394                                                 g_assert_not_reached ();
8395                                         }
8396
8397                                         buffer_add_cattr_arg (buf, arginfo [j].type, domain, val);
8398                                 }
8399                         } else {
8400                                 buffer_add_int (buf, 0);
8401                         }
8402                         g_free (arginfo);
8403                 }
8404         }
8405
8406         return ERR_NONE;
8407 }
8408
8409 /* FIXME: Code duplication with icall.c */
8410 static void
8411 collect_interfaces (MonoClass *klass, GHashTable *ifaces, MonoError *error)
8412 {
8413         int i;
8414         MonoClass *ic;
8415
8416         mono_class_setup_interfaces (klass, error);
8417         if (!mono_error_ok (error))
8418                 return;
8419
8420         for (i = 0; i < klass->interface_count; i++) {
8421                 ic = klass->interfaces [i];
8422                 g_hash_table_insert (ifaces, ic, ic);
8423
8424                 collect_interfaces (ic, ifaces, error);
8425                 if (!mono_error_ok (error))
8426                         return;
8427         }
8428 }
8429
8430 static ErrorCode
8431 type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint8 *p, guint8 *end, Buffer *buf)
8432 {
8433         MonoError error;
8434         MonoClass *nested;
8435         MonoType *type;
8436         gpointer iter;
8437         guint8 b;
8438         int nnested;
8439         ErrorCode err;
8440         char *name;
8441
8442         switch (command) {
8443         case CMD_TYPE_GET_INFO: {
8444                 buffer_add_string (buf, klass->name_space);
8445                 buffer_add_string (buf, klass->name);
8446                 // FIXME: byref
8447                 name = mono_type_get_name_full (&klass->byval_arg, MONO_TYPE_NAME_FORMAT_FULL_NAME);
8448                 buffer_add_string (buf, name);
8449                 g_free (name);
8450                 buffer_add_assemblyid (buf, domain, klass->image->assembly);
8451                 buffer_add_moduleid (buf, domain, klass->image);
8452                 buffer_add_typeid (buf, domain, klass->parent);
8453                 if (klass->rank || klass->byval_arg.type == MONO_TYPE_PTR)
8454                         buffer_add_typeid (buf, domain, klass->element_class);
8455                 else
8456                         buffer_add_id (buf, 0);
8457                 buffer_add_int (buf, klass->type_token);
8458                 buffer_add_byte (buf, klass->rank);
8459                 buffer_add_int (buf, mono_class_get_flags (klass));
8460                 b = 0;
8461                 type = &klass->byval_arg;
8462                 // FIXME: Can't decide whenever a class represents a byref type
8463                 if (FALSE)
8464                         b |= (1 << 0);
8465                 if (type->type == MONO_TYPE_PTR)
8466                         b |= (1 << 1);
8467                 if (!type->byref && (((type->type >= MONO_TYPE_BOOLEAN) && (type->type <= MONO_TYPE_R8)) || (type->type == MONO_TYPE_I) || (type->type == MONO_TYPE_U)))
8468                         b |= (1 << 2);
8469                 if (type->type == MONO_TYPE_VALUETYPE)
8470                         b |= (1 << 3);
8471                 if (klass->enumtype)
8472                         b |= (1 << 4);
8473                 if (mono_class_is_gtd (klass))
8474                         b |= (1 << 5);
8475                 if (mono_class_is_gtd (klass) || mono_class_is_ginst (klass))
8476                         b |= (1 << 6);
8477                 buffer_add_byte (buf, b);
8478                 nnested = 0;
8479                 iter = NULL;
8480                 while ((nested = mono_class_get_nested_types (klass, &iter)))
8481                         nnested ++;
8482                 buffer_add_int (buf, nnested);
8483                 iter = NULL;
8484                 while ((nested = mono_class_get_nested_types (klass, &iter)))
8485                         buffer_add_typeid (buf, domain, nested);
8486                 if (CHECK_PROTOCOL_VERSION (2, 12)) {
8487                         if (mono_class_is_gtd (klass))
8488                                 buffer_add_typeid (buf, domain, klass);
8489                         else if (mono_class_is_ginst (klass))
8490                                 buffer_add_typeid (buf, domain, mono_class_get_generic_class (klass)->container_class);
8491                         else
8492                                 buffer_add_id (buf, 0);
8493                 }
8494                 if (CHECK_PROTOCOL_VERSION (2, 15)) {
8495                         int count, i;
8496
8497                         if (mono_class_is_ginst (klass)) {
8498                                 MonoGenericInst *inst = mono_class_get_generic_class (klass)->context.class_inst;
8499
8500                                 count = inst->type_argc;
8501                                 buffer_add_int (buf, count);
8502                                 for (i = 0; i < count; i++)
8503                                         buffer_add_typeid (buf, domain, mono_class_from_mono_type (inst->type_argv [i]));
8504                         } else if (mono_class_is_gtd (klass)) {
8505                                 MonoGenericContainer *container = mono_class_get_generic_container (klass);
8506                                 MonoClass *pklass;
8507
8508                                 count = container->type_argc;
8509                                 buffer_add_int (buf, count);
8510                                 for (i = 0; i < count; i++) {
8511                                         pklass = mono_class_from_generic_parameter_internal (mono_generic_container_get_param (container, i));
8512                                         buffer_add_typeid (buf, domain, pklass);
8513                                 }
8514                         } else {
8515                                 buffer_add_int (buf, 0);
8516                         }
8517                 }
8518                 break;
8519         }
8520         case CMD_TYPE_GET_METHODS: {
8521                 int nmethods;
8522                 int i = 0;
8523                 gpointer iter = NULL;
8524                 MonoMethod *m;
8525
8526                 mono_class_setup_methods (klass);
8527
8528                 nmethods = mono_class_num_methods (klass);
8529
8530                 buffer_add_int (buf, nmethods);
8531
8532                 while ((m = mono_class_get_methods (klass, &iter))) {
8533                         buffer_add_methodid (buf, domain, m);
8534                         i ++;
8535                 }
8536                 g_assert (i == nmethods);
8537                 break;
8538         }
8539         case CMD_TYPE_GET_FIELDS: {
8540                 int nfields;
8541                 int i = 0;
8542                 gpointer iter = NULL;
8543                 MonoClassField *f;
8544
8545                 nfields = mono_class_num_fields (klass);
8546
8547                 buffer_add_int (buf, nfields);
8548
8549                 while ((f = mono_class_get_fields (klass, &iter))) {
8550                         buffer_add_fieldid (buf, domain, f);
8551                         buffer_add_string (buf, f->name);
8552                         buffer_add_typeid (buf, domain, mono_class_from_mono_type (f->type));
8553                         buffer_add_int (buf, f->type->attrs);
8554                         i ++;
8555                 }
8556                 g_assert (i == nfields);
8557                 break;
8558         }
8559         case CMD_TYPE_GET_PROPERTIES: {
8560                 int nprops;
8561                 int i = 0;
8562                 gpointer iter = NULL;
8563                 MonoProperty *p;
8564
8565                 nprops = mono_class_num_properties (klass);
8566
8567                 buffer_add_int (buf, nprops);
8568
8569                 while ((p = mono_class_get_properties (klass, &iter))) {
8570                         buffer_add_propertyid (buf, domain, p);
8571                         buffer_add_string (buf, p->name);
8572                         buffer_add_methodid (buf, domain, p->get);
8573                         buffer_add_methodid (buf, domain, p->set);
8574                         buffer_add_int (buf, p->attrs);
8575                         i ++;
8576                 }
8577                 g_assert (i == nprops);
8578                 break;
8579         }
8580         case CMD_TYPE_GET_CATTRS: {
8581                 MonoClass *attr_klass;
8582                 MonoCustomAttrInfo *cinfo;
8583
8584                 attr_klass = decode_typeid (p, &p, end, NULL, &err);
8585                 /* attr_klass can be NULL */
8586                 if (err != ERR_NONE)
8587                         return err;
8588
8589                 cinfo = mono_custom_attrs_from_class_checked (klass, &error);
8590                 if (!is_ok (&error)) {
8591                         mono_error_cleanup (&error); /* FIXME don't swallow the error message */
8592                         return ERR_LOADER_ERROR;
8593                 }
8594
8595                 err = buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo);
8596                 if (err != ERR_NONE)
8597                         return err;
8598                 break;
8599         }
8600         case CMD_TYPE_GET_FIELD_CATTRS: {
8601                 MonoClass *attr_klass;
8602                 MonoCustomAttrInfo *cinfo;
8603                 MonoClassField *field;
8604
8605                 field = decode_fieldid (p, &p, end, NULL, &err);
8606                 if (err != ERR_NONE)
8607                         return err;
8608                 attr_klass = decode_typeid (p, &p, end, NULL, &err);
8609                 if (err != ERR_NONE)
8610                         return err;
8611
8612                 cinfo = mono_custom_attrs_from_field_checked (klass, field, &error);
8613                 if (!is_ok (&error)) {
8614                         mono_error_cleanup (&error); /* FIXME don't swallow the error message */
8615                         return ERR_LOADER_ERROR;
8616                 }
8617
8618                 err = buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo);
8619                 if (err != ERR_NONE)
8620                         return err;
8621                 break;
8622         }
8623         case CMD_TYPE_GET_PROPERTY_CATTRS: {
8624                 MonoClass *attr_klass;
8625                 MonoCustomAttrInfo *cinfo;
8626                 MonoProperty *prop;
8627
8628                 prop = decode_propertyid (p, &p, end, NULL, &err);
8629                 if (err != ERR_NONE)
8630                         return err;
8631                 attr_klass = decode_typeid (p, &p, end, NULL, &err);
8632                 if (err != ERR_NONE)
8633                         return err;
8634
8635                 cinfo = mono_custom_attrs_from_property_checked (klass, prop, &error);
8636                 if (!is_ok (&error)) {
8637                         mono_error_cleanup (&error); /* FIXME don't swallow the error message */
8638                         return ERR_LOADER_ERROR;
8639                 }
8640
8641                 err = buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo);
8642                 if (err != ERR_NONE)
8643                         return err;
8644                 break;
8645         }
8646         case CMD_TYPE_GET_VALUES:
8647         case CMD_TYPE_GET_VALUES_2: {
8648                 guint8 *val;
8649                 MonoClassField *f;
8650                 MonoVTable *vtable;
8651                 MonoClass *k;
8652                 int len, i;
8653                 gboolean found;
8654                 MonoThread *thread_obj;
8655                 MonoInternalThread *thread = NULL;
8656                 guint32 special_static_type;
8657
8658                 if (command == CMD_TYPE_GET_VALUES_2) {
8659                         int objid = decode_objid (p, &p, end);
8660                         ErrorCode err;
8661
8662                         err = get_object (objid, (MonoObject**)&thread_obj);
8663                         if (err != ERR_NONE)
8664                                 return err;
8665
8666                         thread = THREAD_TO_INTERNAL (thread_obj);
8667                 }
8668
8669                 len = decode_int (p, &p, end);
8670                 for (i = 0; i < len; ++i) {
8671                         f = decode_fieldid (p, &p, end, NULL, &err);
8672                         if (err != ERR_NONE)
8673                                 return err;
8674
8675                         if (!(f->type->attrs & FIELD_ATTRIBUTE_STATIC))
8676                                 return ERR_INVALID_FIELDID;
8677                         special_static_type = mono_class_field_get_special_static_type (f);
8678                         if (special_static_type != SPECIAL_STATIC_NONE) {
8679                                 if (!(thread && special_static_type == SPECIAL_STATIC_THREAD))
8680                                         return ERR_INVALID_FIELDID;
8681                         }
8682
8683                         /* Check that the field belongs to the object */
8684                         found = FALSE;
8685                         for (k = klass; k; k = k->parent) {
8686                                 if (k == f->parent) {
8687                                         found = TRUE;
8688                                         break;
8689                                 }
8690                         }
8691                         if (!found)
8692                                 return ERR_INVALID_FIELDID;
8693
8694                         vtable = mono_class_vtable (domain, f->parent);
8695                         val = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
8696                         mono_field_static_get_value_for_thread (thread ? thread : mono_thread_internal_current (), vtable, f, val, &error);
8697                         if (!is_ok (&error))
8698                                 return ERR_INVALID_FIELDID;
8699                         buffer_add_value (buf, f->type, val, domain);
8700                         g_free (val);
8701                 }
8702                 break;
8703         }
8704         case CMD_TYPE_SET_VALUES: {
8705                 guint8 *val;
8706                 MonoClassField *f;
8707                 MonoVTable *vtable;
8708                 MonoClass *k;
8709                 int len, i;
8710                 gboolean found;
8711
8712                 len = decode_int (p, &p, end);
8713                 for (i = 0; i < len; ++i) {
8714                         f = decode_fieldid (p, &p, end, NULL, &err);
8715                         if (err != ERR_NONE)
8716                                 return err;
8717
8718                         if (!(f->type->attrs & FIELD_ATTRIBUTE_STATIC))
8719                                 return ERR_INVALID_FIELDID;
8720                         if (mono_class_field_is_special_static (f))
8721                                 return ERR_INVALID_FIELDID;
8722
8723                         /* Check that the field belongs to the object */
8724                         found = FALSE;
8725                         for (k = klass; k; k = k->parent) {
8726                                 if (k == f->parent) {
8727                                         found = TRUE;
8728                                         break;
8729                                 }
8730                         }
8731                         if (!found)
8732                                 return ERR_INVALID_FIELDID;
8733
8734                         // FIXME: Check for literal/const
8735
8736                         vtable = mono_class_vtable (domain, f->parent);
8737                         val = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
8738                         err = decode_value (f->type, domain, val, p, &p, end);
8739                         if (err != ERR_NONE) {
8740                                 g_free (val);
8741                                 return err;
8742                         }
8743                         if (MONO_TYPE_IS_REFERENCE (f->type))
8744                                 mono_field_static_set_value (vtable, f, *(gpointer*)val);
8745                         else
8746                                 mono_field_static_set_value (vtable, f, val);
8747                         g_free (val);
8748                 }
8749                 break;
8750         }
8751         case CMD_TYPE_GET_OBJECT: {
8752                 MonoObject *o = (MonoObject*)mono_type_get_object_checked (domain, &klass->byval_arg, &error);
8753                 if (!mono_error_ok (&error)) {
8754                         mono_error_cleanup (&error);
8755                         return ERR_INVALID_OBJECT;
8756                 }
8757                 buffer_add_objid (buf, o);
8758                 break;
8759         }
8760         case CMD_TYPE_GET_SOURCE_FILES:
8761         case CMD_TYPE_GET_SOURCE_FILES_2: {
8762                 char *source_file, *base;
8763                 GPtrArray *files;
8764                 int i;
8765
8766                 files = get_source_files_for_type (klass);
8767
8768                 buffer_add_int (buf, files->len);
8769                 for (i = 0; i < files->len; ++i) {
8770                         source_file = (char *)g_ptr_array_index (files, i);
8771                         if (command == CMD_TYPE_GET_SOURCE_FILES_2) {
8772                                 buffer_add_string (buf, source_file);
8773                         } else {
8774                                 base = dbg_path_get_basename (source_file);
8775                                 buffer_add_string (buf, base);
8776                                 g_free (base);
8777                         }
8778                         g_free (source_file);
8779                 }
8780                 g_ptr_array_free (files, TRUE);
8781                 break;
8782         }
8783         case CMD_TYPE_IS_ASSIGNABLE_FROM: {
8784                 MonoClass *oklass = decode_typeid (p, &p, end, NULL, &err);
8785
8786                 if (err != ERR_NONE)
8787                         return err;
8788                 if (mono_class_is_assignable_from (klass, oklass))
8789                         buffer_add_byte (buf, 1);
8790                 else
8791                         buffer_add_byte (buf, 0);
8792                 break;
8793         }
8794         case CMD_TYPE_GET_METHODS_BY_NAME_FLAGS: {
8795                 char *name = decode_string (p, &p, end);
8796                 int i, flags = decode_int (p, &p, end);
8797                 MonoError error;
8798                 GPtrArray *array;
8799
8800                 error_init (&error);
8801                 array = mono_class_get_methods_by_name (klass, name, flags & ~BINDING_FLAGS_IGNORE_CASE, (flags & BINDING_FLAGS_IGNORE_CASE) != 0, TRUE, &error);
8802                 if (!is_ok (&error)) {
8803                         mono_error_cleanup (&error);
8804                         return ERR_LOADER_ERROR;
8805                 }
8806                 buffer_add_int (buf, array->len);
8807                 for (i = 0; i < array->len; ++i) {
8808                         MonoMethod *method = (MonoMethod *)g_ptr_array_index (array, i);
8809                         buffer_add_methodid (buf, domain, method);
8810                 }
8811
8812                 g_ptr_array_free (array, TRUE);
8813                 g_free (name);
8814                 break;
8815         }
8816         case CMD_TYPE_GET_INTERFACES: {
8817                 MonoClass *parent;
8818                 GHashTable *iface_hash = g_hash_table_new (NULL, NULL);
8819                 MonoClass *tclass, *iface;
8820                 GHashTableIter iter;
8821
8822                 tclass = klass;
8823
8824                 for (parent = tclass; parent; parent = parent->parent) {
8825                         mono_class_setup_interfaces (parent, &error);
8826                         if (!mono_error_ok (&error))
8827                                 return ERR_LOADER_ERROR;
8828                         collect_interfaces (parent, iface_hash, &error);
8829                         if (!mono_error_ok (&error))
8830                                 return ERR_LOADER_ERROR;
8831                 }
8832
8833                 buffer_add_int (buf, g_hash_table_size (iface_hash));
8834
8835                 g_hash_table_iter_init (&iter, iface_hash);
8836                 while (g_hash_table_iter_next (&iter, NULL, (void**)&iface))
8837                         buffer_add_typeid (buf, domain, iface);
8838                 g_hash_table_destroy (iface_hash);
8839                 break;
8840         }
8841         case CMD_TYPE_GET_INTERFACE_MAP: {
8842                 int tindex, ioffset;
8843                 gboolean variance_used;
8844                 MonoClass *iclass;
8845                 int len, nmethods, i;
8846                 gpointer iter;
8847                 MonoMethod *method;
8848
8849                 len = decode_int (p, &p, end);
8850                 mono_class_setup_vtable (klass);
8851
8852                 for (tindex = 0; tindex < len; ++tindex) {
8853                         iclass = decode_typeid (p, &p, end, NULL, &err);
8854                         if (err != ERR_NONE)
8855                                 return err;
8856
8857                         ioffset = mono_class_interface_offset_with_variance (klass, iclass, &variance_used);
8858                         if (ioffset == -1)
8859                                 return ERR_INVALID_ARGUMENT;
8860
8861                         nmethods = mono_class_num_methods (iclass);
8862                         buffer_add_int (buf, nmethods);
8863
8864                         iter = NULL;
8865                         while ((method = mono_class_get_methods (iclass, &iter))) {
8866                                 buffer_add_methodid (buf, domain, method);
8867                         }
8868                         for (i = 0; i < nmethods; ++i)
8869                                 buffer_add_methodid (buf, domain, klass->vtable [i + ioffset]);
8870                 }
8871                 break;
8872         }
8873         case CMD_TYPE_IS_INITIALIZED: {
8874                 MonoVTable *vtable = mono_class_vtable (domain, klass);
8875
8876                 if (vtable)
8877                         buffer_add_int (buf, (vtable->initialized || vtable->init_failed) ? 1 : 0);
8878                 else
8879                         buffer_add_int (buf, 0);
8880                 break;
8881         }
8882         case CMD_TYPE_CREATE_INSTANCE: {
8883                 MonoError error;
8884                 MonoObject *obj;
8885
8886                 obj = mono_object_new_checked (domain, klass, &error);
8887                 mono_error_assert_ok (&error);
8888                 buffer_add_objid (buf, obj);
8889                 break;
8890         }
8891         default:
8892                 return ERR_NOT_IMPLEMENTED;
8893         }
8894
8895         return ERR_NONE;
8896 }
8897
8898 static ErrorCode
8899 type_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
8900 {
8901         MonoClass *klass;
8902         MonoDomain *old_domain;
8903         MonoDomain *domain;
8904         ErrorCode err;
8905
8906         klass = decode_typeid (p, &p, end, &domain, &err);
8907         if (err != ERR_NONE)
8908                 return err;
8909
8910         old_domain = mono_domain_get ();
8911
8912         mono_domain_set (domain, TRUE);
8913
8914         err = type_commands_internal (command, klass, domain, p, end, buf);
8915
8916         mono_domain_set (old_domain, TRUE);
8917
8918         return err;
8919 }
8920
8921 static ErrorCode
8922 method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, guint8 *p, guint8 *end, Buffer *buf)
8923 {
8924         MonoMethodHeader *header;
8925         ErrorCode err;
8926
8927         switch (command) {
8928         case CMD_METHOD_GET_NAME: {
8929                 buffer_add_string (buf, method->name);
8930                 break;
8931         }
8932         case CMD_METHOD_GET_DECLARING_TYPE: {
8933                 buffer_add_typeid (buf, domain, method->klass);
8934                 break;
8935         }
8936         case CMD_METHOD_GET_DEBUG_INFO: {
8937                 MonoError error;
8938                 MonoDebugMethodInfo *minfo;
8939                 char *source_file;
8940                 int i, j, n_il_offsets;
8941                 int *source_files;
8942                 GPtrArray *source_file_list;
8943                 MonoSymSeqPoint *sym_seq_points;
8944
8945                 header = mono_method_get_header_checked (method, &error);
8946                 if (!header) {
8947                         mono_error_cleanup (&error); /* FIXME don't swallow the error */
8948                         buffer_add_int (buf, 0);
8949                         buffer_add_string (buf, "");
8950                         buffer_add_int (buf, 0);
8951                         break;
8952                 }
8953
8954                 minfo = mono_debug_lookup_method (method);
8955                 if (!minfo) {
8956                         buffer_add_int (buf, header->code_size);
8957                         buffer_add_string (buf, "");
8958                         buffer_add_int (buf, 0);
8959                         mono_metadata_free_mh (header);
8960                         break;
8961                 }
8962
8963                 mono_debug_get_seq_points (minfo, &source_file, &source_file_list, &source_files, &sym_seq_points, &n_il_offsets);
8964                 buffer_add_int (buf, header->code_size);
8965                 if (CHECK_PROTOCOL_VERSION (2, 13)) {
8966                         buffer_add_int (buf, source_file_list->len);
8967                         for (i = 0; i < source_file_list->len; ++i) {
8968                                 MonoDebugSourceInfo *sinfo = (MonoDebugSourceInfo *)g_ptr_array_index (source_file_list, i);
8969                                 buffer_add_string (buf, sinfo->source_file);
8970                                 if (CHECK_PROTOCOL_VERSION (2, 14)) {
8971                                         for (j = 0; j < 16; ++j)
8972                                                 buffer_add_byte (buf, sinfo->hash [j]);
8973                                 }
8974                         }
8975                 } else {
8976                         buffer_add_string (buf, source_file);
8977                 }
8978                 buffer_add_int (buf, n_il_offsets);
8979                 DEBUG_PRINTF (10, "Line number table for method %s:\n", mono_method_full_name (method,  TRUE));
8980                 for (i = 0; i < n_il_offsets; ++i) {
8981                         MonoSymSeqPoint *sp = &sym_seq_points [i];
8982                         const char *srcfile = "";
8983
8984                         if (source_files [i] != -1) {
8985                                 MonoDebugSourceInfo *sinfo = (MonoDebugSourceInfo *)g_ptr_array_index (source_file_list, source_files [i]);
8986                                 srcfile = sinfo->source_file;
8987                         }
8988                         DEBUG_PRINTF (10, "IL%x -> %s:%d %d %d %d\n", sp->il_offset, srcfile, sp->line, sp->column, sp->end_line, sp->end_column);
8989                         buffer_add_int (buf, sp->il_offset);
8990                         buffer_add_int (buf, sp->line);
8991                         if (CHECK_PROTOCOL_VERSION (2, 13))
8992                                 buffer_add_int (buf, source_files [i]);
8993                         if (CHECK_PROTOCOL_VERSION (2, 19))
8994                                 buffer_add_int (buf, sp->column);
8995                         if (CHECK_PROTOCOL_VERSION (2, 32)) {
8996                                 buffer_add_int (buf, sp->end_line);
8997                                 buffer_add_int (buf, sp->end_column);
8998                         }
8999                 }
9000                 g_free (source_file);
9001                 g_free (source_files);
9002                 g_free (sym_seq_points);
9003                 g_ptr_array_free (source_file_list, TRUE);
9004                 mono_metadata_free_mh (header);
9005                 break;
9006         }
9007         case CMD_METHOD_GET_PARAM_INFO: {
9008                 MonoMethodSignature *sig = mono_method_signature (method);
9009                 guint32 i;
9010                 char **names;
9011
9012                 /* FIXME: mono_class_from_mono_type () and byrefs */
9013
9014                 /* FIXME: Use a smaller encoding */
9015                 buffer_add_int (buf, sig->call_convention);
9016                 buffer_add_int (buf, sig->param_count);
9017                 buffer_add_int (buf, sig->generic_param_count);
9018                 buffer_add_typeid (buf, domain, mono_class_from_mono_type (sig->ret));
9019                 for (i = 0; i < sig->param_count; ++i) {
9020                         /* FIXME: vararg */
9021                         buffer_add_typeid (buf, domain, mono_class_from_mono_type (sig->params [i]));
9022                 }
9023
9024                 /* Emit parameter names */
9025                 names = g_new (char *, sig->param_count);
9026                 mono_method_get_param_names (method, (const char **) names);
9027                 for (i = 0; i < sig->param_count; ++i)
9028                         buffer_add_string (buf, names [i]);
9029                 g_free (names);
9030
9031                 break;
9032         }
9033         case CMD_METHOD_GET_LOCALS_INFO: {
9034                 MonoError error;
9035                 int i, num_locals;
9036                 MonoDebugLocalsInfo *locals;
9037                 int *locals_map = NULL;
9038
9039                 header = mono_method_get_header_checked (method, &error);
9040                 if (!header) {
9041                         mono_error_cleanup (&error); /* FIXME don't swallow the error */
9042                         return ERR_INVALID_ARGUMENT;
9043                 }
9044
9045                 locals = mono_debug_lookup_locals (method);
9046                 if (!locals) {
9047                         if (CHECK_PROTOCOL_VERSION (2, 43)) {
9048                                 /* Scopes */
9049                                 buffer_add_int (buf, 1);
9050                                 buffer_add_int (buf, 0);
9051                                 buffer_add_int (buf, header->code_size);
9052                         }
9053                         buffer_add_int (buf, header->num_locals);
9054                         /* Types */
9055                         for (i = 0; i < header->num_locals; ++i) {
9056                                 buffer_add_typeid (buf, domain, mono_class_from_mono_type (header->locals [i]));
9057                         }
9058                         /* Names */
9059                         for (i = 0; i < header->num_locals; ++i) {
9060                                 char lname [128];
9061                                 sprintf (lname, "V_%d", i);
9062                                 buffer_add_string (buf, lname);
9063                         }
9064                         /* Scopes */
9065                         for (i = 0; i < header->num_locals; ++i) {
9066                                 buffer_add_int (buf, 0);
9067                                 buffer_add_int (buf, header->code_size);
9068                         }
9069                 } else {
9070                         if (CHECK_PROTOCOL_VERSION (2, 43)) {
9071                                 /* Scopes */
9072                                 buffer_add_int (buf, locals->num_blocks);
9073                                 int last_start = 0;
9074                                 for (i = 0; i < locals->num_blocks; ++i) {
9075                                         buffer_add_int (buf, locals->code_blocks [i].start_offset - last_start);
9076                                         buffer_add_int (buf, locals->code_blocks [i].end_offset - locals->code_blocks [i].start_offset);
9077                                         last_start = locals->code_blocks [i].start_offset;
9078                                 }
9079                         }
9080
9081                         num_locals = locals->num_locals;
9082                         buffer_add_int (buf, num_locals);
9083
9084                         /* Types */
9085                         for (i = 0; i < num_locals; ++i) {
9086                                 g_assert (locals->locals [i].index < header->num_locals);
9087                                 buffer_add_typeid (buf, domain, mono_class_from_mono_type (header->locals [locals->locals [i].index]));
9088                         }
9089                         /* Names */
9090                         for (i = 0; i < num_locals; ++i)
9091                                 buffer_add_string (buf, locals->locals [i].name);
9092                         /* Scopes */
9093                         for (i = 0; i < num_locals; ++i) {
9094                                 if (locals->locals [i].block) {
9095                                         buffer_add_int (buf, locals->locals [i].block->start_offset);
9096                                         buffer_add_int (buf, locals->locals [i].block->end_offset);
9097                                 } else {
9098                                         buffer_add_int (buf, 0);
9099                                         buffer_add_int (buf, header->code_size);
9100                                 }
9101                         }
9102                 }
9103                 mono_metadata_free_mh (header);
9104
9105                 if (locals)
9106                         mono_debug_free_locals (locals);
9107                 g_free (locals_map);
9108
9109                 break;
9110         }
9111         case CMD_METHOD_GET_INFO:
9112                 buffer_add_int (buf, method->flags);
9113                 buffer_add_int (buf, method->iflags);
9114                 buffer_add_int (buf, method->token);
9115                 if (CHECK_PROTOCOL_VERSION (2, 12)) {
9116                         guint8 attrs = 0;
9117                         if (method->is_generic)
9118                                 attrs |= (1 << 0);
9119                         if (mono_method_signature (method)->generic_param_count)
9120                                 attrs |= (1 << 1);
9121                         buffer_add_byte (buf, attrs);
9122                         if (method->is_generic || method->is_inflated) {
9123                                 MonoMethod *result;
9124
9125                                 if (method->is_generic) {
9126                                         result = method;
9127                                 } else {
9128                                         MonoMethodInflated *imethod = (MonoMethodInflated *)method;
9129
9130                                         result = imethod->declaring;
9131                                         if (imethod->context.class_inst) {
9132                                                 MonoClass *klass = ((MonoMethod *) imethod)->klass;
9133                                                 /*Generic methods gets the context of the GTD.*/
9134                                                 if (mono_class_get_context (klass)) {
9135                                                         MonoError error;
9136                                                         result = mono_class_inflate_generic_method_full_checked (result, klass, mono_class_get_context (klass), &error);
9137                                                         g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
9138                                                 }
9139                                         }
9140                                 }
9141
9142                                 buffer_add_methodid (buf, domain, result);
9143                         } else {
9144                                 buffer_add_id (buf, 0);
9145                         }
9146                         if (CHECK_PROTOCOL_VERSION (2, 15)) {
9147                                 if (mono_method_signature (method)->generic_param_count) {
9148                                         int count, i;
9149
9150                                         if (method->is_inflated) {
9151                                                 MonoGenericInst *inst = mono_method_get_context (method)->method_inst;
9152                                                 if (inst) {
9153                                                         count = inst->type_argc;
9154                                                         buffer_add_int (buf, count);
9155
9156                                                         for (i = 0; i < count; i++)
9157                                                                 buffer_add_typeid (buf, domain, mono_class_from_mono_type (inst->type_argv [i]));
9158                                                 } else {
9159                                                         buffer_add_int (buf, 0);
9160                                                 }
9161                                         } else if (method->is_generic) {
9162                                                 MonoGenericContainer *container = mono_method_get_generic_container (method);
9163
9164                                                 count = mono_method_signature (method)->generic_param_count;
9165                                                 buffer_add_int (buf, count);
9166                                                 for (i = 0; i < count; i++) {
9167                                                         MonoGenericParam *param = mono_generic_container_get_param (container, i);
9168                                                         MonoClass *pklass = mono_class_from_generic_parameter_internal (param);
9169                                                         buffer_add_typeid (buf, domain, pklass);
9170                                                 }
9171                                         } else {
9172                                                 buffer_add_int (buf, 0);
9173                                         }
9174                                 } else {
9175                                         buffer_add_int (buf, 0);
9176                                 }
9177                         }
9178                 }
9179                 break;
9180         case CMD_METHOD_GET_BODY: {
9181                 MonoError error;
9182                 int i;
9183
9184                 header = mono_method_get_header_checked (method, &error);
9185                 if (!header) {
9186                         mono_error_cleanup (&error); /* FIXME don't swallow the error */
9187                         buffer_add_int (buf, 0);
9188
9189                         if (CHECK_PROTOCOL_VERSION (2, 18))
9190                                 buffer_add_int (buf, 0);
9191                 } else {
9192                         buffer_add_int (buf, header->code_size);
9193                         for (i = 0; i < header->code_size; ++i)
9194                                 buffer_add_byte (buf, header->code [i]);
9195
9196                         if (CHECK_PROTOCOL_VERSION (2, 18)) {
9197                                 buffer_add_int (buf, header->num_clauses);
9198                                 for (i = 0; i < header->num_clauses; ++i) {
9199                                         MonoExceptionClause *clause = &header->clauses [i];
9200
9201                                         buffer_add_int (buf, clause->flags);
9202                                         buffer_add_int (buf, clause->try_offset);
9203                                         buffer_add_int (buf, clause->try_len);
9204                                         buffer_add_int (buf, clause->handler_offset);
9205                                         buffer_add_int (buf, clause->handler_len);
9206                                         if (clause->flags == MONO_EXCEPTION_CLAUSE_NONE)
9207                                                 buffer_add_typeid (buf, domain, clause->data.catch_class);
9208                                         else if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER)
9209                                                 buffer_add_int (buf, clause->data.filter_offset);
9210                                 }
9211                         }
9212
9213                         mono_metadata_free_mh (header);
9214                 }
9215
9216                 break;
9217         }
9218         case CMD_METHOD_RESOLVE_TOKEN: {
9219                 guint32 token = decode_int (p, &p, end);
9220
9221                 // FIXME: Generics
9222                 switch (mono_metadata_token_code (token)) {
9223                 case MONO_TOKEN_STRING: {
9224                         MonoError error;
9225                         MonoString *s;
9226                         char *s2;
9227
9228                         s = mono_ldstr_checked (domain, method->klass->image, mono_metadata_token_index (token), &error);
9229                         mono_error_assert_ok (&error); /* FIXME don't swallow the error */
9230
9231                         s2 = mono_string_to_utf8_checked (s, &error);
9232                         mono_error_assert_ok (&error);
9233
9234                         buffer_add_byte (buf, TOKEN_TYPE_STRING);
9235                         buffer_add_string (buf, s2);
9236                         g_free (s2);
9237                         break;
9238                 }
9239                 default: {
9240                         MonoError error;
9241                         gpointer val;
9242                         MonoClass *handle_class;
9243
9244                         if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD) {
9245                                 val = mono_method_get_wrapper_data (method, token);
9246                                 handle_class = (MonoClass *)mono_method_get_wrapper_data (method, token + 1);
9247
9248                                 if (handle_class == NULL) {
9249                                         // Can't figure out the token type
9250                                         buffer_add_byte (buf, TOKEN_TYPE_UNKNOWN);
9251                                         break;
9252                                 }
9253                         } else {
9254                                 val = mono_ldtoken_checked (method->klass->image, token, &handle_class, NULL, &error);
9255                                 if (!val)
9256                                         g_error ("Could not load token due to %s", mono_error_get_message (&error));
9257                         }
9258
9259                         if (handle_class == mono_defaults.typehandle_class) {
9260                                 buffer_add_byte (buf, TOKEN_TYPE_TYPE);
9261                                 if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
9262                                         buffer_add_typeid (buf, domain, (MonoClass *) val);
9263                                 else
9264                                         buffer_add_typeid (buf, domain, mono_class_from_mono_type ((MonoType*)val));
9265                         } else if (handle_class == mono_defaults.fieldhandle_class) {
9266                                 buffer_add_byte (buf, TOKEN_TYPE_FIELD);
9267                                 buffer_add_fieldid (buf, domain, (MonoClassField *)val);
9268                         } else if (handle_class == mono_defaults.methodhandle_class) {
9269                                 buffer_add_byte (buf, TOKEN_TYPE_METHOD);
9270                                 buffer_add_methodid (buf, domain, (MonoMethod *)val);
9271                         } else if (handle_class == mono_defaults.string_class) {
9272                                 char *s;
9273
9274                                 s = mono_string_to_utf8_checked ((MonoString *)val, &error);
9275                                 mono_error_assert_ok (&error);
9276                                 buffer_add_byte (buf, TOKEN_TYPE_STRING);
9277                                 buffer_add_string (buf, s);
9278                                 g_free (s);
9279                         } else {
9280                                 g_assert_not_reached ();
9281                         }
9282                         break;
9283                 }
9284                 }
9285                 break;
9286         }
9287         case CMD_METHOD_GET_CATTRS: {
9288                 MonoError error;
9289                 MonoClass *attr_klass;
9290                 MonoCustomAttrInfo *cinfo;
9291
9292                 attr_klass = decode_typeid (p, &p, end, NULL, &err);
9293                 /* attr_klass can be NULL */
9294                 if (err != ERR_NONE)
9295                         return err;
9296
9297                 cinfo = mono_custom_attrs_from_method_checked (method, &error);
9298                 if (!is_ok (&error)) {
9299                         mono_error_cleanup (&error); /* FIXME don't swallow the error message */
9300                         return ERR_LOADER_ERROR;
9301                 }
9302
9303                 err = buffer_add_cattrs (buf, domain, method->klass->image, attr_klass, cinfo);
9304                 if (err != ERR_NONE)
9305                         return err;
9306                 break;
9307         }
9308         case CMD_METHOD_MAKE_GENERIC_METHOD: {
9309                 MonoError error;
9310                 MonoType **type_argv;
9311                 int i, type_argc;
9312                 MonoDomain *d;
9313                 MonoClass *klass;
9314                 MonoGenericInst *ginst;
9315                 MonoGenericContext tmp_context;
9316                 MonoMethod *inflated;
9317
9318                 type_argc = decode_int (p, &p, end);
9319                 type_argv = g_new0 (MonoType*, type_argc);
9320                 for (i = 0; i < type_argc; ++i) {
9321                         klass = decode_typeid (p, &p, end, &d, &err);
9322                         if (err != ERR_NONE) {
9323                                 g_free (type_argv);
9324                                 return err;
9325                         }
9326                         if (domain != d) {
9327                                 g_free (type_argv);
9328                                 return ERR_INVALID_ARGUMENT;
9329                         }
9330                         type_argv [i] = &klass->byval_arg;
9331                 }
9332                 ginst = mono_metadata_get_generic_inst (type_argc, type_argv);
9333                 g_free (type_argv);
9334                 tmp_context.class_inst = mono_class_is_ginst (method->klass) ? mono_class_get_generic_class (method->klass)->context.class_inst : NULL;
9335                 tmp_context.method_inst = ginst;
9336
9337                 inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, &error);
9338                 g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
9339                 if (!mono_verifier_is_method_valid_generic_instantiation (inflated))
9340                         return ERR_INVALID_ARGUMENT;
9341                 buffer_add_methodid (buf, domain, inflated);
9342                 break;
9343         }
9344         default:
9345                 return ERR_NOT_IMPLEMENTED;
9346         }
9347
9348         return ERR_NONE;
9349 }
9350
9351 static ErrorCode
9352 method_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
9353 {
9354         ErrorCode err;
9355         MonoDomain *old_domain;
9356         MonoDomain *domain;
9357         MonoMethod *method;
9358
9359         method = decode_methodid (p, &p, end, &domain, &err);
9360         if (err != ERR_NONE)
9361                 return err;
9362
9363         old_domain = mono_domain_get ();
9364
9365         mono_domain_set (domain, TRUE);
9366
9367         err = method_commands_internal (command, method, domain, p, end, buf);
9368
9369         mono_domain_set (old_domain, TRUE);
9370
9371         return err;
9372 }
9373
9374 static ErrorCode
9375 thread_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
9376 {
9377         int objid = decode_objid (p, &p, end);
9378         ErrorCode err;
9379         MonoThread *thread_obj;
9380         MonoInternalThread *thread;
9381
9382         err = get_object (objid, (MonoObject**)&thread_obj);
9383         if (err != ERR_NONE)
9384                 return err;
9385
9386         thread = THREAD_TO_INTERNAL (thread_obj);
9387
9388         switch (command) {
9389         case CMD_THREAD_GET_NAME: {
9390                 guint32 name_len;
9391                 gunichar2 *s = mono_thread_get_name (thread, &name_len);
9392
9393                 if (!s) {
9394                         buffer_add_int (buf, 0);
9395                 } else {
9396                         char *name;
9397                         glong len;
9398
9399                         name = g_utf16_to_utf8 (s, name_len, NULL, &len, NULL);
9400                         g_assert (name);
9401                         buffer_add_int (buf, len);
9402                         buffer_add_data (buf, (guint8*)name, len);
9403                         g_free (s);
9404                 }
9405                 break;
9406         }
9407         case CMD_THREAD_GET_FRAME_INFO: {
9408                 DebuggerTlsData *tls;
9409                 int i, start_frame, length;
9410
9411                 // Wait for suspending if it already started
9412                 // FIXME: Races with suspend_count
9413                 while (!is_suspended ()) {
9414                         if (suspend_count)
9415                                 wait_for_suspend ();
9416                 }
9417                 /*
9418                 if (suspend_count)
9419                         wait_for_suspend ();
9420                 if (!is_suspended ())
9421                         return ERR_NOT_SUSPENDED;
9422                 */
9423
9424                 start_frame = decode_int (p, &p, end);
9425                 length = decode_int (p, &p, end);
9426
9427                 if (start_frame != 0 || length != -1)
9428                         return ERR_NOT_IMPLEMENTED;
9429
9430                 mono_loader_lock ();
9431                 tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
9432                 mono_loader_unlock ();
9433                 g_assert (tls);
9434
9435                 compute_frame_info (thread, tls);
9436
9437                 buffer_add_int (buf, tls->frame_count);
9438                 for (i = 0; i < tls->frame_count; ++i) {
9439                         buffer_add_int (buf, tls->frames [i]->id);
9440                         buffer_add_methodid (buf, tls->frames [i]->domain, tls->frames [i]->actual_method);
9441                         buffer_add_int (buf, tls->frames [i]->il_offset);
9442                         /*
9443                          * Instead of passing the frame type directly to the client, we associate
9444                          * it with the previous frame using a set of flags. This avoids lots of
9445                          * conditional code in the client, since a frame whose type isn't
9446                          * FRAME_TYPE_MANAGED has no method, location, etc.
9447                          */
9448                         buffer_add_byte (buf, tls->frames [i]->flags);
9449                 }
9450
9451                 break;
9452         }
9453         case CMD_THREAD_GET_STATE:
9454                 buffer_add_int (buf, thread->state);
9455                 break;
9456         case CMD_THREAD_GET_INFO:
9457                 buffer_add_byte (buf, thread->threadpool_thread);
9458                 break;
9459         case CMD_THREAD_GET_ID:
9460                 buffer_add_long (buf, (guint64)(gsize)thread);
9461                 break;
9462         case CMD_THREAD_GET_TID:
9463                 buffer_add_long (buf, (guint64)thread->tid);
9464                 break;
9465         case CMD_THREAD_SET_IP: {
9466                 DebuggerTlsData *tls;
9467                 MonoMethod *method;
9468                 MonoDomain *domain;
9469                 MonoSeqPointInfo *seq_points;
9470                 SeqPoint sp;
9471                 gboolean found_sp;
9472                 gint64 il_offset;
9473
9474                 method = decode_methodid (p, &p, end, &domain, &err);
9475                 if (err != ERR_NONE)
9476                         return err;
9477                 il_offset = decode_long (p, &p, end);
9478
9479                 while (!is_suspended ()) {
9480                         if (suspend_count)
9481                                 wait_for_suspend ();
9482                 }
9483
9484                 mono_loader_lock ();
9485                 tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
9486                 mono_loader_unlock ();
9487                 g_assert (tls);
9488
9489                 compute_frame_info (thread, tls);
9490                 if (tls->frame_count == 0 || tls->frames [0]->actual_method != method)
9491                         return ERR_INVALID_ARGUMENT;
9492
9493                 found_sp = mono_find_seq_point (domain, method, il_offset, &seq_points, &sp);
9494
9495                 g_assert (seq_points);
9496
9497                 if (!found_sp)
9498                         return ERR_INVALID_ARGUMENT;
9499
9500                 // FIXME: Check that the ip change is safe
9501
9502                 DEBUG_PRINTF (1, "[dbg] Setting IP to %s:0x%0x(0x%0x)\n", tls->frames [0]->actual_method->name, (int)sp.il_offset, (int)sp.native_offset);
9503
9504                 if (tls->frames [0]->ji->is_interp) {
9505                         MonoJitTlsData *jit_data = ((MonoThreadInfo*)thread->thread_info)->jit_data;
9506                         mono_interp_set_resume_state (jit_data, NULL, tls->frames [0]->interp_frame, (guint8*)tls->frames [0]->ji->code_start + sp.native_offset);
9507                 } else {
9508                         MONO_CONTEXT_SET_IP (&tls->restore_state.ctx, (guint8*)tls->frames [0]->ji->code_start + sp.native_offset);
9509                 }
9510                 break;
9511         }
9512         default:
9513                 return ERR_NOT_IMPLEMENTED;
9514         }
9515
9516         return ERR_NONE;
9517 }
9518
9519 static ErrorCode
9520 frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
9521 {
9522         int objid;
9523         ErrorCode err;
9524         MonoThread *thread_obj;
9525         MonoInternalThread *thread;
9526         int pos, i, len, frame_idx;
9527         DebuggerTlsData *tls;
9528         StackFrame *frame;
9529         MonoDebugMethodJitInfo *jit;
9530         MonoMethodSignature *sig;
9531         gssize id;
9532         MonoMethodHeader *header;
9533
9534         objid = decode_objid (p, &p, end);
9535         err = get_object (objid, (MonoObject**)&thread_obj);
9536         if (err != ERR_NONE)
9537                 return err;
9538
9539         thread = THREAD_TO_INTERNAL (thread_obj);
9540
9541         id = decode_id (p, &p, end);
9542
9543         mono_loader_lock ();
9544         tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread);
9545         mono_loader_unlock ();
9546         g_assert (tls);
9547
9548         for (i = 0; i < tls->frame_count; ++i) {
9549                 if (tls->frames [i]->id == id)
9550                         break;
9551         }
9552         if (i == tls->frame_count)
9553                 return ERR_INVALID_FRAMEID;
9554
9555         frame_idx = i;
9556         frame = tls->frames [frame_idx];
9557
9558         /* This is supported for frames without has_ctx etc. set */
9559         if (command == CMD_STACK_FRAME_GET_DOMAIN) {
9560                 if (CHECK_PROTOCOL_VERSION (2, 38))
9561                         buffer_add_domainid (buf, frame->domain);
9562                 return ERR_NONE;
9563         }
9564
9565         if (!frame->has_ctx)
9566                 return ERR_ABSENT_INFORMATION;
9567
9568         if (!ensure_jit (frame))
9569                 return ERR_ABSENT_INFORMATION;
9570
9571         jit = frame->jit;
9572
9573         sig = mono_method_signature (frame->actual_method);
9574
9575         if (!(jit->has_var_info || frame->ji->is_interp) || !mono_get_seq_points (frame->domain, frame->actual_method))
9576                 /*
9577                  * The method is probably from an aot image compiled without soft-debug, variables might be dead, etc.
9578                  */
9579                 return ERR_ABSENT_INFORMATION;
9580
9581         switch (command) {
9582         case CMD_STACK_FRAME_GET_VALUES: {
9583                 MonoError error;
9584                 len = decode_int (p, &p, end);
9585                 header = mono_method_get_header_checked (frame->actual_method, &error);
9586                 mono_error_assert_ok (&error); /* FIXME report error */
9587
9588                 for (i = 0; i < len; ++i) {
9589                         pos = decode_int (p, &p, end);
9590
9591                         if (pos < 0) {
9592                                 pos = - pos - 1;
9593
9594                                 DEBUG_PRINTF (4, "[dbg]   send arg %d.\n", pos);
9595
9596                                 if (frame->ji->is_interp) {
9597                                         guint8 *addr;
9598
9599                                         addr = mono_interp_frame_get_arg (frame->interp_frame, pos);
9600
9601                                         buffer_add_value_full (buf, sig->params [pos], addr, frame->domain, FALSE, NULL);
9602                                 } else {
9603                                         g_assert (pos >= 0 && pos < jit->num_params);
9604
9605                                         add_var (buf, jit, sig->params [pos], &jit->params [pos], &frame->ctx, frame->domain, FALSE);
9606                                 }
9607                         } else {
9608                                 MonoDebugLocalsInfo *locals;
9609
9610                                 locals = mono_debug_lookup_locals (frame->method);
9611                                 if (locals) {
9612                                         g_assert (pos < locals->num_locals);
9613                                         pos = locals->locals [pos].index;
9614                                         mono_debug_free_locals (locals);
9615                                 }
9616
9617                                 DEBUG_PRINTF (4, "[dbg]   send local %d.\n", pos);
9618
9619                                 if (frame->ji->is_interp) {
9620                                         guint8 *addr;
9621
9622                                         addr = mono_interp_frame_get_local (frame->interp_frame, pos);
9623
9624                                         buffer_add_value_full (buf, header->locals [pos], addr, frame->domain, FALSE, NULL);
9625                                 } else {
9626                                         g_assert (pos >= 0 && pos < jit->num_locals);
9627
9628                                         add_var (buf, jit, header->locals [pos], &jit->locals [pos], &frame->ctx, frame->domain, FALSE);
9629                                 }
9630                         }
9631                 }
9632                 mono_metadata_free_mh (header);
9633                 break;
9634         }
9635         case CMD_STACK_FRAME_GET_THIS: {
9636                 if (frame->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE)
9637                         return ERR_ABSENT_INFORMATION;
9638                 if (frame->api_method->klass->valuetype) {
9639                         if (!sig->hasthis) {
9640                                 MonoObject *p = NULL;
9641                                 buffer_add_value (buf, &mono_defaults.object_class->byval_arg, &p, frame->domain);
9642                         } else {
9643                                 if (frame->ji->is_interp) {
9644                                         guint8 *addr;
9645
9646                                         addr = mono_interp_frame_get_this (frame->interp_frame);
9647
9648                                         buffer_add_value_full (buf, &frame->actual_method->klass->this_arg, addr, frame->domain, FALSE, NULL);
9649                                 } else {
9650                                         add_var (buf, jit, &frame->actual_method->klass->this_arg, jit->this_var, &frame->ctx, frame->domain, TRUE);
9651                                 }
9652                         }
9653                 } else {
9654                         if (!sig->hasthis) {
9655                                 MonoObject *p = NULL;
9656                                 buffer_add_value (buf, &frame->actual_method->klass->byval_arg, &p, frame->domain);
9657                         } else {
9658                                 if (frame->ji->is_interp) {
9659                                         guint8 *addr;
9660
9661                                         addr = mono_interp_frame_get_this (frame->interp_frame);
9662
9663                                         buffer_add_value_full (buf, &frame->api_method->klass->byval_arg, addr, frame->domain, FALSE, NULL);
9664                                 } else {
9665                                         add_var (buf, jit, &frame->api_method->klass->byval_arg, jit->this_var, &frame->ctx, frame->domain, TRUE);
9666                                 }
9667                         }
9668                 }
9669                 break;
9670         }
9671         case CMD_STACK_FRAME_SET_VALUES: {
9672                 MonoError error;
9673                 guint8 *val_buf;
9674                 MonoType *t;
9675                 MonoDebugVarInfo *var = NULL;
9676                 gboolean is_arg = FALSE;
9677
9678                 len = decode_int (p, &p, end);
9679                 header = mono_method_get_header_checked (frame->actual_method, &error);
9680                 mono_error_assert_ok (&error); /* FIXME report error */
9681
9682                 for (i = 0; i < len; ++i) {
9683                         pos = decode_int (p, &p, end);
9684
9685                         if (pos < 0) {
9686                                 pos = - pos - 1;
9687
9688                                 g_assert (pos >= 0 && pos < jit->num_params);
9689
9690                                 t = sig->params [pos];
9691                                 var = &jit->params [pos];
9692                                 is_arg = TRUE;
9693                         } else {
9694                                 MonoDebugLocalsInfo *locals;
9695
9696                                 locals = mono_debug_lookup_locals (frame->method);
9697                                 if (locals) {
9698                                         g_assert (pos < locals->num_locals);
9699                                         pos = locals->locals [pos].index;
9700                                         mono_debug_free_locals (locals);
9701                                 }
9702                                 g_assert (pos >= 0 && pos < jit->num_locals);
9703
9704                                 t = header->locals [pos];
9705                                 var = &jit->locals [pos];
9706                         }
9707
9708                         if (MONO_TYPE_IS_REFERENCE (t))
9709                                 val_buf = (guint8 *)g_alloca (sizeof (MonoObject*));
9710                         else
9711                                 val_buf = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type (t)));
9712                         err = decode_value (t, frame->domain, val_buf, p, &p, end);
9713                         if (err != ERR_NONE)
9714                                 return err;
9715
9716                         if (frame->ji->is_interp) {
9717                                 guint8 *addr;
9718
9719                                 if (is_arg)
9720                                         addr = mono_interp_frame_get_arg (frame->interp_frame, pos);
9721                                 else
9722                                         addr = mono_interp_frame_get_local (frame->interp_frame, pos);
9723                                 set_interp_var (t, addr, val_buf);
9724                         } else {
9725                                 set_var (t, var, &frame->ctx, frame->domain, val_buf, frame->reg_locations, &tls->restore_state.ctx);
9726                         }
9727                 }
9728                 mono_metadata_free_mh (header);
9729                 break;
9730         }
9731         case CMD_STACK_FRAME_GET_DOMAIN: {
9732                 if (CHECK_PROTOCOL_VERSION (2, 38))
9733                         buffer_add_domainid (buf, frame->domain);
9734                 break;
9735         }
9736         case CMD_STACK_FRAME_SET_THIS: {
9737                 guint8 *val_buf;
9738                 MonoType *t;
9739                 MonoDebugVarInfo *var;
9740
9741                 t = &frame->actual_method->klass->byval_arg;
9742                 /* Checked by the sender */
9743                 g_assert (MONO_TYPE_ISSTRUCT (t));
9744
9745                 val_buf = (guint8 *)g_alloca (mono_class_instance_size (mono_class_from_mono_type (t)));
9746                 err = decode_value (t, frame->domain, val_buf, p, &p, end);
9747                 if (err != ERR_NONE)
9748                         return err;
9749
9750                 if (frame->ji->is_interp) {
9751                         guint8 *addr;
9752
9753                         addr = mono_interp_frame_get_this (frame->interp_frame);
9754                         set_interp_var (&frame->actual_method->klass->this_arg, addr, val_buf);
9755                 } else {
9756                         var = jit->this_var;
9757                         g_assert (var);
9758
9759                         set_var (&frame->actual_method->klass->this_arg, var, &frame->ctx, frame->domain, val_buf, frame->reg_locations, &tls->restore_state.ctx);
9760                 }
9761                 break;
9762         }
9763         default:
9764                 return ERR_NOT_IMPLEMENTED;
9765         }
9766
9767         return ERR_NONE;
9768 }
9769
9770 static ErrorCode
9771 array_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
9772 {
9773         MonoArray *arr;
9774         int objid, index, len, i, esize;
9775         ErrorCode err;
9776         gpointer elem;
9777
9778         objid = decode_objid (p, &p, end);
9779         err = get_object (objid, (MonoObject**)&arr);
9780         if (err != ERR_NONE)
9781                 return err;
9782
9783         switch (command) {
9784         case CMD_ARRAY_REF_GET_LENGTH:
9785                 buffer_add_int (buf, arr->obj.vtable->klass->rank);
9786                 if (!arr->bounds) {
9787                         buffer_add_int (buf, arr->max_length);
9788                         buffer_add_int (buf, 0);
9789                 } else {
9790                         for (i = 0; i < arr->obj.vtable->klass->rank; ++i) {
9791                                 buffer_add_int (buf, arr->bounds [i].length);
9792                                 buffer_add_int (buf, arr->bounds [i].lower_bound);
9793                         }
9794                 }
9795                 break;
9796         case CMD_ARRAY_REF_GET_VALUES:
9797                 index = decode_int (p, &p, end);
9798                 len = decode_int (p, &p, end);
9799
9800                 g_assert (index >= 0 && len >= 0);
9801                 // Reordered to avoid integer overflow
9802                 g_assert (!(index > arr->max_length - len));
9803
9804                 esize = mono_array_element_size (arr->obj.vtable->klass);
9805                 for (i = index; i < index + len; ++i) {
9806                         elem = (gpointer*)((char*)arr->vector + (i * esize));
9807                         buffer_add_value (buf, &arr->obj.vtable->klass->element_class->byval_arg, elem, arr->obj.vtable->domain);
9808                 }
9809                 break;
9810         case CMD_ARRAY_REF_SET_VALUES:
9811                 index = decode_int (p, &p, end);
9812                 len = decode_int (p, &p, end);
9813
9814                 g_assert (index >= 0 && len >= 0);
9815                 // Reordered to avoid integer overflow
9816                 g_assert (!(index > arr->max_length - len));
9817
9818                 esize = mono_array_element_size (arr->obj.vtable->klass);
9819                 for (i = index; i < index + len; ++i) {
9820                         elem = (gpointer*)((char*)arr->vector + (i * esize));
9821
9822                         decode_value (&arr->obj.vtable->klass->element_class->byval_arg, arr->obj.vtable->domain, (guint8 *)elem, p, &p, end);
9823                 }
9824                 break;
9825         default:
9826                 return ERR_NOT_IMPLEMENTED;
9827         }
9828
9829         return ERR_NONE;
9830 }
9831
9832 static ErrorCode
9833 string_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
9834 {
9835         int objid;
9836         ErrorCode err;
9837         MonoString *str;
9838         char *s;
9839         int i, index, length;
9840         gunichar2 *c;
9841         gboolean use_utf16 = FALSE;
9842
9843         objid = decode_objid (p, &p, end);
9844         err = get_object (objid, (MonoObject**)&str);
9845         if (err != ERR_NONE)
9846                 return err;
9847
9848         switch (command) {
9849         case CMD_STRING_REF_GET_VALUE:
9850                 if (CHECK_PROTOCOL_VERSION (2, 41)) {
9851                         for (i = 0; i < mono_string_length (str); ++i)
9852                                 if (mono_string_chars (str)[i] == 0)
9853                                         use_utf16 = TRUE;
9854                         buffer_add_byte (buf, use_utf16 ? 1 : 0);
9855                 }
9856                 if (use_utf16) {
9857                         buffer_add_int (buf, mono_string_length (str) * 2);
9858                         buffer_add_data (buf, (guint8*)mono_string_chars (str), mono_string_length (str) * 2);
9859                 } else {
9860                         MonoError error;
9861                         s = mono_string_to_utf8_checked (str, &error);
9862                         mono_error_assert_ok (&error);
9863                         buffer_add_string (buf, s);
9864                         g_free (s);
9865                 }
9866                 break;
9867         case CMD_STRING_REF_GET_LENGTH:
9868                 buffer_add_long (buf, mono_string_length (str));
9869                 break;
9870         case CMD_STRING_REF_GET_CHARS:
9871                 index = decode_long (p, &p, end);
9872                 length = decode_long (p, &p, end);
9873                 if (index > mono_string_length (str) - length)
9874                         return ERR_INVALID_ARGUMENT;
9875                 c = mono_string_chars (str) + index;
9876                 for (i = 0; i < length; ++i)
9877                         buffer_add_short (buf, c [i]);
9878                 break;
9879         default:
9880                 return ERR_NOT_IMPLEMENTED;
9881         }
9882
9883         return ERR_NONE;
9884 }
9885
9886 static ErrorCode
9887 object_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
9888 {
9889         MonoError error;
9890         int objid;
9891         ErrorCode err;
9892         MonoObject *obj;
9893         int len, i;
9894         MonoClassField *f;
9895         MonoClass *k;
9896         gboolean found;
9897
9898         if (command == CMD_OBJECT_REF_IS_COLLECTED) {
9899                 objid = decode_objid (p, &p, end);
9900                 err = get_object (objid, &obj);
9901                 if (err != ERR_NONE)
9902                         buffer_add_int (buf, 1);
9903                 else
9904                         buffer_add_int (buf, 0);
9905                 return ERR_NONE;
9906         }
9907
9908         objid = decode_objid (p, &p, end);
9909         err = get_object (objid, &obj);
9910         if (err != ERR_NONE)
9911                 return err;
9912
9913         MonoClass *obj_type;
9914         gboolean remote_obj = FALSE;
9915
9916         obj_type = obj->vtable->klass;
9917         if (mono_class_is_transparent_proxy (obj_type)) {
9918                 obj_type = ((MonoTransparentProxy *)obj)->remote_class->proxy_class;
9919                 remote_obj = TRUE;
9920         }
9921
9922         g_assert (obj_type);
9923
9924         switch (command) {
9925         case CMD_OBJECT_REF_GET_TYPE:
9926                 /* This handles transparent proxies too */
9927                 buffer_add_typeid (buf, obj->vtable->domain, mono_class_from_mono_type (((MonoReflectionType*)obj->vtable->type)->type));
9928                 break;
9929         case CMD_OBJECT_REF_GET_VALUES:
9930                 len = decode_int (p, &p, end);
9931
9932                 for (i = 0; i < len; ++i) {
9933                         MonoClassField *f = decode_fieldid (p, &p, end, NULL, &err);
9934                         if (err != ERR_NONE)
9935                                 return err;
9936
9937                         /* Check that the field belongs to the object */
9938                         found = FALSE;
9939                         for (k = obj_type; k; k = k->parent) {
9940                                 if (k == f->parent) {
9941                                         found = TRUE;
9942                                         break;
9943                                 }
9944                         }
9945                         if (!found)
9946                                 return ERR_INVALID_FIELDID;
9947
9948                         if (f->type->attrs & FIELD_ATTRIBUTE_STATIC) {
9949                                 guint8 *val;
9950                                 MonoVTable *vtable;
9951
9952                                 if (mono_class_field_is_special_static (f))
9953                                         return ERR_INVALID_FIELDID;
9954
9955                                 g_assert (f->type->attrs & FIELD_ATTRIBUTE_STATIC);
9956                                 vtable = mono_class_vtable (obj->vtable->domain, f->parent);
9957                                 val = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
9958                                 mono_field_static_get_value_checked (vtable, f, val, &error);
9959                                 if (!is_ok (&error)) {
9960                                         mono_error_cleanup (&error); /* FIXME report the error */
9961                                         return ERR_INVALID_OBJECT;
9962                                 }
9963                                 buffer_add_value (buf, f->type, val, obj->vtable->domain);
9964                                 g_free (val);
9965                         } else {
9966                                 guint8 *field_value = NULL;
9967
9968                                 if (remote_obj) {
9969 #ifndef DISABLE_REMOTING
9970                                         void *field_storage = NULL;
9971                                         field_value = mono_load_remote_field_checked(obj, obj_type, f, &field_storage, &error);
9972                                         if (!is_ok (&error)) {
9973                                                 mono_error_cleanup (&error); /* FIXME report the error */
9974                                                 return ERR_INVALID_OBJECT;
9975                                         }
9976 #else
9977                                         g_assert_not_reached ();
9978 #endif
9979                                 } else
9980                                         field_value = (guint8*)obj + f->offset;
9981
9982                                 buffer_add_value (buf, f->type, field_value, obj->vtable->domain);
9983                         }
9984                 }
9985                 break;
9986         case CMD_OBJECT_REF_SET_VALUES:
9987                 len = decode_int (p, &p, end);
9988
9989                 for (i = 0; i < len; ++i) {
9990                         f = decode_fieldid (p, &p, end, NULL, &err);
9991                         if (err != ERR_NONE)
9992                                 return err;
9993
9994                         /* Check that the field belongs to the object */
9995                         found = FALSE;
9996                         for (k = obj_type; k; k = k->parent) {
9997                                 if (k == f->parent) {
9998                                         found = TRUE;
9999                                         break;
10000                                 }
10001                         }
10002                         if (!found)
10003                                 return ERR_INVALID_FIELDID;
10004
10005                         if (f->type->attrs & FIELD_ATTRIBUTE_STATIC) {
10006                                 guint8 *val;
10007                                 MonoVTable *vtable;
10008
10009                                 if (mono_class_field_is_special_static (f))
10010                                         return ERR_INVALID_FIELDID;
10011
10012                                 g_assert (f->type->attrs & FIELD_ATTRIBUTE_STATIC);
10013                                 vtable = mono_class_vtable (obj->vtable->domain, f->parent);
10014
10015                                 val = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
10016                                 err = decode_value (f->type, obj->vtable->domain, val, p, &p, end);
10017                                 if (err != ERR_NONE) {
10018                                         g_free (val);
10019                                         return err;
10020                                 }
10021                                 mono_field_static_set_value (vtable, f, val);
10022                                 g_free (val);
10023                         } else {
10024                                 err = decode_value (f->type, obj->vtable->domain, (guint8*)obj + f->offset, p, &p, end);
10025                                 if (err != ERR_NONE)
10026                                         return err;
10027                         }
10028                 }
10029                 break;
10030         case CMD_OBJECT_REF_GET_ADDRESS:
10031                 buffer_add_long (buf, (gssize)obj);
10032                 break;
10033         case CMD_OBJECT_REF_GET_DOMAIN:
10034                 buffer_add_domainid (buf, obj->vtable->domain);
10035                 break;
10036         case CMD_OBJECT_REF_GET_INFO:
10037                 buffer_add_typeid (buf, obj->vtable->domain, mono_class_from_mono_type (((MonoReflectionType*)obj->vtable->type)->type));
10038                 buffer_add_domainid (buf, obj->vtable->domain);
10039                 break;
10040         default:
10041                 return ERR_NOT_IMPLEMENTED;
10042         }
10043
10044         return ERR_NONE;
10045 }
10046
10047 static const char*
10048 command_set_to_string (CommandSet command_set)
10049 {
10050         switch (command_set) {
10051         case CMD_SET_VM:
10052                 return "VM";
10053         case CMD_SET_OBJECT_REF:
10054                 return "OBJECT_REF";
10055         case CMD_SET_STRING_REF:
10056                 return "STRING_REF";
10057         case CMD_SET_THREAD:
10058                 return "THREAD";
10059         case CMD_SET_ARRAY_REF:
10060                 return "ARRAY_REF";
10061         case CMD_SET_EVENT_REQUEST:
10062                 return "EVENT_REQUEST";
10063         case CMD_SET_STACK_FRAME:
10064                 return "STACK_FRAME";
10065         case CMD_SET_APPDOMAIN:
10066                 return "APPDOMAIN";
10067         case CMD_SET_ASSEMBLY:
10068                 return "ASSEMBLY";
10069         case CMD_SET_METHOD:
10070                 return "METHOD";
10071         case CMD_SET_TYPE:
10072                 return "TYPE";
10073         case CMD_SET_MODULE:
10074                 return "MODULE";
10075         case CMD_SET_FIELD:
10076                 return "FIELD";
10077         case CMD_SET_EVENT:
10078                 return "EVENT";
10079         default:
10080                 return "";
10081         }
10082 }
10083
10084 static const char* vm_cmds_str [] = {
10085         "VERSION",
10086         "ALL_THREADS",
10087         "SUSPEND",
10088         "RESUME",
10089         "EXIT",
10090         "DISPOSE",
10091         "INVOKE_METHOD",
10092         "SET_PROTOCOL_VERSION",
10093         "ABORT_INVOKE",
10094         "SET_KEEPALIVE"
10095         "GET_TYPES_FOR_SOURCE_FILE",
10096         "GET_TYPES",
10097         "INVOKE_METHODS"
10098 };
10099
10100 static const char* thread_cmds_str[] = {
10101         "GET_FRAME_INFO",
10102         "GET_NAME",
10103         "GET_STATE",
10104         "GET_INFO",
10105         "GET_ID",
10106         "GET_TID",
10107         "SET_IP"
10108 };
10109
10110 static const char* event_cmds_str[] = {
10111         "REQUEST_SET",
10112         "REQUEST_CLEAR",
10113         "REQUEST_CLEAR_ALL_BREAKPOINTS"
10114 };
10115
10116 static const char* appdomain_cmds_str[] = {
10117         "GET_ROOT_DOMAIN",
10118         "GET_FRIENDLY_NAME",
10119         "GET_ASSEMBLIES",
10120         "GET_ENTRY_ASSEMBLY",
10121         "CREATE_STRING",
10122         "GET_CORLIB",
10123         "CREATE_BOXED_VALUE"
10124 };
10125
10126 static const char* assembly_cmds_str[] = {
10127         "GET_LOCATION",
10128         "GET_ENTRY_POINT",
10129         "GET_MANIFEST_MODULE",
10130         "GET_OBJECT",
10131         "GET_TYPE",
10132         "GET_NAME",
10133         "GET_DOMAIN"
10134 };
10135
10136 static const char* module_cmds_str[] = {
10137         "GET_INFO",
10138 };
10139
10140 static const char* field_cmds_str[] = {
10141         "GET_INFO",
10142 };
10143
10144 static const char* method_cmds_str[] = {
10145         "GET_NAME",
10146         "GET_DECLARING_TYPE",
10147         "GET_DEBUG_INFO",
10148         "GET_PARAM_INFO",
10149         "GET_LOCALS_INFO",
10150         "GET_INFO",
10151         "GET_BODY",
10152         "RESOLVE_TOKEN",
10153         "GET_CATTRS ",
10154         "MAKE_GENERIC_METHOD"
10155 };
10156
10157 static const char* type_cmds_str[] = {
10158         "GET_INFO",
10159         "GET_METHODS",
10160         "GET_FIELDS",
10161         "GET_VALUES",
10162         "GET_OBJECT",
10163         "GET_SOURCE_FILES",
10164         "SET_VALUES",
10165         "IS_ASSIGNABLE_FROM",
10166         "GET_PROPERTIES ",
10167         "GET_CATTRS",
10168         "GET_FIELD_CATTRS",
10169         "GET_PROPERTY_CATTRS",
10170         "GET_SOURCE_FILES_2",
10171         "GET_VALUES_2",
10172         "GET_METHODS_BY_NAME_FLAGS",
10173         "GET_INTERFACES",
10174         "GET_INTERFACE_MAP",
10175         "IS_INITIALIZED"
10176 };
10177
10178 static const char* stack_frame_cmds_str[] = {
10179         "GET_VALUES",
10180         "GET_THIS",
10181         "SET_VALUES",
10182         "GET_DOMAIN",
10183         "SET_THIS"
10184 };
10185
10186 static const char* array_cmds_str[] = {
10187         "GET_LENGTH",
10188         "GET_VALUES",
10189         "SET_VALUES",
10190 };
10191
10192 static const char* string_cmds_str[] = {
10193         "GET_VALUE",
10194         "GET_LENGTH",
10195         "GET_CHARS"
10196 };
10197
10198 static const char* object_cmds_str[] = {
10199         "GET_TYPE",
10200         "GET_VALUES",
10201         "IS_COLLECTED",
10202         "GET_ADDRESS",
10203         "GET_DOMAIN",
10204         "SET_VALUES",
10205         "GET_INFO",
10206 };
10207
10208 static const char*
10209 cmd_to_string (CommandSet set, int command)
10210 {
10211         const char **cmds;
10212         int cmds_len = 0;
10213
10214         switch (set) {
10215         case CMD_SET_VM:
10216                 cmds = vm_cmds_str;
10217                 cmds_len = G_N_ELEMENTS (vm_cmds_str);
10218                 break;
10219         case CMD_SET_OBJECT_REF:
10220                 cmds = object_cmds_str;
10221                 cmds_len = G_N_ELEMENTS (object_cmds_str);
10222                 break;
10223         case CMD_SET_STRING_REF:
10224                 cmds = string_cmds_str;
10225                 cmds_len = G_N_ELEMENTS (string_cmds_str);
10226                 break;
10227         case CMD_SET_THREAD:
10228                 cmds = thread_cmds_str;
10229                 cmds_len = G_N_ELEMENTS (thread_cmds_str);
10230                 break;
10231         case CMD_SET_ARRAY_REF:
10232                 cmds = array_cmds_str;
10233                 cmds_len = G_N_ELEMENTS (array_cmds_str);
10234                 break;
10235         case CMD_SET_EVENT_REQUEST:
10236                 cmds = event_cmds_str;
10237                 cmds_len = G_N_ELEMENTS (event_cmds_str);
10238                 break;
10239         case CMD_SET_STACK_FRAME:
10240                 cmds = stack_frame_cmds_str;
10241                 cmds_len = G_N_ELEMENTS (stack_frame_cmds_str);
10242                 break;
10243         case CMD_SET_APPDOMAIN:
10244                 cmds = appdomain_cmds_str;
10245                 cmds_len = G_N_ELEMENTS (appdomain_cmds_str);
10246                 break;
10247         case CMD_SET_ASSEMBLY:
10248                 cmds = assembly_cmds_str;
10249                 cmds_len = G_N_ELEMENTS (assembly_cmds_str);
10250                 break;
10251         case CMD_SET_METHOD:
10252                 cmds = method_cmds_str;
10253                 cmds_len = G_N_ELEMENTS (method_cmds_str);
10254                 break;
10255         case CMD_SET_TYPE:
10256                 cmds = type_cmds_str;
10257                 cmds_len = G_N_ELEMENTS (type_cmds_str);
10258                 break;
10259         case CMD_SET_MODULE:
10260                 cmds = module_cmds_str;
10261                 cmds_len = G_N_ELEMENTS (module_cmds_str);
10262                 break;
10263         case CMD_SET_FIELD:
10264                 cmds = field_cmds_str;
10265                 cmds_len = G_N_ELEMENTS (field_cmds_str);
10266                 break;
10267         case CMD_SET_EVENT:
10268                 cmds = event_cmds_str;
10269                 cmds_len = G_N_ELEMENTS (event_cmds_str);
10270                 break;
10271         default:
10272                 return NULL;
10273         }
10274         if (command > 0 && command <= cmds_len)
10275                 return cmds [command - 1];
10276         else
10277                 return NULL;
10278 }
10279
10280 static gboolean
10281 wait_for_attach (void)
10282 {
10283 #ifndef DISABLE_SOCKET_TRANSPORT
10284         if (listen_fd == -1) {
10285                 DEBUG_PRINTF (1, "[dbg] Invalid listening socket\n");
10286                 return FALSE;
10287         }
10288
10289         /* Block and wait for client connection */
10290         conn_fd = socket_transport_accept (listen_fd);
10291
10292         DEBUG_PRINTF (1, "Accepted connection on %d\n", conn_fd);
10293         if (conn_fd == -1) {
10294                 DEBUG_PRINTF (1, "[dbg] Bad client connection\n");
10295                 return FALSE;
10296         }
10297 #else
10298         g_assert_not_reached ();
10299 #endif
10300
10301         /* Handshake */
10302         disconnected = !transport_handshake ();
10303         if (disconnected) {
10304                 DEBUG_PRINTF (1, "Transport handshake failed!\n");
10305                 return FALSE;
10306         }
10307
10308         return TRUE;
10309 }
10310
10311 /*
10312  * debugger_thread:
10313  *
10314  *   This thread handles communication with the debugger client using a JDWP
10315  * like protocol.
10316  */
10317 static gsize WINAPI
10318 debugger_thread (void *arg)
10319 {
10320         MonoError error;
10321         int res, len, id, flags, command = 0;
10322         CommandSet command_set = (CommandSet)0;
10323         guint8 header [HEADER_LENGTH];
10324         guint8 *data, *p, *end;
10325         Buffer buf;
10326         ErrorCode err;
10327         gboolean no_reply;
10328         gboolean attach_failed = FALSE;
10329
10330         DEBUG_PRINTF (1, "[dbg] Agent thread started, pid=%p\n", (gpointer) (gsize) mono_native_thread_id_get ());
10331
10332         debugger_thread_id = mono_native_thread_id_get ();
10333
10334         MonoInternalThread *internal = mono_thread_internal_current ();
10335         MonoString *str = mono_string_new_checked (mono_domain_get (), "Debugger agent", &error);
10336         mono_error_assert_ok (&error);
10337         mono_thread_set_name_internal (internal, str, TRUE, FALSE, &error);
10338         mono_error_assert_ok (&error);
10339
10340         internal->state |= ThreadState_Background;
10341         internal->flags |= MONO_THREAD_FLAG_DONT_MANAGE;
10342
10343         if (agent_config.defer) {
10344                 if (!wait_for_attach ()) {
10345                         DEBUG_PRINTF (1, "[dbg] Can't attach, aborting debugger thread.\n");
10346                         attach_failed = TRUE; // Don't abort process when we can't listen
10347                 } else {
10348                         mono_set_is_debugger_attached (TRUE);
10349                         /* Send start event to client */
10350                         process_profiler_event (EVENT_KIND_VM_START, mono_thread_get_main ());
10351                 }
10352         } else {
10353                 mono_set_is_debugger_attached (TRUE);
10354         }
10355
10356         while (!attach_failed) {
10357                 res = transport_recv (header, HEADER_LENGTH);
10358
10359                 /* This will break if the socket is closed during shutdown too */
10360                 if (res != HEADER_LENGTH) {
10361                         DEBUG_PRINTF (1, "[dbg] transport_recv () returned %d, expected %d.\n", res, HEADER_LENGTH);
10362                         break;
10363                 }
10364
10365                 p = header;
10366                 end = header + HEADER_LENGTH;
10367
10368                 len = decode_int (p, &p, end);
10369                 id = decode_int (p, &p, end);
10370                 flags = decode_byte (p, &p, end);
10371                 command_set = (CommandSet)decode_byte (p, &p, end);
10372                 command = decode_byte (p, &p, end);
10373
10374                 g_assert (flags == 0);
10375
10376                 if (log_level) {
10377                         const char *cmd_str;
10378                         char cmd_num [256];
10379
10380                         cmd_str = cmd_to_string (command_set, command);
10381                         if (!cmd_str) {
10382                                 sprintf (cmd_num, "%d", command);
10383                                 cmd_str = cmd_num;
10384                         }
10385
10386                         DEBUG_PRINTF (1, "[dbg] Command %s(%s) [%d][at=%lx].\n", command_set_to_string (command_set), cmd_str, id, (long)mono_100ns_ticks () / 10000);
10387                 }
10388
10389                 data = (guint8 *)g_malloc (len - HEADER_LENGTH);
10390                 if (len - HEADER_LENGTH > 0)
10391                 {
10392                         res = transport_recv (data, len - HEADER_LENGTH);
10393                         if (res != len - HEADER_LENGTH) {
10394                                 DEBUG_PRINTF (1, "[dbg] transport_recv () returned %d, expected %d.\n", res, len - HEADER_LENGTH);
10395                                 break;
10396                         }
10397                 }
10398
10399                 p = data;
10400                 end = data + (len - HEADER_LENGTH);
10401
10402                 buffer_init (&buf, 128);
10403
10404                 err = ERR_NONE;
10405                 no_reply = FALSE;
10406
10407                 /* Process the request */
10408                 switch (command_set) {
10409                 case CMD_SET_VM:
10410                         err = vm_commands (command, id, p, end, &buf);
10411                         if (err == ERR_NONE && command == CMD_VM_INVOKE_METHOD)
10412                                 /* Sent after the invoke is complete */
10413                                 no_reply = TRUE;
10414                         break;
10415                 case CMD_SET_EVENT_REQUEST:
10416                         err = event_commands (command, p, end, &buf);
10417                         break;
10418                 case CMD_SET_APPDOMAIN:
10419                         err = domain_commands (command, p, end, &buf);
10420                         break;
10421                 case CMD_SET_ASSEMBLY:
10422                         err = assembly_commands (command, p, end, &buf);
10423                         break;
10424                 case CMD_SET_MODULE:
10425                         err = module_commands (command, p, end, &buf);
10426                         break;
10427                 case CMD_SET_FIELD:
10428                         err = field_commands (command, p, end, &buf);
10429                         break;
10430                 case CMD_SET_TYPE:
10431                         err = type_commands (command, p, end, &buf);
10432                         break;
10433                 case CMD_SET_METHOD:
10434                         err = method_commands (command, p, end, &buf);
10435                         break;
10436                 case CMD_SET_THREAD:
10437                         err = thread_commands (command, p, end, &buf);
10438                         break;
10439                 case CMD_SET_STACK_FRAME:
10440                         err = frame_commands (command, p, end, &buf);
10441                         break;
10442                 case CMD_SET_ARRAY_REF:
10443                         err = array_commands (command, p, end, &buf);
10444                         break;
10445                 case CMD_SET_STRING_REF:
10446                         err = string_commands (command, p, end, &buf);
10447                         break;
10448                 case CMD_SET_OBJECT_REF:
10449                         err = object_commands (command, p, end, &buf);
10450                         break;
10451                 default:
10452                         err = ERR_NOT_IMPLEMENTED;
10453                 }
10454
10455                 if (command_set == CMD_SET_VM && command == CMD_VM_START_BUFFERING) {
10456                         buffer_replies = TRUE;
10457                 }
10458
10459                 if (!no_reply) {
10460                         if (buffer_replies) {
10461                                 buffer_reply_packet (id, err, &buf);
10462                         } else {
10463                                 send_reply_packet (id, err, &buf);
10464                                 //DEBUG_PRINTF (1, "[dbg] Sent reply to %d [at=%lx].\n", id, (long)mono_100ns_ticks () / 10000);
10465                         }
10466                 }
10467
10468                 if (err == ERR_NONE && command_set == CMD_SET_VM && command == CMD_VM_STOP_BUFFERING) {
10469                         send_buffered_reply_packets ();
10470                         buffer_replies = FALSE;
10471                 }
10472
10473                 g_free (data);
10474                 buffer_free (&buf);
10475
10476                 if (command_set == CMD_SET_VM && (command == CMD_VM_DISPOSE || command == CMD_VM_EXIT))
10477                         break;
10478         }
10479
10480         mono_set_is_debugger_attached (FALSE);
10481
10482         mono_coop_mutex_lock (&debugger_thread_exited_mutex);
10483         debugger_thread_exited = TRUE;
10484         mono_coop_cond_signal (&debugger_thread_exited_cond);
10485         mono_coop_mutex_unlock (&debugger_thread_exited_mutex);
10486
10487         DEBUG_PRINTF (1, "[dbg] Debugger thread exited.\n");
10488
10489         if (!attach_failed && command_set == CMD_SET_VM && command == CMD_VM_DISPOSE && !(vm_death_event_sent || mono_runtime_is_shutting_down ())) {
10490                 DEBUG_PRINTF (2, "[dbg] Detached - restarting clean debugger thread.\n");
10491                 start_debugger_thread ();
10492         }
10493
10494         return 0;
10495 }
10496
10497 #else /* DISABLE_DEBUGGER_AGENT */
10498
10499 void
10500 mono_debugger_agent_parse_options (char *options)
10501 {
10502         g_error ("This runtime is configured with the debugger agent disabled.");
10503 }
10504
10505 void
10506 mono_debugger_agent_init (void)
10507 {
10508 }
10509
10510 void
10511 mono_debugger_agent_breakpoint_hit (void *sigctx)
10512 {
10513 }
10514
10515 void
10516 mono_debugger_agent_single_step_event (void *sigctx)
10517 {
10518 }
10519
10520 void
10521 mono_debugger_agent_free_domain_info (MonoDomain *domain)
10522 {
10523 }
10524
10525 void
10526 mono_debugger_agent_handle_exception (MonoException *ext, MonoContext *throw_ctx,
10527                                                                           MonoContext *catch_ctx)
10528 {
10529 }
10530
10531 void
10532 mono_debugger_agent_begin_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx)
10533 {
10534 }
10535
10536 void
10537 mono_debugger_agent_end_exception_filter (MonoException *exc, MonoContext *ctx, MonoContext *orig_ctx)
10538 {
10539 }
10540
10541 void
10542 mono_debugger_agent_user_break (void)
10543 {
10544         G_BREAKPOINT ();
10545 }
10546
10547 void
10548 mono_debugger_agent_debug_log (int level, MonoString *category, MonoString *message)
10549 {
10550 }
10551
10552 gboolean
10553 mono_debugger_agent_debug_log_is_enabled (void)
10554 {
10555         return FALSE;
10556 }
10557
10558 void
10559 mono_debugger_agent_unhandled_exception (MonoException *exc)
10560 {
10561         g_assert_not_reached ();
10562 }
10563
10564 void
10565 debugger_agent_single_step_from_context (MonoContext *ctx)
10566 {
10567         g_assert_not_reached ();
10568 }
10569
10570 void
10571 debugger_agent_breakpoint_from_context (MonoContext *ctx)
10572 {
10573         g_assert_not_reached ();
10574 }
10575
10576 #endif