mono/mini/debugger-agent.c

   1 /*
   2  * debugger-agent.c: Debugger back-end module
   3  *
   4  * Author:
   5  *   Zoltan Varga (vargaz@gmail.com)
   6  *
   7  * (C) 2009 Novell, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #ifdef HAVE_SYS_TYPES_H
  15 #include <sys/types.h>
  16 #endif
  17 #ifdef HAVE_SYS_SELECT_H
  18 #include <sys/select.h>
  19 #endif
  20 #ifdef HAVE_SYS_SOCKET_H
  21 #include <sys/socket.h>
  22 #endif
  23 #ifdef HAVE_NETINET_TCP_H
  24 #include <netinet/tcp.h>
  25 #endif
  26 #ifdef HAVE_NETINET_IN_H
  27 #include <netinet/in.h>
  28 #endif
  29 #ifdef HAVE_NETDB_H
  30 #include <netdb.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 HAVE_UCONTEXT_H
  43 #include <ucontext.h>
  44 #endif
  45
  46 #ifdef HOST_WIN32
  47 #ifdef _MSC_VER
  48 #include <winsock2.h>
  49 #endif
  50 #include <ws2tcpip.h>
  51 #ifdef __GNUC__
  52 /* cygwin's headers do not seem to define these */
  53 void WSAAPI freeaddrinfo (struct addrinfo*);
  54 int WSAAPI getaddrinfo (const char*,const char*,const struct addrinfo*,
  55                         struct addrinfo**);
  56 int WSAAPI getnameinfo(const struct sockaddr*,socklen_t,char*,DWORD,
  57                        char*,DWORD,int);
  58 #endif
  59 #endif
  60
  61 #ifdef PLATFORM_ANDROID
  62 #include <linux/in.h>
  63 #include <linux/tcp.h>
  64 #include <sys/endian.h>
  65 #endif
  66
  67 #include <mono/metadata/mono-debug.h>
  68 #include <mono/metadata/mono-debug-debugger.h>
  69 #include <mono/metadata/debug-mono-symfile.h>
  70 #include <mono/metadata/gc-internal.h>
  71 #include <mono/metadata/threads-types.h>
  72 #include <mono/metadata/socket-io.h>
  73 #include <mono/utils/mono-semaphore.h>
  74 #include "debugger-agent.h"
  75 #include "mini.h"
  76
  77 #ifndef MONO_ARCH_SOFT_DEBUG_SUPPORTED
  78 #define DISABLE_DEBUGGER_AGENT 1
  79 #endif
  80
  81 #ifdef DISABLE_SOFT_DEBUG
  82 #define DISABLE_DEBUGGER_AGENT 1
  83 #endif
  84
  85 #ifndef DISABLE_DEBUGGER_AGENT
  86 #include <mono/io-layer/mono-mutex.h>
  87
  88 /* Definitions to make backporting to 2.6 easier */
  89 //#define MonoInternalThread MonoThread
  90 //#define mono_thread_internal_current mono_thread_current
  91 #define THREAD_TO_INTERNAL(thread) (thread)->internal_thread
  92
  93 typedef struct {
  94         gboolean enabled;
  95         char *transport;
  96         char *address;
  97         int log_level;
  98         char *log_file;
  99         gboolean suspend;
 100         gboolean server;
 101         gboolean onuncaught;
 102         GSList *onthrow;
 103         int timeout;
 104         char *launch;
 105 } AgentConfig;
 106
 107 typedef struct
 108 {
 109         int id;
 110         guint32 il_offset;
 111         MonoDomain *domain;
 112         MonoMethod *method;
 113         MonoContext ctx;
 114         MonoDebugMethodJitInfo *jit;
 115         int flags;
 116         /*
 117          * Whenever ctx is set. This is FALSE for the last frame of running threads, since
 118          * the frame can become invalid.
 119          */
 120         gboolean has_ctx;
 121 } StackFrame;
 122
 123 typedef struct _InvokeData InvokeData;
 124
 125 struct _InvokeData
 126 {
 127         int id;
 128         int flags;
 129         guint8 *p;
 130         guint8 *endp;
 131         /* This is the context which needs to be restored after the invoke */
 132         MonoContext ctx;
 133         gboolean has_ctx;
 134         /*
 135          * If this is set, invoke this method with the arguments given by ARGS.
 136          */
 137         MonoMethod *method;
 138         gpointer *args;
 139         guint32 suspend_count;
 140
 141         InvokeData *last_invoke;
 142 };
 143
 144 typedef struct {
 145         MonoContext ctx;
 146         MonoLMF *lmf;
 147         MonoDomain *domain;
 148         gboolean has_context;
 149         gpointer resume_event;
 150         /* This is computed on demand when it is requested using the wire protocol */
 151         /* It is freed up when the thread is resumed */
 152         int frame_count;
 153         StackFrame **frames;
 154         /*
 155          * Whenever the frame info is up-to-date. If not, compute_frame_info () will need to
 156          * re-compute it.
 157          */
 158         gboolean frames_up_to_date;
 159         /*
 160          * Points to data about a pending invoke which needs to be executed after the thread
 161          * resumes.
 162          */
 163         InvokeData *pending_invoke;
 164         /*
 165          * Set to TRUE if this thread is suspended in suspend_current () or it is executing
 166          * native code.
 167          */
 168         gboolean suspended;
 169         /*
 170          * Signals whenever the thread is in the process of suspending, i.e. it will suspend
 171          * within a finite amount of time.
 172          */
 173         gboolean suspending;
 174         /*
 175          * Set to TRUE if this thread is suspended in suspend_current ().
 176          */
 177         gboolean really_suspended;
 178         /* Used to pass the context to the breakpoint/single step handler */
 179         MonoContext handler_ctx;
 180         /* Whenever thread_stop () was called for this thread */
 181         gboolean terminated;
 182
 183         /* Number of thread interruptions not yet processed */
 184         gint32 interrupt_count;
 185
 186         /* Whenever to disable breakpoints (used during invokes) */
 187         gboolean disable_breakpoints;
 188
 189         /*
 190          * Number of times this thread has been resumed using resume_thread ().
 191          */
 192         guint32 resume_count;
 193
 194         MonoInternalThread *thread;
 195
 196         /*
 197          * Information about the frame which transitioned to native code for running
 198          * threads.
 199          */
 200         StackFrameInfo async_last_frame;
 201
 202         /*
 203          * The context where the stack walk can be started for running threads.
 204          */
 205         MonoContext async_ctx;
 206
 207         gboolean has_async_ctx;
 208
 209         /*
 210          * The lmf where the stack walk can be started for running threads.
 211          */
 212         gpointer async_lmf;
 213
 214         /*
 215          * The callee address of the last mono_runtime_invoke call
 216          */
 217         gpointer invoke_addr;
 218
 219         gboolean abort_requested;
 220
 221         /*
 222          * The current mono_runtime_invoke invocation.
 223          */
 224         InvokeData *invoke;
 225 } DebuggerTlsData;
 226
 227 /*
 228  * Wire Protocol definitions
 229  */
 230
 231 #define HEADER_LENGTH 11
 232
 233 #define MAJOR_VERSION 2
 234 #define MINOR_VERSION 1
 235
 236 typedef enum {
 237         CMD_SET_VM = 1,
 238         CMD_SET_OBJECT_REF = 9,
 239         CMD_SET_STRING_REF = 10,
 240         CMD_SET_THREAD = 11,
 241         CMD_SET_ARRAY_REF = 13,
 242         CMD_SET_EVENT_REQUEST = 15,
 243         CMD_SET_STACK_FRAME = 16,
 244         CMD_SET_APPDOMAIN = 20,
 245         CMD_SET_ASSEMBLY = 21,
 246         CMD_SET_METHOD = 22,
 247         CMD_SET_TYPE = 23,
 248         CMD_SET_MODULE = 24,
 249         CMD_SET_EVENT = 64
 250 } CommandSet;
 251
 252 typedef enum {
 253         EVENT_KIND_VM_START = 0,
 254         EVENT_KIND_VM_DEATH = 1,
 255         EVENT_KIND_THREAD_START = 2,
 256         EVENT_KIND_THREAD_DEATH = 3,
 257         EVENT_KIND_APPDOMAIN_CREATE = 4,
 258         EVENT_KIND_APPDOMAIN_UNLOAD = 5,
 259         EVENT_KIND_METHOD_ENTRY = 6,
 260         EVENT_KIND_METHOD_EXIT = 7,
 261         EVENT_KIND_ASSEMBLY_LOAD = 8,
 262         EVENT_KIND_ASSEMBLY_UNLOAD = 9,
 263         EVENT_KIND_BREAKPOINT = 10,
 264         EVENT_KIND_STEP = 11,
 265         EVENT_KIND_TYPE_LOAD = 12,
 266         EVENT_KIND_EXCEPTION = 13
 267 } EventKind;
 268
 269 typedef enum {
 270         SUSPEND_POLICY_NONE = 0,
 271         SUSPEND_POLICY_EVENT_THREAD = 1,
 272         SUSPEND_POLICY_ALL = 2
 273 } SuspendPolicy;
 274
 275 typedef enum {
 276         ERR_NONE = 0,
 277         ERR_INVALID_OBJECT = 20,
 278         ERR_INVALID_FIELDID = 25,
 279         ERR_INVALID_FRAMEID = 30,
 280         ERR_NOT_IMPLEMENTED = 100,
 281         ERR_NOT_SUSPENDED = 101,
 282         ERR_INVALID_ARGUMENT = 102,
 283         ERR_UNLOADED = 103,
 284         ERR_NO_INVOCATION = 104
 285 } ErrorCode;
 286
 287 typedef enum {
 288         MOD_KIND_COUNT = 1,
 289         MOD_KIND_THREAD_ONLY = 3,
 290         MOD_KIND_LOCATION_ONLY = 7,
 291         MOD_KIND_EXCEPTION_ONLY = 8,
 292         MOD_KIND_STEP = 10,
 293         MOD_KIND_ASSEMBLY_ONLY = 11
 294 } ModifierKind;
 295
 296 typedef enum {
 297         STEP_DEPTH_INTO = 0,
 298         STEP_DEPTH_OVER = 1,
 299         STEP_DEPTH_OUT = 2
 300 } StepDepth;
 301
 302 typedef enum {
 303         STEP_SIZE_MIN = 0,
 304         STEP_SIZE_LINE = 1
 305 } StepSize;
 306
 307 typedef enum {
 308         TOKEN_TYPE_STRING = 0,
 309         TOKEN_TYPE_TYPE = 1,
 310         TOKEN_TYPE_FIELD = 2,
 311         TOKEN_TYPE_METHOD = 3,
 312         TOKEN_TYPE_UNKNOWN = 4
 313 } DebuggerTokenType;
 314
 315 typedef enum {
 316         VALUE_TYPE_ID_NULL = 0xf0,
 317         VALUE_TYPE_ID_TYPE = 0xf1
 318 } ValueTypeId;
 319
 320 typedef enum {
 321         FRAME_FLAG_DEBUGGER_INVOKE = 1
 322 } StackFrameFlags;
 323
 324 typedef enum {
 325         INVOKE_FLAG_DISABLE_BREAKPOINTS = 1,
 326         INVOKE_FLAG_SINGLE_THREADED = 2
 327 } InvokeFlags;
 328
 329 typedef enum {
 330         CMD_VM_VERSION = 1,
 331         CMD_VM_ALL_THREADS = 2,
 332         CMD_VM_SUSPEND = 3,
 333         CMD_VM_RESUME = 4,
 334         CMD_VM_EXIT = 5,
 335         CMD_VM_DISPOSE = 6,
 336         CMD_VM_INVOKE_METHOD = 7,
 337         CMD_VM_SET_PROTOCOL_VERSION = 8,
 338         CMD_VM_ABORT_INVOKE = 9
 339 } CmdVM;
 340
 341 typedef enum {
 342         CMD_THREAD_GET_FRAME_INFO = 1,
 343         CMD_THREAD_GET_NAME = 2,
 344         CMD_THREAD_GET_STATE = 3,
 345         CMD_THREAD_GET_INFO = 4,
 346         CMD_THREAD_GET_ID = 5
 347 } CmdThread;
 348
 349 typedef enum {
 350         CMD_EVENT_REQUEST_SET = 1,
 351         CMD_EVENT_REQUEST_CLEAR = 2,
 352         CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS = 3
 353 } CmdEvent;
 354
 355 typedef enum {
 356         CMD_COMPOSITE = 100
 357 } CmdComposite;
 358
 359 typedef enum {
 360         CMD_APPDOMAIN_GET_ROOT_DOMAIN = 1,
 361         CMD_APPDOMAIN_GET_FRIENDLY_NAME = 2,
 362         CMD_APPDOMAIN_GET_ASSEMBLIES = 3,
 363         CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY = 4,
 364         CMD_APPDOMAIN_CREATE_STRING = 5,
 365         CMD_APPDOMAIN_GET_CORLIB = 6,
 366         CMD_APPDOMAIN_CREATE_BOXED_VALUE = 7,
 367 } CmdAppDomain;
 368
 369 typedef enum {
 370         CMD_ASSEMBLY_GET_LOCATION = 1,
 371         CMD_ASSEMBLY_GET_ENTRY_POINT = 2,
 372         CMD_ASSEMBLY_GET_MANIFEST_MODULE = 3,
 373         CMD_ASSEMBLY_GET_OBJECT = 4,
 374         CMD_ASSEMBLY_GET_TYPE = 5,
 375         CMD_ASSEMBLY_GET_NAME = 6
 376 } CmdAssembly;
 377
 378 typedef enum {
 379         CMD_MODULE_GET_INFO = 1,
 380 } CmdModule;
 381
 382 typedef enum {
 383         CMD_METHOD_GET_NAME = 1,
 384         CMD_METHOD_GET_DECLARING_TYPE = 2,
 385         CMD_METHOD_GET_DEBUG_INFO = 3,
 386         CMD_METHOD_GET_PARAM_INFO = 4,
 387         CMD_METHOD_GET_LOCALS_INFO = 5,
 388         CMD_METHOD_GET_INFO = 6,
 389         CMD_METHOD_GET_BODY = 7,
 390         CMD_METHOD_RESOLVE_TOKEN = 8,
 391 } CmdMethod;
 392
 393 typedef enum {
 394         CMD_TYPE_GET_INFO = 1,
 395         CMD_TYPE_GET_METHODS = 2,
 396         CMD_TYPE_GET_FIELDS = 3,
 397         CMD_TYPE_GET_VALUES = 4,
 398         CMD_TYPE_GET_OBJECT = 5,
 399         CMD_TYPE_GET_SOURCE_FILES = 6,
 400         CMD_TYPE_SET_VALUES = 7,
 401         CMD_TYPE_IS_ASSIGNABLE_FROM = 8,
 402         CMD_TYPE_GET_PROPERTIES = 9,
 403         CMD_TYPE_GET_CATTRS = 10,
 404         CMD_TYPE_GET_FIELD_CATTRS = 11,
 405         CMD_TYPE_GET_PROPERTY_CATTRS = 12
 406 } CmdType;
 407
 408 typedef enum {
 409         CMD_STACK_FRAME_GET_VALUES = 1,
 410         CMD_STACK_FRAME_GET_THIS = 2,
 411         CMD_STACK_FRAME_SET_VALUES = 3
 412 } CmdStackFrame;
 413
 414 typedef enum {
 415         CMD_ARRAY_REF_GET_LENGTH = 1,
 416         CMD_ARRAY_REF_GET_VALUES = 2,
 417         CMD_ARRAY_REF_SET_VALUES = 3,
 418 } CmdArray;
 419
 420 typedef enum {
 421         CMD_STRING_REF_GET_VALUE = 1,
 422 } CmdString;
 423
 424 typedef enum {
 425         CMD_OBJECT_REF_GET_TYPE = 1,
 426         CMD_OBJECT_REF_GET_VALUES = 2,
 427         CMD_OBJECT_REF_IS_COLLECTED = 3,
 428         CMD_OBJECT_REF_GET_ADDRESS = 4,
 429         CMD_OBJECT_REF_GET_DOMAIN = 5,
 430         CMD_OBJECT_REF_SET_VALUES = 6
 431 } CmdObject;
 432
 433 typedef struct {
 434         ModifierKind kind;
 435         union {
 436                 int count; /* For kind == MOD_KIND_COUNT */
 437                 MonoInternalThread *thread; /* For kind == MOD_KIND_THREAD_ONLY */
 438                 MonoClass *exc_class; /* For kind == MONO_KIND_EXCEPTION_ONLY */
 439                 MonoAssembly **assemblies; /* For kind == MONO_KIND_ASSEMBLY_ONLY */
 440         } data;
 441         gboolean caught, uncaught; /* For kind == MOD_KIND_EXCEPTION_ONLY */
 442 } Modifier;
 443
 444 typedef struct{
 445         int id;
 446         int event_kind;
 447         int suspend_policy;
 448         int nmodifiers;
 449         gpointer info;
 450         Modifier modifiers [MONO_ZERO_LEN_ARRAY];
 451 } EventRequest;
 452
 453 /*
 454  * Describes a single step request.
 455  */
 456 typedef struct {
 457         EventRequest *req;
 458         MonoInternalThread *thread;
 459         StepDepth depth;
 460         StepSize size;
 461         gpointer last_sp;
 462         gpointer start_sp;
 463         MonoMethod *last_method;
 464         int last_line;
 465         /* Whenever single stepping is performed using start/stop_single_stepping () */
 466         gboolean global;
 467         /* The list of breakpoints used to implement step-over */
 468         GSList *bps;
 469 } SingleStepReq;
 470
 471 /*
 472  * Contains additional information for an event
 473  */
 474 typedef struct {
 475         /* For EVENT_KIND_EXCEPTION */
 476         MonoObject *exc;
 477         MonoContext catch_ctx;
 478         gboolean caught;
 479 } EventInfo;
 480
 481 /* Dummy structure used for the profiler callbacks */
 482 typedef struct {
 483         void* dummy;
 484 } DebuggerProfiler;
 485
 486 #define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; fflush (log_file); } } while (0)
 487
 488 /*
 489  * Globals
 490  */
 491
 492 static AgentConfig agent_config;
 493
 494 /*
 495  * Whenever the agent is fully initialized.
 496  * When using the onuncaught or onthrow options, only some parts of the agent are
 497  * initialized on startup, and the full initialization which includes connection
 498  * establishment and the startup of the agent thread is only done in response to
 499  * an event.
 500  */
 501 static gint32 inited;
 502
 503 static int conn_fd;
 504
 505 static int packet_id = 0;
 506
 507 static int objref_id = 0;
 508
 509 static int event_request_id = 0;
 510
 511 static int frame_id = 0;
 512
 513 static GPtrArray *event_requests;
 514
 515 static guint32 debugger_tls_id;
 516
 517 static gboolean vm_start_event_sent, vm_death_event_sent, disconnected;
 518
 519 /* Maps MonoInternalThread -> DebuggerTlsData */
 520 static MonoGHashTable *thread_to_tls;
 521
 522 /* Maps tid -> MonoInternalThread */
 523 static MonoGHashTable *tid_to_thread;
 524
 525 /* Maps tid -> MonoThread (not MonoInternalThread) */
 526 static MonoGHashTable *tid_to_thread_obj;
 527
 528 static gsize debugger_thread_id;
 529
 530 static HANDLE debugger_thread_handle;
 531
 532 static int log_level;
 533
 534 static FILE *log_file;
 535
 536 /* Classes whose class load event has been sent */
 537 static GHashTable *loaded_classes;
 538
 539 /* Assemblies whose assembly load event has no been sent yet */
 540 static GPtrArray *pending_assembly_loads;
 541
 542 /* Types whose type load event has no been sent yet */
 543 static GPtrArray *pending_type_loads;
 544
 545 /* Whenever the debugger thread has exited */
 546 static gboolean debugger_thread_exited;
 547
 548 /* Cond variable used to wait for debugger_thread_exited becoming true */
 549 static mono_cond_t debugger_thread_exited_cond;
 550
 551 /* Mutex for the cond var above */
 552 static mono_mutex_t debugger_thread_exited_mutex;
 553
 554 static DebuggerProfiler debugger_profiler;
 555
 556 /* The single step request instance */
 557 static SingleStepReq *ss_req = NULL;
 558 static gpointer ss_invoke_addr = NULL;
 559
 560 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
 561 /* Number of single stepping operations in progress */
 562 static int ss_count;
 563 #endif
 564
 565 /* The protocol version of the client */
 566 static int major_version, minor_version;
 567
 568 /* Whenever the variables above are set by the client */
 569 static gboolean protocol_version_set;
 570
 571 static void transport_connect (const char *host, int port);
 572
 573 static guint32 WINAPI debugger_thread (void *arg);
 574
 575 static void runtime_initialized (MonoProfiler *prof);
 576
 577 static void runtime_shutdown (MonoProfiler *prof);
 578
 579 static void thread_startup (MonoProfiler *prof, intptr_t tid);
 580
 581 static void thread_end (MonoProfiler *prof, intptr_t tid);
 582
 583 static void appdomain_load (MonoProfiler *prof, MonoDomain *domain, int result);
 584
 585 static void appdomain_unload (MonoProfiler *prof, MonoDomain *domain);
 586
 587 static void invalidate_each_thread (gpointer key, gpointer value, gpointer user_data);
 588
 589 static void assembly_load (MonoProfiler *prof, MonoAssembly *assembly, int result);
 590
 591 static void assembly_unload (MonoProfiler *prof, MonoAssembly *assembly);
 592
 593 static void start_runtime_invoke (MonoProfiler *prof, MonoMethod *method);
 594
 595 static void end_runtime_invoke (MonoProfiler *prof, MonoMethod *method);
 596
 597 static void jit_end (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo, int result);
 598
 599 static void add_pending_breakpoints (MonoMethod *method, MonoJitInfo *jinfo);
 600
 601 static void start_single_stepping (void);
 602
 603 static void stop_single_stepping (void);
 604
 605 static void suspend_current (void);
 606
 607 static void clear_event_requests_for_assembly (MonoAssembly *assembly);
 608
 609 /* Submodule init/cleanup */
 610 static void breakpoints_init (void);
 611 static void breakpoints_cleanup (void);
 612
 613 static void objrefs_init (void);
 614 static void objrefs_cleanup (void);
 615
 616 static void ids_init (void);
 617 static void ids_cleanup (void);
 618
 619 static void suspend_init (void);
 620
 621 static void ss_start (SingleStepReq *ss_req, MonoMethod *method, SeqPoint *sp, MonoSeqPointInfo *info, MonoContext *ctx, DebuggerTlsData *tls);
 622 static ErrorCode ss_create (MonoInternalThread *thread, StepSize size, StepDepth depth, EventRequest *req);
 623 static void ss_destroy (SingleStepReq *req);
 624
 625 static void start_debugger_thread (void);
 626
 627 static void finish_agent_init (gboolean on_startup);
 628
 629 static int
 630 parse_address (char *address, char **host, int *port)
 631 {
 632         char *pos = strchr (address, ':');
 633
 634         if (pos == NULL || pos == address)
 635                 return 1;
 636
 637         *host = g_malloc (pos - address + 1);
 638         strncpy (*host, address, pos - address);
 639         (*host) [pos - address] = '\0';
 640
 641         *port = atoi (pos + 1);
 642
 643         return 0;
 644 }
 645
 646 static void
 647 print_usage (void)
 648 {
 649         fprintf (stderr, "Usage: mono --debugger-agent=[<option>=<value>,...] ...\n");
 650         fprintf (stderr, "Available options:\n");
 651         fprintf (stderr, "  transport=<transport>\t\tTransport to use for connecting to the debugger (mandatory, possible values: 'dt_socket')\n");
 652         fprintf (stderr, "  address=<hostname>:<port>\tAddress to connect to (mandatory)\n");
 653         fprintf (stderr, "  loglevel=<n>\t\t\tLog level (defaults to 0)\n");
 654         fprintf (stderr, "  logfile=<file>\t\tFile to log to (defaults to stdout)\n");
 655         fprintf (stderr, "  suspend=y/n\t\t\tWhenever to suspend after startup.\n");
 656         fprintf (stderr, "  timeout=<n>\t\t\tTimeout for connecting in milliseconds.\n");
 657         fprintf (stderr, "  help\t\t\t\tPrint this help.\n");
 658 }
 659
 660 static gboolean
 661 parse_flag (const char *option, char *flag)
 662 {
 663         if (!strcmp (flag, "y"))
 664                 return TRUE;
 665         else if (!strcmp (flag, "n"))
 666                 return FALSE;
 667         else {
 668                 fprintf (stderr, "debugger-agent: The valid values for the '%s' option are 'y' and 'n'.\n", option);
 669                 exit (1);
 670                 return FALSE;
 671         }
 672 }
 673
 674 void
 675 mono_debugger_agent_parse_options (char *options)
 676 {
 677         char **args, **ptr;
 678         char *host;
 679         int port;
 680
 681 #ifndef MONO_ARCH_SOFT_DEBUG_SUPPORTED
 682         fprintf (stderr, "--debugger-agent is not supported on this platform.\n");
 683         exit (1);
 684 #endif
 685
 686         agent_config.enabled = TRUE;
 687         agent_config.suspend = TRUE;
 688         agent_config.server = FALSE;
 689
 690         args = g_strsplit (options, ",", -1);
 691         for (ptr = args; ptr && *ptr; ptr ++) {
 692                 char *arg = *ptr;
 693
 694                 if (strncmp (arg, "transport=", 10) == 0) {
 695                         agent_config.transport = g_strdup (arg + 10);
 696                 } else if (strncmp (arg, "address=", 8) == 0) {
 697                         agent_config.address = g_strdup (arg + 8);
 698                 } else if (strncmp (arg, "loglevel=", 9) == 0) {
 699                         agent_config.log_level = atoi (arg + 9);
 700                 } else if (strncmp (arg, "logfile=", 8) == 0) {
 701                         agent_config.log_file = g_strdup (arg + 8);
 702                 } else if (strncmp (arg, "suspend=", 8) == 0) {
 703                         agent_config.suspend = parse_flag ("suspend", arg + 8);
 704                 } else if (strncmp (arg, "server=", 7) == 0) {
 705                         agent_config.server = parse_flag ("server", arg + 7);
 706                 } else if (strncmp (arg, "onuncaught=", 11) == 0) {
 707                         agent_config.onuncaught = parse_flag ("onuncaught", arg + 11);
 708                 } else if (strncmp (arg, "onthrow=", 8) == 0) {
 709                         /* We support multiple onthrow= options */
 710                         agent_config.onthrow = g_slist_append (agent_config.onthrow, g_strdup (arg + 8));
 711                 } else if (strncmp (arg, "onthrow", 7) == 0) {
 712                         agent_config.onthrow = g_slist_append (agent_config.onthrow, g_strdup (""));
 713                 } else if (strncmp (arg, "help", 4) == 0) {
 714                         print_usage ();
 715                         exit (0);
 716                 } else if (strncmp (arg, "timeout=", 8) == 0) {
 717                         agent_config.timeout = atoi (arg + 8);
 718                 } else if (strncmp (arg, "launch=", 7) == 0) {
 719                         agent_config.launch = g_strdup (arg + 7);
 720                 } else {
 721                         print_usage ();
 722                         exit (1);
 723                 }
 724         }
 725
 726         if (agent_config.transport == NULL) {
 727                 fprintf (stderr, "debugger-agent: The 'transport' option is mandatory.\n");
 728                 exit (1);
 729         }
 730         if (strcmp (agent_config.transport, "dt_socket") != 0) {
 731                 fprintf (stderr, "debugger-agent: The only supported value for the 'transport' option is 'dt_socket'.\n");
 732                 exit (1);
 733         }
 734
 735         if (agent_config.address == NULL && !agent_config.server) {
 736                 fprintf (stderr, "debugger-agent: The 'address' option is mandatory.\n");
 737                 exit (1);
 738         }
 739
 740         if (agent_config.address && parse_address (agent_config.address, &host, &port)) {
 741                 fprintf (stderr, "debugger-agent: The format of the 'address' options is '<host>:<port>'\n");
 742                 exit (1);
 743         }
 744 }
 745
 746 void
 747 mono_debugger_agent_init (void)
 748 {
 749         if (!agent_config.enabled)
 750                 return;
 751
 752         /* Need to know whenever a thread has acquired the loader mutex */
 753         mono_loader_lock_track_ownership (TRUE);
 754
 755         event_requests = g_ptr_array_new ();
 756
 757         mono_mutex_init (&debugger_thread_exited_mutex, NULL);
 758         mono_cond_init (&debugger_thread_exited_cond, NULL);
 759
 760         mono_profiler_install ((MonoProfiler*)&debugger_profiler, runtime_shutdown);
 761         mono_profiler_set_events (MONO_PROFILE_APPDOMAIN_EVENTS | MONO_PROFILE_THREADS | MONO_PROFILE_ASSEMBLY_EVENTS | MONO_PROFILE_JIT_COMPILATION | MONO_PROFILE_METHOD_EVENTS);
 762         mono_profiler_install_runtime_initialized (runtime_initialized);
 763         mono_profiler_install_appdomain (NULL, appdomain_load, NULL, appdomain_unload);
 764         mono_profiler_install_thread (thread_startup, thread_end);
 765         mono_profiler_install_assembly (NULL, assembly_load, assembly_unload, NULL);
 766         mono_profiler_install_jit_end (jit_end);
 767         mono_profiler_install_method_invoke (start_runtime_invoke, end_runtime_invoke);
 768
 769         debugger_tls_id = TlsAlloc ();
 770
 771         thread_to_tls = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_KEY_GC);
 772         MONO_GC_REGISTER_ROOT (thread_to_tls);
 773
 774         tid_to_thread = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC);
 775         MONO_GC_REGISTER_ROOT (tid_to_thread);
 776
 777         tid_to_thread_obj = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC);
 778         MONO_GC_REGISTER_ROOT (tid_to_thread_obj);
 779
 780         loaded_classes = g_hash_table_new (mono_aligned_addr_hash, NULL);
 781         pending_assembly_loads = g_ptr_array_new ();
 782         pending_type_loads = g_ptr_array_new ();
 783
 784         log_level = agent_config.log_level;
 785
 786         if (agent_config.log_file) {
 787                 log_file = fopen (agent_config.log_file, "w+");
 788                 if (!log_file) {
 789                         fprintf (stderr, "Unable to create log file '%s': %s.\n", agent_config.log_file, strerror (errno));
 790                         exit (1);
 791                 }
 792         } else {
 793                 log_file = stdout;
 794         }
 795
 796         ids_init ();
 797         objrefs_init ();
 798         breakpoints_init ();
 799         suspend_init ();
 800
 801         mini_get_debug_options ()->gen_seq_points = TRUE;
 802         /*
 803          * This is needed because currently we don't handle liveness info.
 804          */
 805         mini_get_debug_options ()->mdb_optimizations = TRUE;
 806
 807         /* This is needed because we can't set local variables in registers yet */
 808         mono_disable_optimizations (MONO_OPT_LINEARS);
 809
 810         if (!agent_config.onuncaught && !agent_config.onthrow)
 811                 finish_agent_init (TRUE);
 812 }
 813
 814 /*
 815  * finish_agent_init:
 816  *
 817  *   Finish the initialization of the agent. This involves connecting the transport
 818  * and starting the agent thread. This is either done at startup, or
 819  * in response to some event like an unhandled exception.
 820  */
 821 static void
 822 finish_agent_init (gboolean on_startup)
 823 {
 824         char *host;
 825         int port;
 826         int res;
 827
 828         if (InterlockedCompareExchange (&inited, 1, 0) == 1)
 829                 return;
 830
 831         if (agent_config.launch) {
 832                 char *argv [16];
 833
 834                 // FIXME: Generated address
 835                 // FIXME: Races with transport_connect ()
 836
 837                 argv [0] = agent_config.launch;
 838                 argv [1] = agent_config.transport;
 839                 argv [2] = agent_config.address;
 840                 argv [3] = NULL;
 841
 842                 res = g_spawn_async_with_pipes (NULL, argv, NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 843                 if (!res) {
 844                         fprintf (stderr, "Failed to execute '%s'.\n", agent_config.launch);
 845                         exit (1);
 846                 }
 847         }
 848
 849         if (agent_config.address) {
 850                 res = parse_address (agent_config.address, &host, &port);
 851                 g_assert (res == 0);
 852         } else {
 853                 host = NULL;
 854                 port = 0;
 855         }
 856
 857         transport_connect (host, port);
 858
 859         if (!on_startup) {
 860                 /* Do some which is usually done after sending the VMStart () event */
 861                 vm_start_event_sent = TRUE;
 862                 start_debugger_thread ();
 863         }
 864 }
 865
 866 static void
 867 mono_debugger_agent_cleanup (void)
 868 {
 869         if (!inited)
 870                 return;
 871
 872         /* This will interrupt the agent thread */
 873         /* Close the read part only so it can still send back replies */
 874 #ifdef HOST_WIN32
 875         shutdown (conn_fd, SD_RECEIVE);
 876 #else
 877         shutdown (conn_fd, SHUT_RD);
 878 #endif
 879
 880         /*
 881          * Wait for the thread to exit.
 882          *
 883          * If we continue with the shutdown without waiting for it, then the client might
 884          * not receive an answer to its last command like a resume.
 885          * The WaitForSingleObject infrastructure doesn't seem to work during shutdown, so
 886          * use pthreads.
 887          */
 888         //WaitForSingleObject (debugger_thread_handle, INFINITE);
 889         if (GetCurrentThreadId () != debugger_thread_id) {
 890                 mono_mutex_lock (&debugger_thread_exited_mutex);
 891                 if (!debugger_thread_exited) {
 892 #ifdef HOST_WIN32
 893                         if (WAIT_TIMEOUT == WaitForSingleObject(debugger_thread_exited_cond, 0)) {
 894                                 mono_mutex_unlock (&debugger_thread_exited_mutex);
 895                                 Sleep(0);
 896                                 mono_mutex_lock (&debugger_thread_exited_mutex);
 897                         }
 898 #else
 899                         mono_cond_wait (&debugger_thread_exited_cond, &debugger_thread_exited_mutex);
 900 #endif
 901                 }
 902                 mono_mutex_unlock (&debugger_thread_exited_mutex);
 903         }
 904
 905         breakpoints_cleanup ();
 906         objrefs_cleanup ();
 907         ids_cleanup ();
 908
 909 #ifdef HOST_WIN32
 910         shutdown (conn_fd, SD_BOTH);
 911 #else
 912         shutdown (conn_fd, SHUT_RDWR);
 913 #endif
 914
 915         mono_mutex_destroy (&debugger_thread_exited_mutex);
 916         mono_cond_destroy (&debugger_thread_exited_cond);
 917 }
 918
 919 /*
 920  * recv_length:
 921  *
 922  * recv() + handle incomplete reads and EINTR
 923  */
 924 static int
 925 recv_length (int fd, void *buf, int len, int flags)
 926 {
 927         int res;
 928         int total = 0;
 929
 930         do {
 931                 res = recv (fd, (char *) buf + total, len - total, flags);
 932                 if (res > 0)
 933                         total += res;
 934         } while ((res > 0 && total < len) || (res == -1 && errno == EINTR));
 935         return total;
 936 }
 937 /*
 938  * transport_connect:
 939  *
 940  *   Connect/Listen on HOST:PORT. If HOST is NULL, generate an address and listen on it.
 941  */
 942 static void
 943 transport_connect (const char *host, int port)
 944 {
 945         struct addrinfo hints;
 946         struct addrinfo *result, *rp;
 947         int sfd, s, res;
 948         char port_string [128];
 949         char handshake_msg [128];
 950         guint8 buf [128];
 951
 952         conn_fd = -1;
 953
 954         if (host) {
 955                 sprintf (port_string, "%d", port);
 956
 957                 mono_network_init ();
 958
 959                 /* Obtain address(es) matching host/port */
 960
 961                 memset (&hints, 0, sizeof (struct addrinfo));
 962                 hints.ai_family = AF_UNSPEC;    /* Allow IPv4 or IPv6 */
 963                 hints.ai_socktype = SOCK_STREAM; /* Datagram socket */
 964                 hints.ai_flags = 0;
 965                 hints.ai_protocol = 0;          /* Any protocol */
 966
 967                 s = getaddrinfo (host, port_string, &hints, &result);
 968                 if (s != 0) {
 969                         fprintf (stderr, "debugger-agent: Unable to connect to %s:%d: %s\n", host, port, gai_strerror (s));
 970                         exit (1);
 971                 }
 972         }
 973
 974         if (agent_config.server) {
 975                 /* Wait for a connection */
 976                 if (!host) {
 977                         struct sockaddr_in addr;
 978                         socklen_t addrlen;
 979
 980                         /* No address, generate one */
 981                         sfd = socket (AF_INET, SOCK_STREAM, 0);
 982                         g_assert (sfd);
 983
 984                         /* This will bind the socket to a random port */
 985                         res = listen (sfd, 16);
 986                         if (res == -1) {
 987                                 fprintf (stderr, "debugger-agent: Unable to setup listening socket: %s\n", strerror (errno));
 988                                 exit (1);
 989                         }
 990
 991                         addrlen = sizeof (addr);
 992                         memset (&addr, 0, sizeof (addr));
 993                         res = getsockname (sfd, &addr, &addrlen);
 994                         g_assert (res == 0);
 995
 996                         host = "127.0.0.1";
 997                         port = ntohs (addr.sin_port);
 998
 999                         /* Emit the address to stdout */
1000                         /* FIXME: Should print another interface, not localhost */
1001                         printf ("%s:%d\n", host, port);
1002                 } else {
1003                         /* Listen on the provided address */
1004                         for (rp = result; rp != NULL; rp = rp->ai_next) {
1005                                 sfd = socket (rp->ai_family, rp->ai_socktype,
1006                                                           rp->ai_protocol);
1007                                 if (sfd == -1)
1008                                         continue;
1009
1010                                 res = bind (sfd, rp->ai_addr, rp->ai_addrlen);
1011                                 if (res == -1)
1012                                         continue;
1013
1014                                 res = listen (sfd, 16);
1015                                 if (res == -1)
1016                                         continue;
1017                                 break;
1018                         }
1019
1020 #ifndef HOST_WIN32
1021                         /*
1022                          * this function is not present on win2000 which we still support, and the
1023                          * workaround described here:
1024                          * http://msdn.microsoft.com/en-us/library/ms737931(VS.85).aspx
1025                          * only works with MSVC.
1026                          */
1027                         freeaddrinfo (result);
1028 #endif
1029                 }
1030
1031                 DEBUG (1, fprintf (log_file, "Listening on %s:%d (timeout=%d ms)...\n", host, port, agent_config.timeout));
1032
1033                 if (agent_config.timeout) {
1034                         fd_set readfds;
1035                         struct timeval tv;
1036
1037                         tv.tv_sec = 0;
1038                         tv.tv_usec = agent_config.timeout * 1000;
1039                         FD_ZERO (&readfds);
1040                         FD_SET (sfd, &readfds);
1041                         res = select (sfd + 1, &readfds, NULL, NULL, &tv);
1042                         if (res == 0) {
1043                                 fprintf (stderr, "debugger-agent: Timed out waiting to connect.\n");
1044                                 exit (1);
1045                         }
1046                 }
1047
1048                 conn_fd = accept (sfd, NULL, NULL);
1049                 if (conn_fd == -1) {
1050                         fprintf (stderr, "debugger-agent: Unable to listen on %s:%d\n", host, port);
1051                         exit (1);
1052                 }
1053
1054                 DEBUG (1, fprintf (log_file, "Accepted connection from client, socket fd=%d.\n", conn_fd));
1055         } else {
1056                 /* Connect to the specified address */
1057                 /* FIXME: Respect the timeout */
1058                 for (rp = result; rp != NULL; rp = rp->ai_next) {
1059                         sfd = socket (rp->ai_family, rp->ai_socktype,
1060                                                   rp->ai_protocol);
1061                         if (sfd == -1)
1062                                 continue;
1063
1064                         if (connect (sfd, rp->ai_addr, rp->ai_addrlen) != -1)
1065                                 break;       /* Success */
1066
1067                         close (sfd);
1068                 }
1069
1070                 conn_fd = sfd;
1071
1072 #ifndef HOST_WIN32
1073                 /* See the comment above */
1074                 freeaddrinfo (result);
1075 #endif
1076
1077                 if (rp == 0) {
1078                         fprintf (stderr, "debugger-agent: Unable to connect to %s:%d\n", host, port);
1079                         exit (1);
1080                 }
1081         }
1082
1083         /* Write handshake message */
1084         sprintf (handshake_msg, "DWP-Handshake");
1085         do {
1086                 res = send (conn_fd, handshake_msg, strlen (handshake_msg), 0);
1087         } while (res == -1 && errno == EINTR);
1088         g_assert (res != -1);
1089
1090         /* Read answer */
1091         res = recv_length (conn_fd, buf, strlen (handshake_msg), 0);
1092         if ((res != strlen (handshake_msg)) || (memcmp (buf, handshake_msg, strlen (handshake_msg) != 0))) {
1093                 fprintf (stderr, "debugger-agent: DWP handshake failed.\n");
1094                 exit (1);
1095         }
1096
1097         /*
1098          * To support older clients, the client sends its protocol version after connecting
1099          * using a command. Until that is received, default to our protocol version.
1100          */
1101         major_version = MAJOR_VERSION;
1102         minor_version = MINOR_VERSION;
1103         protocol_version_set = FALSE;
1104
1105         /*
1106          * Set TCP_NODELAY on the socket so the client receives events/command
1107          * results immediately.
1108          */
1109         {
1110                 int flag = 1;
1111                 int result = setsockopt(conn_fd,
1112                                  IPPROTO_TCP,
1113                                  TCP_NODELAY,
1114                                  (char *) &flag,
1115                                  sizeof(int));
1116                 g_assert (result >= 0);
1117         }
1118 }
1119
1120 static gboolean
1121 transport_send (guint8 *data, int len)
1122 {
1123         int res;
1124
1125         do {
1126                 res = send (conn_fd, data, len, 0);
1127         } while (res == -1 && errno == EINTR);
1128         if (res != len)
1129                 return FALSE;
1130         else
1131                 return TRUE;
1132 }
1133
1134 static void
1135 start_debugger_thread (void)
1136 {
1137         gsize tid;
1138
1139         debugger_thread_handle = mono_create_thread (NULL, 0, debugger_thread, NULL, 0, &tid);
1140         g_assert (debugger_thread_handle);
1141 }
1142
1143 /*
1144  * Functions to decode protocol data
1145  */
1146
1147 static inline int
1148 decode_byte (guint8 *buf, guint8 **endbuf, guint8 *limit)
1149 {
1150         *endbuf = buf + 1;
1151         g_assert (*endbuf <= limit);
1152         return buf [0];
1153 }
1154
1155 static inline int
1156 decode_int (guint8 *buf, guint8 **endbuf, guint8 *limit)
1157 {
1158         *endbuf = buf + 4;
1159         g_assert (*endbuf <= limit);
1160
1161         return (((int)buf [0]) << 24) | (((int)buf [1]) << 16) | (((int)buf [2]) << 8) | (((int)buf [3]) << 0);
1162 }
1163
1164 static inline gint64
1165 decode_long (guint8 *buf, guint8 **endbuf, guint8 *limit)
1166 {
1167         guint32 high = decode_int (buf, &buf, limit);
1168         guint32 low = decode_int (buf, &buf, limit);
1169
1170         *endbuf = buf;
1171
1172         return ((((guint64)high) << 32) | ((guint64)low));
1173 }
1174
1175 static inline int
1176 decode_id (guint8 *buf, guint8 **endbuf, guint8 *limit)
1177 {
1178         return decode_int (buf, endbuf, limit);
1179 }
1180
1181 static inline char*
1182 decode_string (guint8 *buf, guint8 **endbuf, guint8 *limit)
1183 {
1184         int len = decode_int (buf, &buf, limit);
1185         char *s;
1186
1187         s = g_malloc (len + 1);
1188         g_assert (s);
1189
1190         memcpy (s, buf, len);
1191         s [len] = '\0';
1192         buf += len;
1193         *endbuf = buf;
1194
1195         return s;
1196 }
1197
1198 /*
1199  * Functions to encode protocol data
1200  */
1201
1202 typedef struct {
1203         guint8 *buf, *p, *end;
1204 } Buffer;
1205
1206 static inline void
1207 buffer_init (Buffer *buf, int size)
1208 {
1209         buf->buf = g_malloc (size);
1210         buf->p = buf->buf;
1211         buf->end = buf->buf + size;
1212 }
1213
1214 static inline void
1215 buffer_make_room (Buffer *buf, int size)
1216 {
1217         if (buf->end - buf->p < size) {
1218                 int new_size = buf->end - buf->buf + size + 32;
1219                 guint8 *p = g_realloc (buf->buf, new_size);
1220                 size = buf->p - buf->buf;
1221                 buf->buf = p;
1222                 buf->p = p + size;
1223                 buf->end = buf->buf + new_size;
1224         }
1225 }
1226
1227 static inline void
1228 buffer_add_byte (Buffer *buf, guint8 val)
1229 {
1230         buffer_make_room (buf, 1);
1231         buf->p [0] = val;
1232         buf->p++;
1233 }
1234
1235 static inline void
1236 buffer_add_int (Buffer *buf, guint32 val)
1237 {
1238         buffer_make_room (buf, 4);
1239         buf->p [0] = (val >> 24) & 0xff;
1240         buf->p [1] = (val >> 16) & 0xff;
1241         buf->p [2] = (val >> 8) & 0xff;
1242         buf->p [3] = (val >> 0) & 0xff;
1243         buf->p += 4;
1244 }
1245
1246 static inline void
1247 buffer_add_long (Buffer *buf, guint64 l)
1248 {
1249         buffer_add_int (buf, (l >> 32) & 0xffffffff);
1250         buffer_add_int (buf, (l >> 0) & 0xffffffff);
1251 }
1252
1253 static inline void
1254 buffer_add_id (Buffer *buf, int id)
1255 {
1256         buffer_add_int (buf, (guint64)id);
1257 }
1258
1259 static inline void
1260 buffer_add_data (Buffer *buf, guint8 *data, int len)
1261 {
1262         buffer_make_room (buf, len);
1263         memcpy (buf->p, data, len);
1264         buf->p += len;
1265 }
1266
1267 static inline void
1268 buffer_add_string (Buffer *buf, const char *str)
1269 {
1270         int len;
1271
1272         if (str == NULL) {
1273                 buffer_add_int (buf, 0);
1274         } else {
1275                 len = strlen (str);
1276                 buffer_add_int (buf, len);
1277                 buffer_add_data (buf, (guint8*)str, len);
1278         }
1279 }
1280
1281 static inline void
1282 buffer_free (Buffer *buf)
1283 {
1284         g_free (buf->buf);
1285 }
1286
1287 static gboolean
1288 send_packet (int command_set, int command, Buffer *data)
1289 {
1290         Buffer buf;
1291         int len, id;
1292         gboolean res;
1293
1294         id = InterlockedIncrement (&packet_id);
1295
1296         len = data->p - data->buf + 11;
1297         buffer_init (&buf, len);
1298         buffer_add_int (&buf, len);
1299         buffer_add_int (&buf, id);
1300         buffer_add_byte (&buf, 0); /* flags */
1301         buffer_add_byte (&buf, command_set);
1302         buffer_add_byte (&buf, command);
1303         memcpy (buf.buf + 11, data->buf, data->p - data->buf);
1304
1305         res = transport_send (buf.buf, len);
1306
1307         buffer_free (&buf);
1308
1309         return res;
1310 }
1311
1312 static gboolean
1313 send_reply_packet (int id, int error, Buffer *data)
1314 {
1315         Buffer buf;
1316         int len;
1317         gboolean res;
1318
1319         len = data->p - data->buf + 11;
1320         buffer_init (&buf, len);
1321         buffer_add_int (&buf, len);
1322         buffer_add_int (&buf, id);
1323         buffer_add_byte (&buf, 0x80); /* flags */
1324         buffer_add_byte (&buf, (error >> 8) & 0xff);
1325         buffer_add_byte (&buf, error);
1326         memcpy (buf.buf + 11, data->buf, data->p - data->buf);
1327
1328         res = transport_send (buf.buf, len);
1329
1330         buffer_free (&buf);
1331
1332         return res;
1333 }
1334
1335 /*
1336  * OBJECT IDS
1337  */
1338
1339 /*
1340  * Represents an object accessible by the debugger client.
1341  */
1342 typedef struct {
1343         /* Unique id used in the wire protocol to refer to objects */
1344         int id;
1345         /*
1346          * A weakref gc handle pointing to the object. The gc handle is used to
1347          * detect if the object was garbage collected.
1348          */
1349         guint32 handle;
1350 } ObjRef;
1351
1352 /* Maps objid -> ObjRef */
1353 static GHashTable *objrefs;
1354
1355 static void
1356 free_objref (gpointer value)
1357 {
1358         ObjRef *o = value;
1359
1360         mono_gchandle_free (o->handle);
1361
1362         g_free (o);
1363 }
1364
1365 static void
1366 objrefs_init (void)
1367 {
1368         objrefs = g_hash_table_new_full (NULL, NULL, NULL, free_objref);
1369 }
1370
1371 static void
1372 objrefs_cleanup (void)
1373 {
1374         g_hash_table_destroy (objrefs);
1375         objrefs = NULL;
1376 }
1377
1378 static GHashTable *obj_to_objref;
1379
1380 /*
1381  * Return an ObjRef for OBJ.
1382  */
1383 static ObjRef*
1384 get_objref (MonoObject *obj)
1385 {
1386         ObjRef *ref;
1387
1388         if (obj == NULL)
1389                 return 0;
1390
1391 #ifdef HAVE_SGEN_GC
1392         NOT_IMPLEMENTED;
1393 #endif
1394
1395         /* Use a hash table with masked pointers to internalize object references */
1396         /* FIXME: This can grow indefinitely */
1397         mono_loader_lock ();
1398
1399         if (!obj_to_objref)
1400                 obj_to_objref = g_hash_table_new (NULL, NULL);
1401
1402         ref = g_hash_table_lookup (obj_to_objref, GINT_TO_POINTER (~((gsize)obj)));
1403         /* ref might refer to a different object with the same addr which was GCd */
1404         if (ref && mono_gchandle_get_target (ref->handle) == obj) {
1405                 mono_loader_unlock ();
1406                 return ref;
1407         }
1408
1409         ref = g_new0 (ObjRef, 1);
1410         ref->id = InterlockedIncrement (&objref_id);
1411         ref->handle = mono_gchandle_new_weakref (obj, FALSE);
1412
1413         g_hash_table_insert (objrefs, GINT_TO_POINTER (ref->id), ref);
1414         g_hash_table_insert (obj_to_objref, GINT_TO_POINTER (~((gsize)obj)), ref);
1415
1416         mono_loader_unlock ();
1417
1418         return ref;
1419 }
1420
1421 static inline int
1422 get_objid (MonoObject *obj)
1423 {
1424         return get_objref (obj)->id;
1425 }
1426
1427 /*
1428  * Set OBJ to the object identified by OBJID.
1429  * Returns 0 or an error code if OBJID is invalid or the object has been garbage
1430  * collected.
1431  */
1432 static ErrorCode
1433 get_object_allow_null (int objid, MonoObject **obj)
1434 {
1435         ObjRef *ref;
1436
1437         if (objid == 0) {
1438                 *obj = NULL;
1439                 return 0;
1440         }
1441
1442         if (!objrefs)
1443                 return ERR_INVALID_OBJECT;
1444
1445         mono_loader_lock ();
1446
1447         ref = g_hash_table_lookup (objrefs, GINT_TO_POINTER (objid));
1448
1449         if (ref) {
1450                 *obj = mono_gchandle_get_target (ref->handle);
1451                 mono_loader_unlock ();
1452                 if (!(*obj))
1453                         return ERR_INVALID_OBJECT;
1454                 return 0;
1455         } else {
1456                 mono_loader_unlock ();
1457                 return ERR_INVALID_OBJECT;
1458         }
1459 }
1460
1461 static ErrorCode
1462 get_object (int objid, MonoObject **obj)
1463 {
1464         int err = get_object_allow_null (objid, obj);
1465
1466         if (err)
1467                 return err;
1468         if (!(*obj))
1469                 return ERR_INVALID_OBJECT;
1470         return 0;
1471 }
1472
1473 static inline int
1474 decode_objid (guint8 *buf, guint8 **endbuf, guint8 *limit)
1475 {
1476         return decode_id (buf, endbuf, limit);
1477 }
1478
1479 static inline void
1480 buffer_add_objid (Buffer *buf, MonoObject *o)
1481 {
1482         buffer_add_id (buf, get_objid (o));
1483 }
1484
1485 /*
1486  * IDS
1487  */
1488
1489 typedef enum {
1490         ID_ASSEMBLY = 0,
1491         ID_MODULE = 1,
1492         ID_TYPE = 2,
1493         ID_METHOD = 3,
1494         ID_FIELD = 4,
1495         ID_DOMAIN = 5,
1496         ID_PROPERTY = 6,
1497         ID_NUM
1498 } IdType;
1499
1500 /*
1501  * Represents a runtime structure accessible to the debugger client
1502  */
1503 typedef struct {
1504         /* Unique id used in the wire protocol */
1505         int id;
1506         /* Domain of the runtime structure, NULL if the domain was unloaded */
1507         MonoDomain *domain;
1508         union {
1509                 gpointer val;
1510                 MonoClass *klass;
1511                 MonoMethod *method;
1512                 MonoImage *image;
1513                 MonoAssembly *assembly;
1514                 MonoClassField *field;
1515                 MonoDomain *domain;
1516                 MonoProperty *property;
1517         } data;
1518 } Id;
1519
1520 typedef struct {
1521         /* Maps runtime structure -> Id */
1522         GHashTable *val_to_id [ID_NUM];
1523 } AgentDomainInfo;
1524
1525 /* Maps id -> Id */
1526 static GPtrArray *ids [ID_NUM];
1527
1528 static void
1529 ids_init (void)
1530 {
1531         int i;
1532
1533         for (i = 0; i < ID_NUM; ++i)
1534                 ids [i] = g_ptr_array_new ();
1535 }
1536
1537 static void
1538 ids_cleanup (void)
1539 {
1540         int i, j;
1541
1542         for (i = 0; i < ID_NUM; ++i) {
1543                 if (ids [i]) {
1544                         for (j = 0; j < ids [i]->len; ++j)
1545                                 g_free (g_ptr_array_index (ids [i], j));
1546                         g_ptr_array_free (ids [i], TRUE);
1547                 }
1548                 ids [i] = NULL;
1549         }
1550 }
1551
1552 void
1553 mono_debugger_agent_free_domain_info (MonoDomain *domain)
1554 {
1555         AgentDomainInfo *info = domain_jit_info (domain)->agent_info;
1556         int i, j;
1557
1558         if (info) {
1559                 for (i = 0; i < ID_NUM; ++i)
1560                         if (info->val_to_id [i])
1561                                 g_hash_table_destroy (info->val_to_id [i]);
1562                 g_free (info);
1563         }
1564
1565         domain_jit_info (domain)->agent_info = NULL;
1566
1567         /* Clear ids referencing structures in the domain */
1568         for (i = 0; i < ID_NUM; ++i) {
1569                 if (ids [i]) {
1570                         for (j = 0; j < ids [i]->len; ++j) {
1571                                 Id *id = g_ptr_array_index (ids [i], j);
1572                                 if (id->domain == domain)
1573                                         id->domain = NULL;
1574                         }
1575                 }
1576         }
1577 }
1578
1579 static int
1580 get_id (MonoDomain *domain, IdType type, gpointer val)
1581 {
1582         Id *id;
1583         AgentDomainInfo *info;
1584
1585         if (val == NULL)
1586                 return 0;
1587
1588         mono_loader_lock ();
1589
1590         mono_domain_lock (domain);
1591
1592         if (!domain_jit_info (domain)->agent_info)
1593                 domain_jit_info (domain)->agent_info = g_new0 (AgentDomainInfo, 1);
1594         info = domain_jit_info (domain)->agent_info;
1595         if (info->val_to_id [type] == NULL)
1596                 info->val_to_id [type] = g_hash_table_new (mono_aligned_addr_hash, NULL);
1597
1598         id = g_hash_table_lookup (info->val_to_id [type], val);
1599         if (id) {
1600                 mono_domain_unlock (domain);
1601                 mono_loader_unlock ();
1602                 return id->id;
1603         }
1604
1605         id = g_new0 (Id, 1);
1606         /* Reserve id 0 */
1607         id->id = ids [type]->len + 1;
1608         id->domain = domain;
1609         id->data.val = val;
1610
1611         g_hash_table_insert (info->val_to_id [type], val, id);
1612
1613         mono_domain_unlock (domain);
1614
1615         g_ptr_array_add (ids [type], id);
1616
1617         mono_loader_unlock ();
1618
1619         return id->id;
1620 }
1621
1622 static inline gpointer
1623 decode_ptr_id (guint8 *buf, guint8 **endbuf, guint8 *limit, IdType type, MonoDomain **domain, int *err)
1624 {
1625         Id *res;
1626
1627         int id = decode_id (buf, endbuf, limit);
1628
1629         *err = 0;
1630         if (domain)
1631                 *domain = NULL;
1632
1633         if (id == 0)
1634                 return NULL;
1635
1636         // FIXME: error handling
1637         mono_loader_lock ();
1638         g_assert (id > 0 && id <= ids [type]->len);
1639
1640         res = g_ptr_array_index (ids [type], GPOINTER_TO_INT (id - 1));
1641         mono_loader_unlock ();
1642
1643         if (res->domain == NULL) {
1644                 *err = ERR_UNLOADED;
1645                 return NULL;
1646         }
1647
1648         if (domain)
1649                 *domain = res->domain;
1650
1651         return res->data.val;
1652 }
1653
1654 static inline void
1655 buffer_add_ptr_id (Buffer *buf, MonoDomain *domain, IdType type, gpointer val)
1656 {
1657         buffer_add_id (buf, get_id (domain, type, val));
1658 }
1659
1660 static inline MonoClass*
1661 decode_typeid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
1662 {
1663         return decode_ptr_id (buf, endbuf, limit, ID_TYPE, domain, err);
1664 }
1665
1666 static inline MonoAssembly*
1667 decode_assemblyid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
1668 {
1669         return decode_ptr_id (buf, endbuf, limit, ID_ASSEMBLY, domain, err);
1670 }
1671
1672 static inline MonoImage*
1673 decode_moduleid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
1674 {
1675         return decode_ptr_id (buf, endbuf, limit, ID_MODULE, domain, err);
1676 }
1677
1678 static inline MonoMethod*
1679 decode_methodid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
1680 {
1681         return decode_ptr_id (buf, endbuf, limit, ID_METHOD, domain, err);
1682 }
1683
1684 static inline MonoClassField*
1685 decode_fieldid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
1686 {
1687         return decode_ptr_id (buf, endbuf, limit, ID_FIELD, domain, err);
1688 }
1689
1690 static inline MonoDomain*
1691 decode_domainid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
1692 {
1693         return decode_ptr_id (buf, endbuf, limit, ID_DOMAIN, domain, err);
1694 }
1695
1696 static inline MonoProperty*
1697 decode_propertyid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, int *err)
1698 {
1699         return decode_ptr_id (buf, endbuf, limit, ID_PROPERTY, domain, err);
1700 }
1701
1702 static inline void
1703 buffer_add_typeid (Buffer *buf, MonoDomain *domain, MonoClass *klass)
1704 {
1705         buffer_add_ptr_id (buf, domain, ID_TYPE, klass);
1706 }
1707
1708 static inline void
1709 buffer_add_methodid (Buffer *buf, MonoDomain *domain, MonoMethod *method)
1710 {
1711         buffer_add_ptr_id (buf, domain, ID_METHOD, method);
1712 }
1713
1714 static inline void
1715 buffer_add_assemblyid (Buffer *buf, MonoDomain *domain, MonoAssembly *assembly)
1716 {
1717         buffer_add_ptr_id (buf, domain, ID_ASSEMBLY, assembly);
1718 }
1719
1720 static inline void
1721 buffer_add_moduleid (Buffer *buf, MonoDomain *domain, MonoImage *image)
1722 {
1723         buffer_add_ptr_id (buf, domain, ID_MODULE, image);
1724 }
1725
1726 static inline void
1727 buffer_add_fieldid (Buffer *buf, MonoDomain *domain, MonoClassField *field)
1728 {
1729         buffer_add_ptr_id (buf, domain, ID_FIELD, field);
1730 }
1731
1732 static inline void
1733 buffer_add_propertyid (Buffer *buf, MonoDomain *domain, MonoProperty *property)
1734 {
1735         buffer_add_ptr_id (buf, domain, ID_PROPERTY, property);
1736 }
1737
1738 static inline void
1739 buffer_add_domainid (Buffer *buf, MonoDomain *domain)
1740 {
1741         buffer_add_ptr_id (buf, domain, ID_DOMAIN, domain);
1742 }
1743
1744 static void invoke_method (void);
1745
1746 /*
1747  * SUSPEND/RESUME
1748  */
1749
1750 /*
1751  * save_thread_context:
1752  *
1753  *   Set CTX as the current threads context which is used for computing stack traces.
1754  * This function is signal-safe.
1755  */
1756 static void
1757 save_thread_context (MonoContext *ctx)
1758 {
1759         DebuggerTlsData *tls;
1760
1761         tls = TlsGetValue (debugger_tls_id);
1762         g_assert (tls);
1763
1764         if (ctx) {
1765                 memcpy (&tls->ctx, ctx, sizeof (MonoContext));
1766         } else {
1767 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
1768                 MONO_INIT_CONTEXT_FROM_CURRENT (&tls->ctx);
1769 #else
1770                 MONO_INIT_CONTEXT_FROM_FUNC (&tls->ctx, save_thread_context);
1771 #endif
1772         }
1773
1774         tls->lmf = mono_get_lmf ();
1775         tls->domain = mono_domain_get ();
1776         tls->has_context = TRUE;
1777 }
1778
1779 /* The number of times the runtime is suspended */
1780 static gint32 suspend_count;
1781
1782 /* Number of threads suspended */
1783 /*
1784  * If this is equal to the size of thread_to_tls, the runtime is considered
1785  * suspended.
1786  */
1787 static gint32 threads_suspend_count;
1788
1789 static mono_mutex_t suspend_mutex;
1790
1791 /* Cond variable used to wait for suspend_count becoming 0 */
1792 static mono_cond_t suspend_cond;
1793
1794 /* Semaphore used to wait for a thread becoming suspended */
1795 static MonoSemType suspend_sem;
1796
1797 static void
1798 suspend_init (void)
1799 {
1800         mono_mutex_init (&suspend_mutex, NULL);
1801         mono_cond_init (&suspend_cond, NULL);
1802         MONO_SEM_INIT (&suspend_sem, 0);
1803 }
1804
1805 typedef struct
1806 {
1807         StackFrameInfo last_frame;
1808         gboolean last_frame_set;
1809         MonoContext ctx;
1810         gpointer lmf;
1811 } GetLastFrameUserData;
1812
1813 static gboolean
1814 get_last_frame (StackFrameInfo *info, MonoContext *ctx, gpointer user_data)
1815 {
1816         GetLastFrameUserData *data = user_data;
1817
1818         if (info->type == FRAME_TYPE_MANAGED_TO_NATIVE)
1819                 return FALSE;
1820
1821         if (!data->last_frame_set) {
1822                 /* Store the last frame */
1823                 memcpy (&data->last_frame, info, sizeof (StackFrameInfo));
1824                 data->last_frame_set = TRUE;
1825                 return FALSE;
1826         } else {
1827                 /* Store the context/lmf for the frame above the last frame */
1828                 memcpy (&data->ctx, ctx, sizeof (MonoContext));
1829                 data->lmf = info->lmf;
1830
1831                 return TRUE;
1832         }
1833 }
1834
1835 /*
1836  * mono_debugger_agent_thread_interrupt:
1837  *
1838  *   Called by the abort signal handler.
1839  * Should be signal safe.
1840  */
1841 gboolean
1842 mono_debugger_agent_thread_interrupt (void *sigctx, MonoJitInfo *ji)
1843 {
1844         DebuggerTlsData *tls;
1845
1846         if (!inited)
1847                 return FALSE;
1848
1849         tls = TlsGetValue (debugger_tls_id);
1850         if (!tls)
1851                 return FALSE;
1852
1853         /*
1854          * OSX can (and will) coalesce signals, so sending multiple pthread_kills does not
1855          * guarantee the signal handler will be called that many times.  Instead of tracking
1856          * interrupt_count on osx, we use this as a boolean flag to determine if a interrupt
1857          * has been requested that hasn't been handled yet, otherwise we can have threads
1858          * refuse to die when VM_EXIT is called
1859          */
1860 #if defined(__APPLE__)
1861         if (InterlockedCompareExchange (&tls->interrupt_count, 0, 1) == 0)
1862                 return FALSE;
1863 #else
1864         /*
1865          * We use interrupt_count to determine whenever this interrupt should be processed
1866          * by us or the normal interrupt processing code in the signal handler.
1867          * There is no race here with notify_thread (), since the signal is sent after
1868          * incrementing interrupt_count.
1869          */
1870         if (tls->interrupt_count == 0)
1871                 return FALSE;
1872
1873         InterlockedDecrement (&tls->interrupt_count);
1874 #endif
1875
1876         // FIXME: Races when the thread leaves managed code before hitting a single step
1877         // event.
1878
1879         if (ji) {
1880                 /* Running managed code, will be suspended by the single step code */
1881                 DEBUG (1, printf ("[%p] Received interrupt while at %s(%p), continuing.\n", (gpointer)GetCurrentThreadId (), ji->method->name, mono_arch_ip_from_context (sigctx)));
1882                 return TRUE;
1883         } else {
1884                 /*
1885                  * Running native code, will be suspended when it returns to/enters
1886                  * managed code. Treat it as already suspended.
1887                  * This might interrupt the code in process_single_step_inner (), we use the
1888                  * tls->suspending flag to avoid races when that happens.
1889                  */
1890                 if (!tls->suspended && !tls->suspending) {
1891                         MonoContext ctx;
1892                         GetLastFrameUserData data;
1893
1894                         // FIXME: printf is not signal safe, but this is only used during
1895                         // debugger debugging
1896                         DEBUG (1, printf ("[%p] Received interrupt while at %p, treating as suspended.\n", (gpointer)GetCurrentThreadId (), mono_arch_ip_from_context (sigctx)));
1897                         //save_thread_context (&ctx);
1898
1899                         if (!tls->thread)
1900                                 /* Already terminated */
1901                                 return TRUE;
1902
1903                         /*
1904                          * We are in a difficult position: we want to be able to provide stack
1905                          * traces for this thread, but we can't use the current ctx+lmf, since
1906                          * the thread is still running, so it might return to managed code,
1907                          * making these invalid.
1908                          * So we start a stack walk and save the first frame, along with the
1909                          * parent frame's ctx+lmf. This (hopefully) works because the thread will be
1910                          * suspended when it returns to managed code, so the parent's ctx should
1911                          * remain valid.
1912                          */
1913                         data.last_frame_set = FALSE;
1914                         if (sigctx) {
1915                                 mono_arch_sigctx_to_monoctx (sigctx, &ctx);
1916                                 mono_jit_walk_stack_from_ctx_in_thread (get_last_frame, mono_domain_get (), &ctx, FALSE, tls->thread, mono_get_lmf (), &data);
1917                         }
1918                         if (data.last_frame_set) {
1919                                 memcpy (&tls->async_last_frame, &data.last_frame, sizeof (StackFrameInfo));
1920                                 memcpy (&tls->async_ctx, &data.ctx, sizeof (MonoContext));
1921                                 tls->async_lmf = data.lmf;
1922                                 tls->has_async_ctx = TRUE;
1923                                 tls->domain = mono_domain_get ();
1924                                 memcpy (&tls->ctx, &ctx, sizeof (MonoContext));
1925                         } else {
1926                                 tls->has_async_ctx = FALSE;
1927                         }
1928
1929                         mono_memory_barrier ();
1930
1931                         tls->suspended = TRUE;
1932                         MONO_SEM_POST (&suspend_sem);
1933                 }
1934                 return TRUE;
1935         }
1936 }
1937
1938 #ifdef HOST_WIN32
1939 static void CALLBACK notify_thread_apc (ULONG_PTR param)
1940 {
1941         //DebugBreak ();
1942         mono_debugger_agent_thread_interrupt (NULL, NULL);
1943 }
1944 #endif /* HOST_WIN32 */
1945
1946 /*
1947  * reset_native_thread_suspend_state:
1948  *
1949  *   Reset the suspended flag on native threads
1950  */
1951 static void
1952 reset_native_thread_suspend_state (gpointer key, gpointer value, gpointer user_data)
1953 {
1954         DebuggerTlsData *tls = value;
1955
1956         if (!tls->really_suspended && tls->suspended)
1957                 tls->suspended = FALSE;
1958 }
1959
1960 /*
1961  * notify_thread:
1962  *
1963  *   Notify a thread that it needs to suspend.
1964  */
1965 static void
1966 notify_thread (gpointer key, gpointer value, gpointer user_data)
1967 {
1968         MonoInternalThread *thread = key;
1969         DebuggerTlsData *tls = value;
1970         gsize tid = thread->tid;
1971
1972         if (GetCurrentThreadId () == tid || tls->terminated)
1973                 return;
1974
1975         DEBUG(1, fprintf (log_file, "[%p] Interrupting %p...\n", (gpointer)GetCurrentThreadId (), (gpointer)tid));
1976
1977         /*
1978          * OSX can (and will) coalesce signals, so sending multiple pthread_kills does not
1979          * guarantee the signal handler will be called that many times.  Instead of tracking
1980          * interrupt_count on osx, we use this as a boolean flag to determine if a interrupt
1981          * has been requested that hasn't been handled yet, otherwise we can have threads
1982          * refuse to die when VM_EXIT is called
1983          */
1984 #if defined(__APPLE__)
1985         if (InterlockedCompareExchange (&tls->interrupt_count, 1, 0) == 1)
1986                 return;
1987 #else
1988         /*
1989          * Maybe we could use the normal interrupt infrastructure, but that does a lot
1990          * of things like breaking waits etc. which we don't want.
1991          */
1992         InterlockedIncrement (&tls->interrupt_count);
1993 #endif
1994
1995         /* This is _not_ equivalent to ves_icall_System_Threading_Thread_Abort () */
1996 #ifdef HOST_WIN32
1997         QueueUserAPC (notify_thread_apc, thread->handle, NULL);
1998 #else
1999         pthread_kill ((pthread_t) tid, mono_thread_get_abort_signal ());
2000 #endif
2001 }
2002
2003 static void
2004 process_suspend (DebuggerTlsData *tls, MonoContext *ctx)
2005 {
2006         guint8 *ip = MONO_CONTEXT_GET_IP (ctx);
2007         MonoJitInfo *ji;
2008
2009         if (debugger_thread_id == GetCurrentThreadId ())
2010                 return;
2011
2012         /* Prevent races with mono_debugger_agent_thread_interrupt () */
2013         if (suspend_count - tls->resume_count > 0)
2014                 tls->suspending = TRUE;
2015
2016         DEBUG(1, fprintf (log_file, "[%p] Received single step event for suspending.\n", (gpointer)GetCurrentThreadId ()));
2017
2018         if (suspend_count - tls->resume_count == 0) {
2019                 /*
2020                  * We are executing a single threaded invoke but the single step for
2021                  * suspending is still active.
2022                  * FIXME: This slows down single threaded invokes.
2023                  */
2024                 DEBUG(1, fprintf (log_file, "[%p] Ignored during single threaded invoke.\n", (gpointer)GetCurrentThreadId ()));
2025                 return;
2026         }
2027
2028         ji = mini_jit_info_table_find (mono_domain_get (), (char*)ip, NULL);
2029
2030         /* Can't suspend in these methods */
2031         if (ji->method->klass == mono_defaults.string_class && (!strcmp (ji->method->name, "memset") || strstr (ji->method->name, "memcpy")))
2032                 return;
2033
2034         save_thread_context (ctx);
2035
2036         suspend_current ();
2037 }
2038
2039 /*
2040  * suspend_vm:
2041  *
2042  * Increase the suspend count of the VM. While the suspend count is greater
2043  * than 0, runtime threads are suspended at certain points during execution.
2044  */
2045 static void
2046 suspend_vm (void)
2047 {
2048         mono_loader_lock ();
2049
2050         mono_mutex_lock (&suspend_mutex);
2051
2052         suspend_count ++;
2053
2054         DEBUG(1, fprintf (log_file, "[%p] Suspending vm...\n", (gpointer)GetCurrentThreadId ()));
2055
2056         if (suspend_count == 1) {
2057                 // FIXME: Is it safe to call this inside the lock ?
2058                 start_single_stepping ();
2059                 mono_g_hash_table_foreach (thread_to_tls, notify_thread, NULL);
2060         }
2061
2062         mono_mutex_unlock (&suspend_mutex);
2063
2064         mono_loader_unlock ();
2065 }
2066
2067 /*
2068  * resume_vm:
2069  *
2070  * Decrease the suspend count of the VM. If the count reaches 0, runtime threads
2071  * are resumed.
2072  */
2073 static void
2074 resume_vm (void)
2075 {
2076         int err;
2077
2078         g_assert (debugger_thread_id == GetCurrentThreadId ());
2079
2080         mono_loader_lock ();
2081
2082         mono_mutex_lock (&suspend_mutex);
2083
2084         g_assert (suspend_count > 0);
2085         suspend_count --;
2086
2087         DEBUG(1, fprintf (log_file, "[%p] Resuming vm...\n", (gpointer)GetCurrentThreadId ()));
2088
2089         if (suspend_count == 0) {
2090                 // FIXME: Is it safe to call this inside the lock ?
2091                 stop_single_stepping ();
2092                 mono_g_hash_table_foreach (thread_to_tls, reset_native_thread_suspend_state, NULL);
2093         }
2094
2095         /* Signal this even when suspend_count > 0, since some threads might have resume_count > 0 */
2096         err = mono_cond_broadcast (&suspend_cond);
2097         g_assert (err == 0);
2098
2099         mono_mutex_unlock (&suspend_mutex);
2100         //g_assert (err == 0);
2101
2102         mono_loader_unlock ();
2103 }
2104
2105 /*
2106  * resume_thread:
2107  *
2108  *   Resume just one thread.
2109  */
2110 static void
2111 resume_thread (MonoInternalThread *thread)
2112 {
2113         int err;
2114         DebuggerTlsData *tls;
2115
2116         g_assert (debugger_thread_id == GetCurrentThreadId ());
2117
2118         mono_loader_lock ();
2119
2120         tls = mono_g_hash_table_lookup (thread_to_tls, thread);
2121         g_assert (tls);
2122
2123         mono_mutex_lock (&suspend_mutex);
2124
2125         g_assert (suspend_count > 0);
2126
2127         DEBUG(1, fprintf (log_file, "[%p] Resuming thread...\n", (gpointer)(gssize)thread->tid));
2128
2129         tls->resume_count += suspend_count;
2130
2131         /*
2132          * Signal suspend_count without decreasing suspend_count, the threads will wake up
2133          * but only the one whose resume_count field is > 0 will be resumed.
2134          */
2135         err = mono_cond_broadcast (&suspend_cond);
2136         g_assert (err == 0);
2137
2138         mono_mutex_unlock (&suspend_mutex);
2139         //g_assert (err == 0);
2140
2141         mono_loader_unlock ();
2142 }
2143
2144 static void
2145 invalidate_frames (DebuggerTlsData *tls)
2146 {
2147         int i;
2148
2149         if (!tls)
2150                 tls = TlsGetValue (debugger_tls_id);
2151         g_assert (tls);
2152
2153         for (i = 0; i < tls->frame_count; ++i) {
2154                 if (tls->frames [i]->jit)
2155                         mono_debug_free_method_jit_info (tls->frames [i]->jit);
2156                 g_free (tls->frames [i]);
2157         }
2158         g_free (tls->frames);
2159         tls->frame_count = 0;
2160         tls->frames = NULL;
2161 }
2162
2163 /*
2164  * suspend_current:
2165  *
2166  *   Suspend the current thread until the runtime is resumed. If the thread has a
2167  * pending invoke, then the invoke is executed before this function returns.
2168  */
2169 static void
2170 suspend_current (void)
2171 {
2172         int err;
2173         DebuggerTlsData *tls;
2174
2175         g_assert (debugger_thread_id != GetCurrentThreadId ());
2176
2177         if (mono_loader_lock_is_owned_by_self ()) {
2178                 /*
2179                  * If we own the loader mutex, can't suspend until we release it, since the
2180                  * whole runtime can deadlock otherwise.
2181                  */
2182                 return;
2183         }
2184
2185         tls = TlsGetValue (debugger_tls_id);
2186         g_assert (tls);
2187
2188         mono_mutex_lock (&suspend_mutex);
2189
2190         tls->suspending = FALSE;
2191         tls->really_suspended = TRUE;
2192
2193         if (!tls->suspended) {
2194                 tls->suspended = TRUE;
2195                 MONO_SEM_POST (&suspend_sem);
2196         }
2197
2198         DEBUG(1, fprintf (log_file, "[%p] Suspended.\n", (gpointer)GetCurrentThreadId ()));
2199
2200         while (suspend_count - tls->resume_count > 0) {
2201 #ifdef HOST_WIN32
2202                 if (WAIT_TIMEOUT == WaitForSingleObject(suspend_cond, 0))
2203                 {
2204                         mono_mutex_unlock (&suspend_mutex);
2205                         Sleep(0);
2206                         mono_mutex_lock (&suspend_mutex);
2207                 }
2208                 else
2209                 {
2210                 }
2211 #else
2212                 err = mono_cond_wait (&suspend_cond, &suspend_mutex);
2213                 g_assert (err == 0);
2214 #endif
2215         }
2216
2217         tls->suspended = FALSE;
2218         tls->really_suspended = FALSE;
2219
2220         threads_suspend_count --;
2221
2222         mono_mutex_unlock (&suspend_mutex);
2223
2224         DEBUG(1, fprintf (log_file, "[%p] Resumed.\n", (gpointer)GetCurrentThreadId ()));
2225
2226         if (tls->pending_invoke) {
2227                 /* Save the original context */
2228                 tls->pending_invoke->has_ctx = TRUE;
2229                 memcpy (&tls->pending_invoke->ctx, &tls->ctx, sizeof (MonoContext));
2230
2231                 invoke_method ();
2232         }
2233
2234         /* The frame info becomes invalid after a resume */
2235         tls->has_context = FALSE;
2236         tls->has_async_ctx = FALSE;
2237         invalidate_frames (NULL);
2238 }
2239
2240 static void
2241 count_thread (gpointer key, gpointer value, gpointer user_data)
2242 {
2243         DebuggerTlsData *tls = value;
2244
2245         if (!tls->suspended && !tls->terminated)
2246                 *(int*)user_data = *(int*)user_data + 1;
2247 }
2248
2249 static int
2250 count_threads_to_wait_for (void)
2251 {
2252         int count = 0;
2253
2254         mono_loader_lock ();
2255         mono_g_hash_table_foreach (thread_to_tls, count_thread, &count);
2256         mono_loader_unlock ();
2257
2258         return count;
2259 }
2260
2261 /*
2262  * wait_for_suspend:
2263  *
2264  *   Wait until the runtime is completely suspended.
2265  */
2266 static void
2267 wait_for_suspend (void)
2268 {
2269         int nthreads, nwait, err;
2270         gboolean waited = FALSE;
2271
2272         // FIXME: Threads starting/stopping ?
2273         mono_loader_lock ();
2274         nthreads = mono_g_hash_table_size (thread_to_tls);
2275         mono_loader_unlock ();
2276
2277         while (TRUE) {
2278                 nwait = count_threads_to_wait_for ();
2279                 if (nwait) {
2280                         DEBUG(1, fprintf (log_file, "Waiting for %d(%d) threads to suspend...\n", nwait, nthreads));
2281                         err = MONO_SEM_WAIT (&suspend_sem);
2282                         g_assert (err == 0);
2283                         waited = TRUE;
2284                 } else {
2285                         break;
2286                 }
2287         }
2288
2289         if (waited)
2290                 DEBUG(1, fprintf (log_file, "%d threads suspended.\n", nthreads));
2291 }
2292
2293 /*
2294  * is_suspended:
2295  *
2296  *   Return whenever the runtime is suspended.
2297  */
2298 static gboolean
2299 is_suspended (void)
2300 {
2301         return count_threads_to_wait_for () == 0;
2302 }
2303
2304 /*
2305  * find_seq_point_for_native_offset:
2306  *
2307  *   Find the sequence point corresponding to the native offset NATIVE_OFFSET, which
2308  * should be the location of a sequence point.
2309  */
2310 static SeqPoint*
2311 find_seq_point_for_native_offset (MonoDomain *domain, MonoMethod *method, gint32 native_offset, MonoSeqPointInfo **info)
2312 {
2313         MonoSeqPointInfo *seq_points;
2314         int i;
2315
2316         mono_domain_lock (domain);
2317         seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, method);
2318         mono_domain_unlock (domain);
2319         g_assert (seq_points);
2320
2321         *info = seq_points;
2322
2323         for (i = 0; i < seq_points->len; ++i) {
2324                 if (seq_points->seq_points [i].native_offset == native_offset)
2325                         return &seq_points->seq_points [i];
2326         }
2327
2328         return NULL;
2329 }
2330
2331 /*
2332  * find_seq_point:
2333  *
2334  *   Find the sequence point corresponding to the IL offset IL_OFFSET, which
2335  * should be the location of a sequence point.
2336  */
2337 static SeqPoint*
2338 find_seq_point (MonoDomain *domain, MonoMethod *method, gint32 il_offset, MonoSeqPointInfo **info)
2339 {
2340         MonoSeqPointInfo *seq_points;
2341         int i;
2342
2343         mono_domain_lock (domain);
2344         seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, method);
2345         mono_domain_unlock (domain);
2346         g_assert (seq_points);
2347
2348         *info = seq_points;
2349
2350         for (i = 0; i < seq_points->len; ++i) {
2351                 if (seq_points->seq_points [i].il_offset == il_offset)
2352                         return &seq_points->seq_points [i];
2353         }
2354
2355         return NULL;
2356 }
2357
2358 /*
2359  * compute_il_offset:
2360  *
2361  *    Compute the IL offset corresponding to NATIVE_OFFSET, which should be
2362  * a location of a sequence point.
2363  * We use this function instead of mono_debug_il_offset_from_address () etc,
2364  * which doesn't seem to work in a lot of cases.
2365  */
2366 static gint32
2367 compute_il_offset (MonoDomain *domain, MonoMethod *method, gint32 native_offset)
2368 {
2369         MonoSeqPointInfo *seq_points;
2370         int i, last_il_offset, seq_il_offset, seq_native_offset;
2371
2372         mono_domain_lock (domain);
2373         seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, method);
2374         mono_domain_unlock (domain);
2375         g_assert (seq_points);
2376
2377         last_il_offset = -1;
2378
2379         /* Find the sequence point */
2380         for (i = 0; i < seq_points->len; ++i) {
2381                 seq_il_offset = seq_points->seq_points [i].il_offset;
2382                 seq_native_offset = seq_points->seq_points [i].native_offset;
2383
2384                 if (seq_native_offset > native_offset)
2385                         break;
2386                 last_il_offset = seq_il_offset;
2387         }
2388
2389         return last_il_offset;
2390 }
2391
2392 typedef struct {
2393         DebuggerTlsData *tls;
2394         GSList *frames;
2395 } ComputeFramesUserData;
2396
2397 static gboolean
2398 process_frame (StackFrameInfo *info, MonoContext *ctx, gpointer user_data)
2399 {
2400         ComputeFramesUserData *ud = user_data;
2401         StackFrame *frame;
2402         MonoMethod *method;
2403
2404         if (info->type != FRAME_TYPE_MANAGED) {
2405                 if (info->type == FRAME_TYPE_DEBUGGER_INVOKE) {
2406                         /* Mark the last frame as an invoke frame */
2407                         if (ud->frames)
2408                                 ((StackFrame*)g_slist_last (ud->frames)->data)->flags |= FRAME_FLAG_DEBUGGER_INVOKE;
2409                 }
2410                 return FALSE;
2411         }
2412
2413         if (info->ji)
2414                 method = info->ji->method;
2415         else
2416                 method = info->method;
2417
2418         if (!method || (method->wrapper_type && method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD))
2419                 return FALSE;
2420
2421         if (info->il_offset == -1) {
2422                 /* Can't use compute_il_offset () since ip doesn't point precisely at at a seq point */
2423                 info->il_offset = mono_debug_il_offset_from_address (method, info->domain, info->native_offset);
2424         }
2425
2426         DEBUG (1, fprintf (log_file, "\tFrame: %s %d %d %d\n", mono_method_full_name (method, TRUE), info->native_offset, info->il_offset, info->managed));
2427
2428         if (!info->managed && method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD) {
2429                 /*
2430                  * mono_arch_find_jit_info () returns the context stored in the LMF for
2431                  * native frames, but it should unwind once. This is why we have duplicate
2432                  * frames on the stack sometimes.
2433                  * !managed also seems to be set for dynamic methods.
2434                  */
2435                 return FALSE;
2436         }
2437
2438         frame = g_new0 (StackFrame, 1);
2439         frame->method = method;
2440         frame->il_offset = info->il_offset;
2441         if (ctx) {
2442                 frame->ctx = *ctx;
2443                 frame->has_ctx = TRUE;
2444         }
2445         frame->domain = info->domain;
2446
2447         ud->frames = g_slist_append (ud->frames, frame);
2448
2449         return FALSE;
2450 }
2451
2452 static void
2453 compute_frame_info (MonoInternalThread *thread, DebuggerTlsData *tls)
2454 {
2455         ComputeFramesUserData user_data;
2456         GSList *tmp;
2457         int i, findex, new_frame_count;
2458         StackFrame **new_frames, *f;
2459
2460         // FIXME: Locking on tls
2461         if (tls->frames && tls->frames_up_to_date)
2462                 return;
2463
2464         DEBUG(1, fprintf (log_file, "Frames for %p(tid=%lx):\n", thread, (glong)thread->tid));
2465
2466         user_data.tls = tls;
2467         user_data.frames = NULL;
2468         if (tls->terminated) {
2469                 tls->frame_count = 0;
2470                 return;
2471         } if (!tls->really_suspended && tls->has_async_ctx) {
2472                 /* Have to use the state saved by the signal handler */
2473                 process_frame (&tls->async_last_frame, NULL, &user_data);
2474                 mono_jit_walk_stack_from_ctx_in_thread (process_frame, tls->domain, &tls->async_ctx, FALSE, thread, tls->async_lmf, &user_data);
2475         } else if (tls->has_context) {
2476                 mono_jit_walk_stack_from_ctx_in_thread (process_frame, tls->domain, &tls->ctx, FALSE, thread, tls->lmf, &user_data);
2477         } else {
2478                 // FIXME:
2479                 tls->frame_count = 0;
2480                 return;
2481         }
2482
2483         new_frame_count = g_slist_length (user_data.frames);
2484         new_frames = g_new0 (StackFrame*, new_frame_count);
2485         findex = 0;
2486         for (tmp = user_data.frames; tmp; tmp = tmp->next) {
2487                 f = tmp->data;
2488
2489                 /*
2490                  * Reuse the id for already existing stack frames, so invokes don't invalidate
2491                  * the still valid stack frames.
2492                  */
2493                 for (i = 0; i < tls->frame_count; ++i) {
2494                         if (MONO_CONTEXT_GET_SP (&tls->frames [i]->ctx) == MONO_CONTEXT_GET_SP (&f->ctx)) {
2495                                 f->id = tls->frames [i]->id;
2496                                 break;
2497                         }
2498                 }
2499
2500                 if (i >= tls->frame_count)
2501                         f->id = InterlockedIncrement (&frame_id);
2502
2503                 new_frames [findex ++] = f;
2504         }
2505
2506         g_slist_free (user_data.frames);
2507
2508         invalidate_frames (tls);
2509
2510         tls->frames = new_frames;
2511         tls->frame_count = new_frame_count;
2512         tls->frames_up_to_date = TRUE;
2513 }
2514
2515 /*
2516  * EVENT HANDLING
2517  */
2518
2519 /*
2520  * create_event_list:
2521  *
2522  *   Return a list of event request ids matching EVENT, starting from REQS, which
2523  * can be NULL to include all event requests. Set SUSPEND_POLICY to the suspend
2524  * policy.
2525  * We return request ids, instead of requests, to simplify threading, since
2526  * requests could be deleted anytime when the loader lock is not held.
2527  * LOCKING: Assumes the loader lock is held.
2528  */
2529 static GSList*
2530 create_event_list (EventKind event, GPtrArray *reqs, MonoJitInfo *ji, EventInfo *ei, int *suspend_policy)
2531 {
2532         int i, j;
2533         GSList *events = NULL;
2534
2535         *suspend_policy = SUSPEND_POLICY_NONE;
2536
2537         if (!reqs)
2538                 reqs = event_requests;
2539
2540         if (!reqs)
2541                 return NULL;
2542
2543         for (i = 0; i < reqs->len; ++i) {
2544                 EventRequest *req = g_ptr_array_index (reqs, i);
2545                 if (req->event_kind == event) {
2546                         gboolean filtered = FALSE;
2547
2548                         /* Apply filters */
2549                         for (j = 0; j < req->nmodifiers; ++j) {
2550                                 Modifier *mod = &req->modifiers [j];
2551
2552                                 if (mod->kind == MOD_KIND_COUNT) {
2553                                         filtered = TRUE;
2554                                         if (mod->data.count > 0) {
2555                                                 if (mod->data.count > 0) {
2556                                                         mod->data.count --;
2557                                                         if (mod->data.count == 0)
2558                                                                 filtered = FALSE;
2559                                                 }
2560                                         }
2561                                 } else if (mod->kind == MOD_KIND_THREAD_ONLY) {
2562                                         if (mod->data.thread != mono_thread_internal_current ())
2563                                                 filtered = TRUE;
2564                                 } else if (mod->kind == MOD_KIND_EXCEPTION_ONLY && ei) {
2565                                         if (mod->data.exc_class && !mono_class_is_assignable_from (mod->data.exc_class, ei->exc->vtable->klass))
2566                                                 filtered = TRUE;
2567                                         if (ei->caught && !mod->caught)
2568                                                 filtered = TRUE;
2569                                         if (!ei->caught && !mod->uncaught)
2570                                                 filtered = TRUE;
2571                                 } else if (mod->kind == MOD_KIND_ASSEMBLY_ONLY && ji) {
2572                                         int k;
2573                                         gboolean found = FALSE;
2574                                         MonoAssembly **assemblies = mod->data.assemblies;
2575
2576                                         if (assemblies) {
2577                                                 for (k = 0; assemblies [k]; ++k)
2578                                                         if (assemblies [k] == ji->method->klass->image->assembly)
2579                                                                 found = TRUE;
2580                                         }
2581                                         if (!found)
2582                                                 filtered = TRUE;
2583                                 }
2584                         }
2585
2586                         if (!filtered) {
2587                                 *suspend_policy = MAX (*suspend_policy, req->suspend_policy);
2588                                 events = g_slist_append (events, GINT_TO_POINTER (req->id));
2589                         }
2590                 }
2591         }
2592
2593         /* Send a VM START/DEATH event by default */
2594         if (event == EVENT_KIND_VM_START)
2595                 events = g_slist_append (events, GINT_TO_POINTER (0));
2596         if (event == EVENT_KIND_VM_DEATH)
2597                 events = g_slist_append (events, GINT_TO_POINTER (0));
2598
2599         return events;
2600 }
2601
2602 static G_GNUC_UNUSED const char*
2603 event_to_string (EventKind event)
2604 {
2605         switch (event) {
2606         case EVENT_KIND_VM_START: return "VM_START";
2607         case EVENT_KIND_VM_DEATH: return "VM_DEATH";
2608         case EVENT_KIND_THREAD_START: return "THREAD_START";
2609         case EVENT_KIND_THREAD_DEATH: return "THREAD_DEATH";
2610         case EVENT_KIND_APPDOMAIN_CREATE: return "APPDOMAIN_CREATE";
2611         case EVENT_KIND_APPDOMAIN_UNLOAD: return "APPDOMAIN_UNLOAD";
2612         case EVENT_KIND_METHOD_ENTRY: return "METHOD_ENTRY";
2613         case EVENT_KIND_METHOD_EXIT: return "METHOD_EXIT";
2614         case EVENT_KIND_ASSEMBLY_LOAD: return "ASSEMBLY_LOAD";
2615         case EVENT_KIND_ASSEMBLY_UNLOAD: return "ASSEMBLY_UNLOAD";
2616         case EVENT_KIND_BREAKPOINT: return "BREAKPOINT";
2617         case EVENT_KIND_STEP: return "STEP";
2618         case EVENT_KIND_TYPE_LOAD: return "TYPE_LOAD";
2619         case EVENT_KIND_EXCEPTION: return "EXCEPTION";
2620         default:
2621                 g_assert_not_reached ();
2622         }
2623 }
2624
2625 /*
2626  * process_event:
2627  *
2628  *   Send an event to the client, suspending the vm if needed.
2629  * LOCKING: Since this can suspend the calling thread, no locks should be held
2630  * by the caller.
2631  * The EVENTS list is freed by this function.
2632  */
2633 static void
2634 process_event (EventKind event, gpointer arg, gint32 il_offset, MonoContext *ctx, GSList *events, int suspend_policy)
2635 {
2636         Buffer buf;
2637         GSList *l;
2638         MonoDomain *domain = mono_domain_get ();
2639         MonoThread *thread;
2640
2641         if (!inited)
2642                 return;
2643
2644         if (!vm_start_event_sent && event != EVENT_KIND_VM_START)
2645                 // FIXME: We miss those events
2646                 return;
2647
2648         if (vm_death_event_sent)
2649                 return;
2650
2651         if (mono_runtime_is_shutting_down () && event != EVENT_KIND_VM_DEATH)
2652                 return;
2653
2654         if (disconnected)
2655                 return;
2656
2657         if (events == NULL)
2658                 return;
2659
2660         if (debugger_thread_id == GetCurrentThreadId () && event != EVENT_KIND_VM_DEATH)
2661                 // FIXME: Send these with a NULL thread, don't suspend the current thread
2662                 return;
2663
2664         buffer_init (&buf, 128);
2665         buffer_add_byte (&buf, suspend_policy);
2666         buffer_add_int (&buf, g_slist_length (events)); // n of events
2667
2668         for (l = events; l; l = l->next) {
2669                 buffer_add_byte (&buf, event); // event kind
2670                 buffer_add_int (&buf, GPOINTER_TO_INT (l->data)); // request id
2671
2672                 thread = mono_thread_current ();
2673
2674                 if (event == EVENT_KIND_VM_START)
2675                         thread = arg;
2676                 else if (event == EVENT_KIND_THREAD_START)
2677                         g_assert (mono_thread_internal_current () == arg);
2678
2679                 buffer_add_objid (&buf, (MonoObject*)thread); // thread
2680
2681                 switch (event) {
2682                 case EVENT_KIND_THREAD_START:
2683                 case EVENT_KIND_THREAD_DEATH:
2684                         break;
2685                 case EVENT_KIND_APPDOMAIN_CREATE:
2686                 case EVENT_KIND_APPDOMAIN_UNLOAD:
2687                         buffer_add_domainid (&buf, arg);
2688                         break;
2689                 case EVENT_KIND_METHOD_ENTRY:
2690                 case EVENT_KIND_METHOD_EXIT:
2691                         buffer_add_methodid (&buf, domain, arg);
2692                         break;
2693                 case EVENT_KIND_ASSEMBLY_LOAD:
2694                 case EVENT_KIND_ASSEMBLY_UNLOAD:
2695                         buffer_add_assemblyid (&buf, domain, arg);
2696                         break;
2697                 case EVENT_KIND_TYPE_LOAD:
2698                         buffer_add_typeid (&buf, domain, arg);
2699                         break;
2700                 case EVENT_KIND_BREAKPOINT:
2701                 case EVENT_KIND_STEP:
2702                         buffer_add_methodid (&buf, domain, arg);
2703                         buffer_add_long (&buf, il_offset);
2704                         break;
2705                 case EVENT_KIND_VM_START:
2706                         buffer_add_domainid (&buf, mono_get_root_domain ());
2707                         break;
2708                 case EVENT_KIND_VM_DEATH:
2709                         break;
2710                 case EVENT_KIND_EXCEPTION: {
2711                         EventInfo *ei = arg;
2712                         buffer_add_objid (&buf, ei->exc);
2713                         break;
2714                 }
2715                 default:
2716                         g_assert_not_reached ();
2717                 }
2718         }
2719
2720         if (event == EVENT_KIND_VM_START) {
2721                 suspend_policy = agent_config.suspend ? SUSPEND_POLICY_ALL : SUSPEND_POLICY_NONE;
2722                 start_debugger_thread ();
2723         }
2724
2725         if (event == EVENT_KIND_VM_DEATH) {
2726                 vm_death_event_sent = TRUE;
2727
2728                 suspend_policy = SUSPEND_POLICY_NONE;
2729         }
2730
2731         if (mono_runtime_is_shutting_down ())
2732                 suspend_policy = SUSPEND_POLICY_NONE;
2733
2734         if (suspend_policy != SUSPEND_POLICY_NONE) {
2735                 /*
2736                  * Save the thread context and start suspending before sending the packet,
2737                  * since we could be receiving the resume request before send_packet ()
2738                  * returns.
2739                  */
2740                 save_thread_context (ctx);
2741                 suspend_vm ();
2742         }
2743
2744         send_packet (CMD_SET_EVENT, CMD_COMPOSITE, &buf);
2745
2746         g_slist_free (events);
2747         events = NULL;
2748
2749         if (event == EVENT_KIND_VM_START)
2750                 vm_start_event_sent = TRUE;
2751
2752         DEBUG (1, fprintf (log_file, "[%p] Sent event %s, suspend=%d.\n", (gpointer)GetCurrentThreadId (), event_to_string (event), suspend_policy));
2753
2754         buffer_free (&buf);
2755
2756         switch (suspend_policy) {
2757         case SUSPEND_POLICY_NONE:
2758                 break;
2759         case SUSPEND_POLICY_ALL:
2760                 suspend_current ();
2761                 break;
2762         case SUSPEND_POLICY_EVENT_THREAD:
2763                 NOT_IMPLEMENTED;
2764                 break;
2765         default:
2766                 g_assert_not_reached ();
2767         }
2768 }
2769
2770 static void
2771 process_profiler_event (EventKind event, gpointer arg)
2772 {
2773         int suspend_policy;
2774         GSList *events;
2775
2776         mono_loader_lock ();
2777         events = create_event_list (event, NULL, NULL, NULL, &suspend_policy);
2778         mono_loader_unlock ();
2779
2780         process_event (event, arg, 0, NULL, events, suspend_policy);
2781 }
2782
2783 static void
2784 runtime_initialized (MonoProfiler *prof)
2785 {
2786         process_profiler_event (EVENT_KIND_VM_START, mono_thread_current ());
2787 }
2788
2789 static void
2790 runtime_shutdown (MonoProfiler *prof)
2791 {
2792         process_profiler_event (EVENT_KIND_VM_DEATH, mono_thread_current ());
2793
2794         mono_debugger_agent_cleanup ();
2795 }
2796
2797 static void
2798 thread_startup (MonoProfiler *prof, intptr_t tid)
2799 {
2800         MonoInternalThread *thread = mono_thread_internal_current ();
2801         MonoInternalThread *old_thread;
2802         DebuggerTlsData *tls;
2803
2804         if (tid == debugger_thread_id)
2805                 return;
2806
2807         g_assert (thread->tid == tid);
2808
2809         mono_loader_lock ();
2810         old_thread = mono_g_hash_table_lookup (tid_to_thread, (gpointer)tid);
2811         mono_loader_unlock ();
2812         if (old_thread) {
2813                 if (thread == old_thread) {
2814                         /*
2815                          * For some reason, thread_startup () might be called for the same thread
2816                          * multiple times (attach ?).
2817                          */
2818                         DEBUG (1, fprintf (log_file, "[%p] thread_start () called multiple times for %p, ignored.\n", (gpointer)tid, (gpointer)tid));
2819                         return;
2820                 } else {
2821                         /*
2822                          * thread_end () might not be called for some threads, and the tid could
2823                          * get reused.
2824                          */
2825                         DEBUG (1, fprintf (log_file, "[%p] Removing stale data for tid %p.\n", (gpointer)tid, (gpointer)tid));
2826                         mono_loader_lock ();
2827                         mono_g_hash_table_remove (thread_to_tls, old_thread);
2828                         mono_g_hash_table_remove (tid_to_thread, (gpointer)tid);
2829                         mono_g_hash_table_remove (tid_to_thread_obj, (gpointer)tid);
2830                         mono_loader_unlock ();
2831                 }
2832         }
2833
2834         tls = TlsGetValue (debugger_tls_id);
2835         g_assert (!tls);
2836         // FIXME: Free this somewhere
2837         tls = g_new0 (DebuggerTlsData, 1);
2838         tls->resume_event = CreateEvent (NULL, FALSE, FALSE, NULL);
2839         MONO_GC_REGISTER_ROOT (tls->thread);
2840         tls->thread = thread;
2841         TlsSetValue (debugger_tls_id, tls);
2842
2843         DEBUG (1, fprintf (log_file, "[%p] Thread started, obj=%p, tls=%p.\n", (gpointer)tid, thread, tls));
2844
2845         mono_loader_lock ();
2846         mono_g_hash_table_insert (thread_to_tls, thread, tls);
2847         mono_g_hash_table_insert (tid_to_thread, (gpointer)tid, thread);
2848         mono_g_hash_table_insert (tid_to_thread_obj, (gpointer)tid, mono_thread_current ());
2849         mono_loader_unlock ();
2850
2851         process_profiler_event (EVENT_KIND_THREAD_START, thread);
2852
2853         /*
2854          * suspend_vm () could have missed this thread, so wait for a resume.
2855          */
2856         suspend_current ();
2857 }
2858
2859 static void
2860 thread_end (MonoProfiler *prof, intptr_t tid)
2861 {
2862         MonoInternalThread *thread;
2863         DebuggerTlsData *tls = NULL;
2864
2865         mono_loader_lock ();
2866         thread = mono_g_hash_table_lookup (tid_to_thread, (gpointer)tid);
2867         if (thread) {
2868                 tls = mono_g_hash_table_lookup (thread_to_tls, thread);
2869                 /* FIXME: Maybe we need to free this instead, but some code can't handle that */
2870                 tls->terminated = TRUE;
2871                 mono_g_hash_table_remove (tid_to_thread_obj, (gpointer)tid);
2872                 /* Can't remove from tid_to_thread, as that would defeat the check in thread_start () */
2873                 MONO_GC_UNREGISTER_ROOT (tls->thread);
2874                 tls->thread = NULL;
2875         }
2876         mono_loader_unlock ();
2877
2878         /* We might be called for threads started before we registered the start callback */
2879         if (thread) {
2880                 DEBUG (1, fprintf (log_file, "[%p] Thread terminated, obj=%p, tls=%p.\n", (gpointer)tid, thread, tls));
2881                 process_profiler_event (EVENT_KIND_THREAD_DEATH, thread);
2882         }
2883 }
2884
2885 static void
2886 appdomain_load (MonoProfiler *prof, MonoDomain *domain, int result)
2887 {
2888         process_profiler_event (EVENT_KIND_APPDOMAIN_CREATE, domain);
2889 }
2890
2891 static void
2892 appdomain_unload (MonoProfiler *prof, MonoDomain *domain)
2893 {
2894         /* Invalidate each thread's frame stack */
2895         mono_g_hash_table_foreach (thread_to_tls, invalidate_each_thread, NULL);
2896         process_profiler_event (EVENT_KIND_APPDOMAIN_UNLOAD, domain);
2897 }
2898
2899 /*
2900  * invalidate_each_thread:
2901  *
2902  *   A GHFunc to invalidate frames.
2903  *   value must be a DebuggerTlsData*
2904  */
2905 static void
2906 invalidate_each_thread (gpointer key, gpointer value, gpointer user_data)
2907 {
2908         invalidate_frames (value);
2909 }
2910
2911 static void
2912 assembly_load (MonoProfiler *prof, MonoAssembly *assembly, int result)
2913 {
2914         /* Sent later in jit_end () */
2915         mono_loader_lock ();
2916         g_ptr_array_add (pending_assembly_loads, assembly);
2917         mono_loader_unlock ();
2918 }
2919
2920 static void
2921 assembly_unload (MonoProfiler *prof, MonoAssembly *assembly)
2922 {
2923         process_profiler_event (EVENT_KIND_ASSEMBLY_UNLOAD, assembly);
2924
2925         clear_event_requests_for_assembly (assembly);
2926 }
2927
2928 static void
2929 start_runtime_invoke (MonoProfiler *prof, MonoMethod *method)
2930 {
2931 #if defined(HOST_WIN32) && !defined(__GNUC__)
2932         gpointer stackptr = ((guint64)_AddressOfReturnAddress () - sizeof (void*));
2933 #else
2934         gpointer stackptr = __builtin_frame_address (1);
2935 #endif
2936         MonoInternalThread *thread = mono_thread_internal_current ();
2937         DebuggerTlsData *tls;
2938
2939         mono_loader_lock ();
2940
2941         tls = mono_g_hash_table_lookup (thread_to_tls, thread);
2942         /* Could be the debugger thread with assembly/type load hooks */
2943         if (tls)
2944                 tls->invoke_addr = stackptr;
2945
2946         mono_loader_unlock ();
2947 }
2948
2949 static void
2950 end_runtime_invoke (MonoProfiler *prof, MonoMethod *method)
2951 {
2952         int i;
2953 #if defined(HOST_WIN32) && !defined(__GNUC__)
2954         gpointer stackptr = ((guint64)_AddressOfReturnAddress () - sizeof (void*));
2955 #else
2956         gpointer stackptr = __builtin_frame_address (1);
2957 #endif
2958
2959         if (ss_req == NULL || stackptr != ss_invoke_addr || ss_req->thread != mono_thread_internal_current ())
2960                 return;
2961
2962         /*
2963          * We need to stop single stepping when exiting a runtime invoke, since if it is
2964          * a step out, it may return to native code, and thus never end.
2965          */
2966         mono_loader_lock ();
2967         ss_invoke_addr = NULL;
2968
2969         for (i = 0; i < event_requests->len; ++i) {
2970                 EventRequest *req = g_ptr_array_index (event_requests, i);
2971
2972                 if (req->event_kind == EVENT_KIND_STEP) {
2973                         ss_destroy (req->info);
2974                         g_ptr_array_remove_index_fast (event_requests, i);
2975                         g_free (req);
2976                         break;
2977                 }
2978         }
2979         mono_loader_unlock ();
2980 }
2981
2982 static void
2983 send_type_load (MonoClass *klass)
2984 {
2985         gboolean type_load = FALSE;
2986
2987         mono_loader_lock ();
2988         if (!g_hash_table_lookup (loaded_classes, klass)) {
2989                 type_load = TRUE;
2990                 g_hash_table_insert (loaded_classes, klass, klass);
2991         }
2992         mono_loader_unlock ();
2993         if (type_load)
2994                 process_profiler_event (EVENT_KIND_TYPE_LOAD, klass);
2995 }
2996
2997 static void
2998 jit_end (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo, int result)
2999 {
3000         /*
3001          * We emit type load events when the first method of the type is JITted,
3002          * since the class load profiler callbacks might be called with the
3003          * loader lock held. They could also occur in the debugger thread.
3004          * Same for assembly load events.
3005          */
3006         while (TRUE) {
3007                 MonoAssembly *assembly = NULL;
3008
3009                 // FIXME: Maybe store this in TLS so the thread of the event is correct ?
3010                 mono_loader_lock ();
3011                 if (pending_assembly_loads->len > 0) {
3012                         assembly = g_ptr_array_index (pending_assembly_loads, 0);
3013                         g_ptr_array_remove_index (pending_assembly_loads, 0);
3014                 }
3015                 mono_loader_unlock ();
3016
3017                 if (assembly)
3018                         process_profiler_event (EVENT_KIND_ASSEMBLY_LOAD, assembly);
3019                 else
3020                         break;
3021         }
3022
3023         if (!vm_start_event_sent) {
3024                 /* Save these so they can be sent after the vm start event */
3025                 mono_loader_lock ();
3026                 g_ptr_array_add (pending_type_loads, method->klass);
3027                 mono_loader_unlock ();
3028         } else {
3029                 /* Send all pending type load events */
3030                 MonoClass *klass;
3031                 while (TRUE) {
3032                         klass = NULL;
3033                         mono_loader_lock ();
3034                         if (pending_type_loads->len > 0) {
3035                                 klass = g_ptr_array_index (pending_type_loads, 0);
3036                                 g_ptr_array_remove_index (pending_type_loads, 0);
3037                         }
3038                         mono_loader_unlock ();
3039                         if (klass)
3040                                 send_type_load (klass);
3041                         else
3042                                 break;
3043                 }
3044
3045                 send_type_load (method->klass);
3046         }
3047
3048         if (!result)
3049                 add_pending_breakpoints (method, jinfo);
3050 }
3051
3052 /*
3053  * BREAKPOINTS/SINGLE STEPPING
3054  */
3055
3056 /*
3057  * Contains information about an inserted breakpoint.
3058  */
3059 typedef struct {
3060         long il_offset, native_offset;
3061         guint8 *ip;
3062         MonoJitInfo *ji;
3063 } BreakpointInstance;
3064
3065 /*
3066  * Contains generic information about a breakpoint.
3067  */
3068 typedef struct {
3069         /*
3070          * The method where the breakpoint is placed. Can be NULL in which case it
3071          * is inserted into every method. This is used to implement method entry/
3072          * exit events. Can be a generic method definition, in which case the
3073          * breakpoint is inserted into every instance.
3074          */
3075         MonoMethod *method;
3076         long il_offset;
3077         EventRequest *req;
3078         /*
3079          * A list of BreakpointInstance structures describing where the breakpoint
3080          * was inserted. There could be more than one because of
3081          * generics/appdomains/method entry/exit.
3082          */
3083         GPtrArray *children;
3084 } MonoBreakpoint;
3085
3086 /* List of breakpoints */
3087 static GPtrArray *breakpoints;
3088 /* Maps breakpoint locations to the number of breakpoints at that location */
3089 static GHashTable *bp_locs;
3090
3091 static void
3092 breakpoints_init (void)
3093 {
3094         breakpoints = g_ptr_array_new ();
3095         bp_locs = g_hash_table_new (NULL, NULL);
3096 }
3097
3098 static void
3099 breakpoints_cleanup (void)
3100 {
3101         int i;
3102
3103         mono_loader_lock ();
3104
3105         for (i = 0; i < breakpoints->len; ++i)
3106                 g_free (g_ptr_array_index (breakpoints, i));
3107
3108         g_ptr_array_free (breakpoints, TRUE);
3109         g_hash_table_destroy (bp_locs);
3110
3111         mono_loader_unlock ();
3112 }
3113
3114 /*
3115  * insert_breakpoint:
3116  *
3117  *   Insert the breakpoint described by BP into the method described by
3118  * JI.
3119  */
3120 static void
3121 insert_breakpoint (MonoSeqPointInfo *seq_points, MonoJitInfo *ji, MonoBreakpoint *bp)
3122 {
3123         int i, count;
3124         gint32 il_offset = -1, native_offset;
3125         BreakpointInstance *inst;
3126
3127         native_offset = 0;
3128         for (i = 0; i < seq_points->len; ++i) {
3129                 il_offset = seq_points->seq_points [i].il_offset;
3130                 native_offset = seq_points->seq_points [i].native_offset;
3131
3132                 if (il_offset == bp->il_offset)
3133                         break;
3134         }
3135
3136         if (i == seq_points->len)
3137                 /* Have to handle this somehow */
3138                 NOT_IMPLEMENTED;
3139
3140         inst = g_new0 (BreakpointInstance, 1);
3141         inst->native_offset = native_offset;
3142         inst->ip = (guint8*)ji->code_start + native_offset;
3143         inst->ji = ji;
3144
3145         mono_loader_lock ();
3146
3147         g_ptr_array_add (bp->children, inst);
3148
3149         count = GPOINTER_TO_INT (g_hash_table_lookup (bp_locs, inst->ip));
3150         g_hash_table_insert (bp_locs, inst->ip, GINT_TO_POINTER (count + 1));
3151         mono_loader_unlock ();
3152
3153         if (count == 0) {
3154 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
3155                 mono_arch_set_breakpoint (ji, inst->ip);
3156 #else
3157                 NOT_IMPLEMENTED;
3158 #endif
3159         }
3160
3161         DEBUG(1, fprintf (log_file, "[dbg] Inserted breakpoint at %s:0x%x.\n", mono_method_full_name (ji->method, TRUE), (int)il_offset));
3162 }
3163
3164 static void
3165 remove_breakpoint (BreakpointInstance *inst)
3166 {
3167 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
3168         int count;
3169         MonoJitInfo *ji = inst->ji;
3170         guint8 *ip = inst->ip;
3171
3172         mono_loader_lock ();
3173         count = GPOINTER_TO_INT (g_hash_table_lookup (bp_locs, ip));
3174         g_hash_table_insert (bp_locs, ip, GINT_TO_POINTER (count - 1));
3175         mono_loader_unlock ();
3176
3177         g_assert (count > 0);
3178
3179         if (count == 1) {
3180                 mono_arch_clear_breakpoint (ji, ip);
3181         }
3182 #else
3183         NOT_IMPLEMENTED;
3184 #endif
3185 }
3186
3187 static inline gboolean
3188 bp_matches_method (MonoBreakpoint *bp, MonoMethod *method)
3189 {
3190         return (!bp->method || method == bp->method || (method->is_inflated && ((MonoMethodInflated*)method)->declaring == bp->method));
3191 }
3192
3193 /*
3194  * add_pending_breakpoints:
3195  *
3196  *   Insert pending breakpoints into the newly JITted method METHOD.
3197  */
3198 static void
3199 add_pending_breakpoints (MonoMethod *method, MonoJitInfo *ji)
3200 {
3201         int i, j;
3202         MonoSeqPointInfo *seq_points;
3203         MonoDomain *domain;
3204
3205         if (!breakpoints)
3206                 return;
3207
3208         domain = mono_domain_get ();
3209
3210         mono_loader_lock ();
3211
3212         for (i = 0; i < breakpoints->len; ++i) {
3213                 MonoBreakpoint *bp = g_ptr_array_index (breakpoints, i);
3214                 gboolean found = FALSE;
3215
3216                 if (!bp_matches_method (bp, method))
3217                         continue;
3218
3219                 for (j = 0; j < bp->children->len; ++j) {
3220                         BreakpointInstance *inst = g_ptr_array_index (bp->children, j);
3221
3222                         if (inst->ji == ji)
3223                                 found = TRUE;
3224                 }
3225
3226                 if (!found) {
3227                         mono_domain_lock (domain);
3228                         seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, ji->method);
3229                         mono_domain_unlock (domain);
3230                         if (!seq_points)
3231                                 /* Could be AOT code */
3232                                 continue;
3233                         g_assert (seq_points);
3234
3235                         insert_breakpoint (seq_points, ji, bp);
3236                 }
3237         }
3238
3239         mono_loader_unlock ();
3240 }
3241
3242 static void
3243 set_bp_in_method (MonoDomain *domain, MonoMethod *method, MonoSeqPointInfo *seq_points, MonoBreakpoint *bp)
3244 {
3245         gpointer code;
3246         MonoJitInfo *ji;
3247
3248         code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
3249         if (!code) {
3250                 /* Might be AOTed code */
3251                 code = mono_aot_get_method (domain, method);
3252                 g_assert (code);
3253                 ji = mono_jit_info_table_find (domain, code);
3254                 g_assert (ji);
3255         }
3256         g_assert (code);
3257
3258         insert_breakpoint (seq_points, ji, bp);
3259 }
3260
3261 static void
3262 set_bp_in_method_cb (gpointer key, gpointer value, gpointer user_data)
3263 {
3264         MonoMethod *method = key;
3265         MonoSeqPointInfo *seq_points = value;
3266         MonoBreakpoint *bp = user_data;
3267         MonoDomain *domain = mono_domain_get ();
3268
3269         if (bp_matches_method (bp, method))
3270                 set_bp_in_method (domain, method, seq_points, bp);
3271 }
3272
3273 /*
3274  * set_breakpoint:
3275  *
3276  *   Set a breakpoint at IL_OFFSET in METHOD.
3277  * METHOD can be NULL, in which case a breakpoint is placed in all methods.
3278  * METHOD can also be a generic method definition, in which case a breakpoint
3279  * is placed in all instances of the method.
3280  */
3281 static MonoBreakpoint*
3282 set_breakpoint (MonoMethod *method, long il_offset, EventRequest *req)
3283 {
3284         MonoDomain *domain;
3285         MonoBreakpoint *bp;
3286
3287         // FIXME:
3288         // - suspend/resume the vm to prevent code patching problems
3289         // - multiple breakpoints on the same location
3290         // - dynamic methods
3291         // - races
3292
3293         bp = g_new0 (MonoBreakpoint, 1);
3294         bp->method = method;
3295         bp->il_offset = il_offset;
3296         bp->req = req;
3297         bp->children = g_ptr_array_new ();
3298
3299         DEBUG(1, fprintf (log_file, "[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));
3300
3301         domain = mono_domain_get ();
3302         mono_domain_lock (domain);
3303         g_hash_table_foreach (domain_jit_info (domain)->seq_points, set_bp_in_method_cb, bp);
3304         mono_domain_unlock (domain);
3305
3306         mono_loader_lock ();
3307         g_ptr_array_add (breakpoints, bp);
3308         mono_loader_unlock ();
3309
3310         return bp;
3311 }
3312
3313 static void
3314 clear_breakpoint (MonoBreakpoint *bp)
3315 {
3316         int i;
3317
3318         // FIXME: locking, races
3319         for (i = 0; i < bp->children->len; ++i) {
3320                 BreakpointInstance *inst = g_ptr_array_index (bp->children, i);
3321
3322                 remove_breakpoint (inst);
3323
3324                 g_free (inst);
3325         }
3326
3327         mono_loader_lock ();
3328         g_ptr_array_remove (breakpoints, bp);
3329         mono_loader_unlock ();
3330
3331         g_ptr_array_free (bp->children, TRUE);
3332         g_free (bp);
3333 }
3334
3335 static gboolean
3336 breakpoint_matches_assembly (MonoBreakpoint *bp, MonoAssembly *assembly)
3337 {
3338         return bp->method && bp->method->klass->image->assembly == assembly;
3339 }
3340
3341 static void
3342 process_breakpoint_inner (DebuggerTlsData *tls, MonoContext *ctx)
3343 {
3344         MonoJitInfo *ji;
3345         guint8 *orig_ip, *ip;
3346         int i, j, suspend_policy;
3347         guint32 native_offset;
3348         MonoBreakpoint *bp;
3349         BreakpointInstance *inst;
3350         GPtrArray *bp_reqs, *ss_reqs_orig, *ss_reqs;
3351         GSList *bp_events = NULL, *ss_events = NULL, *enter_leave_events = NULL;
3352         EventKind kind = EVENT_KIND_BREAKPOINT;
3353
3354         // FIXME: Speed this up
3355
3356         orig_ip = ip = MONO_CONTEXT_GET_IP (ctx);
3357         ji = mini_jit_info_table_find (mono_domain_get (), (char*)ip, NULL);
3358         g_assert (ji);
3359         g_assert (ji->method);
3360
3361         /* Compute the native offset of the breakpoint from the ip */
3362 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
3363         ip = mono_arch_get_ip_for_breakpoint (ji, ctx);
3364         native_offset = ip - (guint8*)ji->code_start;
3365 #else
3366         NOT_IMPLEMENTED;
3367 #endif
3368
3369         /*
3370          * Skip the instruction causing the breakpoint signal.
3371          */
3372         mono_arch_skip_breakpoint (ctx);
3373
3374         if (ji->method->wrapper_type || tls->disable_breakpoints)
3375                 return;
3376
3377         bp_reqs = g_ptr_array_new ();
3378         ss_reqs = g_ptr_array_new ();
3379         ss_reqs_orig = g_ptr_array_new ();
3380
3381         DEBUG(1, fprintf (log_file, "[%p] Breakpoint hit, method=%s, offset=0x%x.\n", (gpointer)GetCurrentThreadId (), ji->method->name, native_offset));
3382
3383         mono_loader_lock ();
3384
3385         bp = NULL;
3386         for (i = 0; i < breakpoints->len; ++i) {
3387                 bp = g_ptr_array_index (breakpoints, i);
3388
3389                 if (!bp->method)
3390                         continue;
3391
3392                 for (j = 0; j < bp->children->len; ++j) {
3393                         inst = g_ptr_array_index (bp->children, j);
3394                         if (inst->ji == ji && inst->native_offset == native_offset) {
3395                                 if (bp->req->event_kind == EVENT_KIND_STEP) {
3396                                         g_ptr_array_add (ss_reqs_orig, bp->req);
3397                                 } else {
3398                                         g_ptr_array_add (bp_reqs, bp->req);
3399                                 }
3400                         }
3401                 }
3402         }
3403         if (bp_reqs->len == 0 && ss_reqs_orig->len == 0) {
3404                 MonoSeqPointInfo *seq_points;
3405                 int seq_il_offset, seq_native_offset;
3406                 MonoDomain *domain = mono_domain_get ();
3407
3408                 /* Maybe a method entry/exit event */
3409                 mono_domain_lock (domain);
3410                 seq_points = g_hash_table_lookup (domain_jit_info (domain)->seq_points, ji->method);
3411                 mono_domain_unlock (domain);
3412                 if (!seq_points) {
3413                         // FIXME: Generic sharing */
3414                         mono_loader_unlock ();
3415                         return;
3416                 }
3417                 g_assert (seq_points);
3418
3419                 for (i = 0; i < seq_points->len; ++i) {
3420                         seq_il_offset = seq_points->seq_points [i].il_offset;
3421                         seq_native_offset = seq_points->seq_points [i].native_offset;
3422
3423                         if (native_offset == seq_native_offset) {
3424                                 if (seq_il_offset == METHOD_ENTRY_IL_OFFSET)
3425                                         kind = EVENT_KIND_METHOD_ENTRY;
3426                                 else if (seq_il_offset == METHOD_EXIT_IL_OFFSET)
3427                                         kind = EVENT_KIND_METHOD_EXIT;
3428                                 break;
3429                         }
3430                 }
3431         }
3432
3433         /* Process single step requests */
3434         for (i = 0; i < ss_reqs_orig->len; ++i) {
3435                 EventRequest *req = g_ptr_array_index (ss_reqs_orig, i);
3436                 SingleStepReq *ss_req = bp->req->info;
3437                 gboolean hit = TRUE;
3438                 MonoSeqPointInfo *info;
3439                 SeqPoint *sp;
3440
3441                 sp = find_seq_point_for_native_offset (mono_domain_get (), ji->method, native_offset, &info);
3442                 g_assert (sp);
3443
3444                 if (ss_req->size == STEP_SIZE_LINE) {
3445                         /* Have to check whenever a different source line was reached */
3446                         MonoDebugMethodInfo *minfo;
3447                         MonoDebugSourceLocation *loc = NULL;
3448
3449                         minfo = mono_debug_lookup_method (ji->method);
3450
3451                         if (minfo)
3452                                 loc = mono_debug_symfile_lookup_location (minfo, sp->il_offset);
3453
3454                         if (!loc || (loc && ji->method == ss_req->last_method && loc->row == ss_req->last_line))
3455                                 /* Have to continue single stepping */
3456                                 hit = FALSE;
3457
3458                         if (loc) {
3459                                 ss_req->last_method = ji->method;
3460                                 ss_req->last_line = loc->row;
3461                                 mono_debug_free_source_location (loc);
3462                         }
3463                 }
3464
3465                 if (hit)
3466                         g_ptr_array_add (ss_reqs, req);
3467
3468                 /* Start single stepping again from the current sequence point */
3469                 ss_start (ss_req, ji->method, sp, info, ctx, NULL);
3470         }
3471
3472         if (ss_reqs->len > 0)
3473                 ss_events = create_event_list (EVENT_KIND_STEP, ss_reqs, ji, NULL, &suspend_policy);
3474         if (bp_reqs->len > 0)
3475                 bp_events = create_event_list (EVENT_KIND_BREAKPOINT, bp_reqs, ji, NULL, &suspend_policy);
3476         if (kind != EVENT_KIND_BREAKPOINT)
3477                 enter_leave_events = create_event_list (kind, NULL, ji, NULL, &suspend_policy);
3478
3479         mono_loader_unlock ();
3480
3481         g_ptr_array_free (bp_reqs, TRUE);
3482         g_ptr_array_free (ss_reqs, TRUE);
3483
3484         /*
3485          * FIXME: The first event will suspend, so the second will only be sent after the
3486          * resume.
3487          */
3488         if (ss_events)
3489                 process_event (EVENT_KIND_STEP, ji->method, 0, ctx, ss_events, suspend_policy);
3490         if (bp_events)
3491                 process_event (kind, ji->method, 0, ctx, bp_events, suspend_policy);
3492         if (enter_leave_events)
3493                 process_event (kind, ji->method, 0, ctx, enter_leave_events, suspend_policy);
3494 }
3495
3496 static void
3497 process_breakpoint (void)
3498 {
3499         DebuggerTlsData *tls;
3500         MonoContext ctx;
3501         static void (*restore_context) (void *);
3502
3503         if (!restore_context)
3504                 restore_context = mono_get_restore_context ();
3505
3506         tls = TlsGetValue (debugger_tls_id);
3507         memcpy (&ctx, &tls->handler_ctx, sizeof (MonoContext));
3508
3509         process_breakpoint_inner (tls, &ctx);
3510
3511         /* This is called when resuming from a signal handler, so it shouldn't return */
3512         restore_context (&ctx);
3513         g_assert_not_reached ();
3514 }
3515
3516 static void
3517 resume_from_signal_handler (void *sigctx, void *func)
3518 {
3519         DebuggerTlsData *tls;
3520         MonoContext ctx;
3521
3522         /* Save the original context in TLS */
3523         // FIXME: This might not work on an altstack ?
3524         tls = TlsGetValue (debugger_tls_id);
3525         g_assert (tls);
3526
3527         // FIXME: MonoContext usually doesn't include the fp registers, so these are
3528         // clobbered by a single step/breakpoint event. If this turns out to be a problem,
3529         // clob:c could be added to op_seq_point.
3530
3531         mono_arch_sigctx_to_monoctx (sigctx, &ctx);
3532         memcpy (&tls->handler_ctx, &ctx, sizeof (MonoContext));
3533         MONO_CONTEXT_SET_IP (&ctx, func);
3534         mono_arch_monoctx_to_sigctx (&ctx, sigctx);
3535
3536 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
3537         mono_ppc_set_func_into_sigctx (sigctx, func);
3538 #endif
3539 }
3540
3541 void
3542 mono_debugger_agent_breakpoint_hit (void *sigctx)
3543 {
3544         /*
3545          * We are called from a signal handler, and running code there causes all kinds of
3546          * problems, like the original signal is disabled, libgc can't handle altstack, etc.
3547          * So set up the signal context to return to the real breakpoint handler function.
3548          */
3549
3550         resume_from_signal_handler (sigctx, process_breakpoint);
3551 }
3552
3553 static void
3554 process_single_step_inner (DebuggerTlsData *tls, MonoContext *ctx)
3555 {
3556         MonoJitInfo *ji;
3557         guint8 *ip;
3558         GPtrArray *reqs;
3559         int il_offset, suspend_policy;
3560         MonoDomain *domain;
3561         GSList *events;
3562
3563         // FIXME: Speed this up
3564
3565         ip = MONO_CONTEXT_GET_IP (ctx);
3566
3567         /* Skip the instruction causing the single step */
3568         mono_arch_skip_single_step (ctx);
3569
3570         if (suspend_count > 0) {
3571                 process_suspend (tls, ctx);
3572                 return;
3573         }
3574
3575         if (!ss_req)
3576                 // FIXME: A suspend race
3577                 return;
3578
3579         if (mono_thread_internal_current () != ss_req->thread)
3580                 return;
3581
3582         if (log_level > 0) {
3583                 const char *depth = NULL;
3584
3585                 ji = mini_jit_info_table_find (mono_domain_get (), (char*)ip, &domain);
3586
3587                 switch (ss_req->depth) {
3588                 case STEP_DEPTH_OVER:
3589                         depth = "over";
3590                         break;
3591                 case STEP_DEPTH_OUT:
3592                         depth = "out";
3593                         break;
3594                 case STEP_DEPTH_INTO:
3595                         depth = "into";
3596                         break;
3597                 default:
3598                         g_assert_not_reached ();
3599                 }
3600
3601                 DEBUG (1, fprintf (log_file, "[%p] Single step event (depth=%s) at %s (%p), sp %p, last sp %p\n", (gpointer)GetCurrentThreadId (), ss_req->depth == STEP_DEPTH_OVER ? "over" : "out", mono_method_full_name (ji->method, TRUE), MONO_CONTEXT_GET_IP (ctx), MONO_CONTEXT_GET_SP (ctx), ss_req->last_sp));
3602         }
3603
3604         /*
3605          * We implement step over/out by single stepping until we reach the same
3606          * frame/parent frame.
3607          * FIXME:
3608          * - this is slow
3609          * - stack growing upward
3610          * - localloc
3611          * - exceptions
3612          */
3613         if (ss_req->depth != STEP_DEPTH_INTO) {
3614                 if (ss_req->depth == STEP_DEPTH_OVER && MONO_CONTEXT_GET_SP (ctx) < ss_req->last_sp)
3615                         return;
3616                 if (ss_req->depth == STEP_DEPTH_OUT && MONO_CONTEXT_GET_SP (ctx) <= ss_req->last_sp)
3617                         return;
3618
3619                 ss_req->last_sp = MONO_CONTEXT_GET_SP (ctx);
3620         }
3621
3622         ji = mini_jit_info_table_find (mono_domain_get (), (char*)ip, &domain);
3623         g_assert (ji);
3624         g_assert (ji->method);
3625
3626         if (ji->method->wrapper_type && ji->method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD)
3627                 return;
3628
3629         /*
3630          * FIXME:
3631          * Stopping in memset makes half-initialized vtypes visible.
3632          * Stopping in memcpy makes half-copied vtypes visible.
3633          */
3634         if (ji->method->klass == mono_defaults.string_class && (!strcmp (ji->method->name, "memset") || strstr (ji->method->name, "memcpy")))
3635                 return;
3636
3637         /*
3638          * The ip points to the instruction causing the single step event, convert it
3639          * to the offset stored in seq_points.
3640          */
3641 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
3642         ip = mono_arch_get_ip_for_single_step (ji, ctx);
3643 #else
3644         g_assert_not_reached ();
3645 #endif
3646
3647         /*
3648          * mono_debug_lookup_source_location () doesn't work for IL offset 0 for
3649          * example, so do things by hand.
3650          */
3651         il_offset = compute_il_offset (domain, ji->method, (guint8*)ip - (guint8*)ji->code_start);
3652
3653         if (il_offset == -1)
3654                 return;
3655
3656         if (ss_req->size == STEP_SIZE_LINE) {
3657                 /* Step until a different source line is reached */
3658                 MonoDebugMethodInfo *minfo;
3659
3660                 minfo = mono_debug_lookup_method (ji->method);
3661
3662                 if (minfo) {
3663                         MonoDebugSourceLocation *loc = mono_debug_symfile_lookup_location (minfo, il_offset);
3664
3665                         if (loc && ji->method == ss_req->last_method && loc->row == ss_req->last_line) {
3666                                 mono_debug_free_source_location (loc);
3667                                 return;
3668                         }
3669                         if (!loc)
3670                                 /*
3671                                  * Step until we reach a location with line number info,
3672                                  * otherwise the client can't show a location.
3673                                  * This can happen for example with statics initialized inline
3674                                  * outside of a cctor.
3675                                  */
3676                                 return;
3677
3678                         if (loc) {
3679                                 ss_req->last_method = ji->method;
3680                                 ss_req->last_line = loc->row;
3681                                 mono_debug_free_source_location (loc);
3682                         }
3683                 }
3684         }
3685
3686         // FIXME: Has to lock earlier
3687
3688         reqs = g_ptr_array_new ();
3689
3690         mono_loader_lock ();
3691
3692         g_ptr_array_add (reqs, ss_req->req);
3693
3694         events = create_event_list (EVENT_KIND_STEP, reqs, ji, NULL, &suspend_policy);
3695
3696         g_ptr_array_free (reqs, TRUE);
3697
3698         mono_loader_unlock ();
3699
3700         process_event (EVENT_KIND_STEP, ji->method, il_offset, ctx, events, suspend_policy);
3701 }
3702
3703 static void
3704 process_single_step (void)
3705 {
3706         DebuggerTlsData *tls;
3707         MonoContext ctx;
3708         static void (*restore_context) (void *);
3709
3710         if (!restore_context)
3711                 restore_context = mono_get_restore_context ();
3712
3713         tls = TlsGetValue (debugger_tls_id);
3714         memcpy (&ctx, &tls->handler_ctx, sizeof (MonoContext));
3715
3716         process_single_step_inner (tls, &ctx);
3717
3718         /* This is called when resuming from a signal handler, so it shouldn't return */
3719         restore_context (&ctx);
3720         g_assert_not_reached ();
3721 }
3722
3723 /*
3724  * mono_debugger_agent_single_step_event:
3725  *
3726  *   Called from a signal handler to handle a single step event.
3727  */
3728 void
3729 mono_debugger_agent_single_step_event (void *sigctx)
3730 {
3731         /* Resume to process_single_step through the signal context */
3732
3733         // FIXME: Since step out/over is implemented using step in, the step in case should
3734         // be as fast as possible. Move the relevant code from process_single_step_inner ()
3735         // here
3736
3737         if (GetCurrentThreadId () == debugger_thread_id) {
3738                 /*
3739                  * This could happen despite our best effors when the runtime calls
3740                  * assembly/type resolve hooks.
3741                  * FIXME: Breakpoints too.
3742                  */
3743                 MonoContext ctx;
3744
3745                 mono_arch_sigctx_to_monoctx (sigctx, &ctx);
3746                 mono_arch_skip_single_step (&ctx);
3747                 mono_arch_monoctx_to_sigctx (&ctx, sigctx);
3748                 return;
3749         }
3750
3751         resume_from_signal_handler (sigctx, process_single_step);
3752 }
3753
3754 /*
3755  * start_single_stepping:
3756  *
3757  *   Turn on single stepping. Can be called multiple times, for example,
3758  * by a single step event request + a suspend.
3759  */
3760 static void
3761 start_single_stepping (void)
3762 {
3763 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
3764         int val = InterlockedIncrement (&ss_count);
3765
3766         if (val == 1)
3767                 mono_arch_start_single_stepping ();
3768
3769         if (ss_req != NULL && ss_invoke_addr == NULL) {
3770                 DebuggerTlsData *tls;
3771
3772                 mono_loader_lock ();
3773
3774                 tls = mono_g_hash_table_lookup (thread_to_tls, ss_req->thread);
3775                 ss_invoke_addr = tls->invoke_addr;
3776
3777                 mono_loader_unlock ();
3778         }
3779 #else
3780         g_assert_not_reached ();
3781 #endif
3782 }
3783
3784 static void
3785 stop_single_stepping (void)
3786 {
3787 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
3788         int val = InterlockedDecrement (&ss_count);
3789
3790         if (val == 0)
3791                 mono_arch_stop_single_stepping ();
3792 #else
3793         g_assert_not_reached ();
3794 #endif
3795 }
3796
3797 /*
3798  * ss_stop:
3799  *
3800  *   Stop the single stepping operation given by SS_REQ.
3801  */
3802 static void
3803 ss_stop (SingleStepReq *ss_req)
3804 {
3805         gboolean use_bps = FALSE;
3806
3807         if (ss_req->bps) {
3808                 GSList *l;
3809
3810                 use_bps = TRUE;
3811
3812                 for (l = ss_req->bps; l; l = l->next) {
3813                         clear_breakpoint (l->data);
3814                 }
3815                 g_slist_free (ss_req->bps);
3816                 ss_req->bps = NULL;
3817         }
3818
3819         if (ss_req->global) {
3820                 stop_single_stepping ();
3821                 ss_req->global = FALSE;
3822         }
3823 }
3824
3825 /*
3826  * ss_start:
3827  *
3828  *   Start the single stepping operation given by SS_REQ from the sequence point SP.
3829  */
3830 static void
3831 ss_start (SingleStepReq *ss_req, MonoMethod *method, SeqPoint *sp, MonoSeqPointInfo *info, MonoContext *ctx, DebuggerTlsData *tls)
3832 {
3833         gboolean use_bp = FALSE;
3834         int i, frame_index;
3835         SeqPoint *next_sp;
3836         MonoBreakpoint *bp;
3837
3838         /* Stop the previous operation */
3839         ss_stop (ss_req);
3840
3841         /*
3842          * Implement single stepping using breakpoints if possible.
3843          */
3844         if (ss_req->depth == STEP_DEPTH_OVER) {
3845                 frame_index = 1;
3846                 /*
3847                  * Find the first sequence point in the current or in a previous frame which
3848                  * is not the last in its method.
3849                  */
3850                 while (sp && sp->next_len == 0) {
3851                         sp = NULL;
3852                         if (tls && frame_index < tls->frame_count) {
3853                                 StackFrame *frame = tls->frames [frame_index];
3854
3855                                 method = frame->method;
3856                                 if (frame->il_offset != -1) {
3857                                         sp = find_seq_point (frame->domain, frame->method, frame->il_offset, &info);
3858                                 }
3859                                 frame_index ++;
3860                         }
3861                 }
3862
3863                 if (sp && sp->next_len > 0) {
3864                         use_bp = TRUE;
3865                         for (i = 0; i < sp->next_len; ++i) {
3866                                 next_sp = &info->seq_points [sp->next [i]];
3867
3868                                 bp = set_breakpoint (method, next_sp->il_offset, ss_req->req);
3869                                 ss_req->bps = g_slist_append (ss_req->bps, bp);
3870                         }
3871                 }
3872         }
3873
3874         if (!ss_req->bps) {
3875                 ss_req->global = TRUE;
3876                 start_single_stepping ();
3877         } else {
3878                 ss_req->global = FALSE;
3879         }
3880 }
3881
3882 /*
3883  * Start single stepping of thread THREAD
3884  */
3885 static ErrorCode
3886 ss_create (MonoInternalThread *thread, StepSize size, StepDepth depth, EventRequest *req)
3887 {
3888         DebuggerTlsData *tls;
3889         MonoSeqPointInfo *info;
3890         SeqPoint *sp = NULL;
3891         MonoMethod *method = NULL;
3892
3893         if (suspend_count == 0)
3894                 return ERR_NOT_SUSPENDED;
3895
3896         wait_for_suspend ();
3897
3898         // FIXME: Multiple requests
3899         if (ss_req) {
3900                 DEBUG (0, printf ("Received a single step request while the previous one was still active.\n"));
3901                 return ERR_NOT_IMPLEMENTED;
3902         }
3903
3904         ss_req = g_new0 (SingleStepReq, 1);
3905         ss_req->req = req;
3906         ss_req->thread = thread;
3907         ss_req->size = size;
3908         ss_req->depth = depth;
3909         req->info = ss_req;
3910
3911         mono_loader_lock ();
3912         tls = mono_g_hash_table_lookup (thread_to_tls, thread);
3913         mono_loader_unlock ();
3914         g_assert (tls);
3915         g_assert (tls->has_context);
3916         ss_req->start_sp = ss_req->last_sp = MONO_CONTEXT_GET_SP (&tls->ctx);
3917
3918         if (ss_req->size == STEP_SIZE_LINE) {
3919                 StackFrame *frame;
3920                 MonoDebugMethodInfo *minfo;
3921
3922                 /* Compute the initial line info */
3923                 compute_frame_info (thread, tls);
3924
3925                 g_assert (tls->frame_count);
3926                 frame = tls->frames [0];
3927
3928                 ss_req->last_method = frame->method;
3929                 ss_req->last_line = -1;
3930
3931                 minfo = mono_debug_lookup_method (frame->method);
3932                 if (minfo && frame->il_offset != -1) {
3933                         MonoDebugSourceLocation *loc = mono_debug_symfile_lookup_location (minfo, frame->il_offset);
3934
3935                         if (loc) {
3936                                 ss_req->last_line = loc->row;
3937                                 g_free (loc);
3938                         }
3939                 }
3940         }
3941
3942         if (ss_req->depth == STEP_DEPTH_OVER) {
3943                 StackFrame *frame;
3944
3945                 compute_frame_info (thread, tls);
3946
3947                 g_assert (tls->frame_count);
3948                 frame = tls->frames [0];
3949
3950                 if (frame->il_offset != -1) {
3951                         /* FIXME: Sort the table and use a binary search */
3952                         sp = find_seq_point (frame->domain, frame->method, frame->il_offset, &info);
3953                         g_assert (sp);
3954                         method = frame->method;
3955                 }
3956         }
3957
3958         ss_start (ss_req, method, sp, info, NULL, tls);
3959
3960         return 0;
3961 }
3962
3963 static void
3964 ss_destroy (SingleStepReq *req)
3965 {
3966         // FIXME: Locking
3967         g_assert (ss_req == req);
3968
3969         ss_stop (ss_req);
3970
3971         g_free (ss_req);
3972         ss_req = NULL;
3973 }
3974
3975 void
3976 mono_debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx,
3977                                       MonoContext *catch_ctx)
3978 {
3979         int suspend_policy;
3980         GSList *events;
3981         MonoJitInfo *ji;
3982         EventInfo ei;
3983
3984         if (thread_to_tls != NULL) {
3985                 MonoInternalThread *thread = mono_thread_internal_current ();
3986                 DebuggerTlsData *tls;
3987
3988                 mono_loader_lock ();
3989                 tls = mono_g_hash_table_lookup (thread_to_tls, thread);
3990                 mono_loader_unlock ();
3991
3992                 if (tls && tls->abort_requested)
3993                         return;
3994         }
3995
3996         memset (&ei, 0, sizeof (EventInfo));
3997
3998         /* Just-In-Time debugging */
3999         if (!catch_ctx) {
4000                 if (agent_config.onuncaught && !inited) {
4001                         finish_agent_init (FALSE);
4002
4003                         /*
4004                          * Send an unsolicited EXCEPTION event with a dummy request id.
4005                          */
4006                         events = g_slist_append (NULL, GUINT_TO_POINTER (0xffffff));
4007                         ei.exc = (MonoObject*)exc;
4008                         process_event (EVENT_KIND_EXCEPTION, &ei, 0, throw_ctx, events, SUSPEND_POLICY_ALL);
4009                         return;
4010                 }
4011         } else if (agent_config.onthrow && !inited) {
4012                 GSList *l;
4013                 gboolean found = FALSE;
4014
4015                 for (l = agent_config.onthrow; l; l = l->next) {
4016                         char *ex_type = l->data;
4017                         char *f = mono_type_full_name (&exc->object.vtable->klass->byval_arg);
4018
4019                         if (!strcmp (ex_type, "") || !strcmp (ex_type, f))
4020                                 found = TRUE;
4021
4022                         g_free (f);
4023                 }
4024
4025                 if (found) {
4026                         finish_agent_init (FALSE);
4027
4028                         /*
4029                          * Send an unsolicited EXCEPTION event with a dummy request id.
4030                          */
4031                         events = g_slist_append (NULL, GUINT_TO_POINTER (0xffffff));
4032                         ei.exc = (MonoObject*)exc;
4033                         process_event (EVENT_KIND_EXCEPTION, &ei, 0, throw_ctx, events, SUSPEND_POLICY_ALL);
4034                         return;
4035                 }
4036         }
4037
4038         if (!inited)
4039                 return;
4040
4041         ji = mini_jit_info_table_find (mono_domain_get (), MONO_CONTEXT_GET_IP (throw_ctx), NULL);
4042
4043         ei.exc = (MonoObject*)exc;
4044         ei.caught = catch_ctx != NULL;
4045
4046         mono_loader_lock ();
4047         events = create_event_list (EVENT_KIND_EXCEPTION, NULL, ji, &ei, &suspend_policy);
4048         mono_loader_unlock ();
4049
4050         process_event (EVENT_KIND_EXCEPTION, &ei, 0, throw_ctx, events, suspend_policy);
4051 }
4052
4053 /*
4054  * buffer_add_value_full:
4055  *
4056  *   Add the encoding of the value at ADDR described by T to the buffer.
4057  * AS_VTYPE determines whenever to treat primitive types as primitive types or
4058  * vtypes.
4059  */
4060 static void
4061 buffer_add_value_full (Buffer *buf, MonoType *t, void *addr, MonoDomain *domain,
4062                                            gboolean as_vtype)
4063 {
4064         MonoObject *obj;
4065
4066         if (t->byref) {
4067                 g_assert (*(void**)addr);
4068                 addr = *(void**)addr;
4069         }
4070
4071         if (as_vtype) {
4072                 switch (t->type) {
4073                 case MONO_TYPE_BOOLEAN:
4074                 case MONO_TYPE_I1:
4075                 case MONO_TYPE_U1:
4076                 case MONO_TYPE_CHAR:
4077                 case MONO_TYPE_I2:
4078                 case MONO_TYPE_U2:
4079                 case MONO_TYPE_I4:
4080                 case MONO_TYPE_U4:
4081                 case MONO_TYPE_R4:
4082                 case MONO_TYPE_I8:
4083                 case MONO_TYPE_U8:
4084                 case MONO_TYPE_R8:
4085                 case MONO_TYPE_I:
4086                 case MONO_TYPE_U:
4087                 case MONO_TYPE_PTR:
4088                         goto handle_vtype;
4089                         break;
4090                 default:
4091                         break;
4092                 }
4093         }
4094
4095         switch (t->type) {
4096         case MONO_TYPE_VOID:
4097                 buffer_add_byte (buf, t->type);
4098                 break;
4099         case MONO_TYPE_BOOLEAN:
4100         case MONO_TYPE_I1:
4101         case MONO_TYPE_U1:
4102                 buffer_add_byte (buf, t->type);
4103                 buffer_add_int (buf, *(gint8*)addr);
4104                 break;
4105         case MONO_TYPE_CHAR:
4106         case MONO_TYPE_I2:
4107         case MONO_TYPE_U2:
4108                 buffer_add_byte (buf, t->type);
4109                 buffer_add_int (buf, *(gint16*)addr);
4110                 break;
4111         case MONO_TYPE_I4:
4112         case MONO_TYPE_U4:
4113         case MONO_TYPE_R4:
4114                 buffer_add_byte (buf, t->type);
4115                 buffer_add_int (buf, *(gint32*)addr);
4116                 break;
4117         case MONO_TYPE_I8:
4118         case MONO_TYPE_U8:
4119         case MONO_TYPE_R8:
4120                 buffer_add_byte (buf, t->type);
4121                 buffer_add_long (buf, *(gint64*)addr);
4122                 break;
4123         case MONO_TYPE_I:
4124         case MONO_TYPE_U:
4125                 /* Treat it as a vtype */
4126                 goto handle_vtype;
4127         case MONO_TYPE_PTR: {
4128                 gssize val = *(gssize*)addr;
4129
4130                 buffer_add_byte (buf, t->type);
4131                 buffer_add_long (buf, val);
4132                 break;
4133         }
4134         handle_ref:
4135         case MONO_TYPE_STRING:
4136         case MONO_TYPE_SZARRAY:
4137         case MONO_TYPE_OBJECT:
4138         case MONO_TYPE_CLASS:
4139         case MONO_TYPE_ARRAY:
4140                 obj = *(MonoObject**)addr;
4141
4142                 if (!obj) {
4143                         buffer_add_byte (buf, VALUE_TYPE_ID_NULL);
4144                 } else {
4145                         if (obj->vtable->klass->valuetype) {
4146                                 t = &obj->vtable->klass->byval_arg;
4147                                 addr = mono_object_unbox (obj);
4148                                 goto handle_vtype;
4149                         } else if (obj->vtable->klass->rank) {
4150                                 buffer_add_byte (buf, obj->vtable->klass->byval_arg.type);
4151                         } else if (obj->vtable->klass->byval_arg.type == MONO_TYPE_GENERICINST) {
4152                                 buffer_add_byte (buf, MONO_TYPE_CLASS);
4153                         } else {
4154                                 buffer_add_byte (buf, obj->vtable->klass->byval_arg.type);
4155                         }
4156                         buffer_add_objid (buf, obj);
4157                 }
4158                 break;
4159         handle_vtype:
4160         case MONO_TYPE_VALUETYPE: {
4161                 int nfields;
4162                 gpointer iter;
4163                 MonoClassField *f;
4164                 MonoClass *klass = mono_class_from_mono_type (t);
4165
4166                 buffer_add_byte (buf, MONO_TYPE_VALUETYPE);
4167                 buffer_add_byte (buf, klass->enumtype);
4168                 buffer_add_typeid (buf, domain, klass);
4169
4170                 nfields = 0;
4171                 iter = NULL;
4172                 while ((f = mono_class_get_fields (klass, &iter))) {
4173                         if (f->type->attrs & FIELD_ATTRIBUTE_STATIC)
4174                                 continue;
4175                         if (mono_field_is_deleted (f))
4176                                 continue;
4177                         nfields ++;
4178                 }
4179                 buffer_add_int (buf, nfields);
4180
4181                 iter = NULL;
4182                 while ((f = mono_class_get_fields (klass, &iter))) {
4183                         if (f->type->attrs & FIELD_ATTRIBUTE_STATIC)
4184                                 continue;
4185                         if (mono_field_is_deleted (f))
4186                                 continue;
4187                         buffer_add_value_full (buf, f->type, (guint8*)addr + f->offset - sizeof (MonoObject), domain, FALSE);
4188                 }
4189                 break;
4190         }
4191         case MONO_TYPE_GENERICINST:
4192                 if (mono_type_generic_inst_is_valuetype (t)) {
4193                         goto handle_vtype;
4194                 } else {
4195                         goto handle_ref;
4196                 }
4197                 break;
4198         default:
4199                 NOT_IMPLEMENTED;
4200         }
4201 }
4202
4203 static void
4204 buffer_add_value (Buffer *buf, MonoType *t, void *addr, MonoDomain *domain)
4205 {
4206         buffer_add_value_full (buf, t, addr, domain, FALSE);
4207 }
4208
4209 static ErrorCode
4210 decode_value (MonoType *t, MonoDomain *domain, guint8 *addr, guint8 *buf, guint8 **endbuf, guint8 *limit)
4211 {
4212         int err;
4213         int type = decode_byte (buf, &buf, limit);
4214
4215         if (type != t->type && !MONO_TYPE_IS_REFERENCE (t) &&
4216                 !(t->type == MONO_TYPE_I && type == MONO_TYPE_VALUETYPE) &&
4217                 !(t->type == MONO_TYPE_U && type == MONO_TYPE_VALUETYPE) &&
4218                 !(t->type == MONO_TYPE_PTR && type == MONO_TYPE_I8) &&
4219                 !(t->type == MONO_TYPE_GENERICINST && type == MONO_TYPE_VALUETYPE)) {
4220                 char *name = mono_type_full_name (t);
4221                 DEBUG(1, fprintf (log_file, "[%p] Expected value of type %s, got 0x%0x.\n", (gpointer)GetCurrentThreadId (), name, type));
4222                 g_free (name);
4223                 return ERR_INVALID_ARGUMENT;
4224         }
4225
4226         switch (t->type) {
4227         case MONO_TYPE_BOOLEAN:
4228                 *(guint8*)addr = decode_int (buf, &buf, limit);
4229                 break;
4230         case MONO_TYPE_CHAR:
4231                 *(gunichar2*)addr = decode_int (buf, &buf, limit);
4232                 break;
4233         case MONO_TYPE_I1:
4234                 *(gint8*)addr = decode_int (buf, &buf, limit);
4235                 break;
4236         case MONO_TYPE_U1:
4237                 *(guint8*)addr = decode_int (buf, &buf, limit);
4238                 break;
4239         case MONO_TYPE_I2:
4240                 *(gint16*)addr = decode_int (buf, &buf, limit);
4241                 break;
4242         case MONO_TYPE_U2:
4243                 *(guint16*)addr = decode_int (buf, &buf, limit);
4244                 break;
4245         case MONO_TYPE_I4:
4246                 *(gint32*)addr = decode_int (buf, &buf, limit);
4247                 break;
4248         case MONO_TYPE_U4:
4249                 *(guint32*)addr = decode_int (buf, &buf, limit);
4250                 break;
4251         case MONO_TYPE_I8:
4252                 *(gint64*)addr = decode_long (buf, &buf, limit);
4253                 break;
4254         case MONO_TYPE_U8:
4255                 *(guint64*)addr = decode_long (buf, &buf, limit);
4256                 break;
4257         case MONO_TYPE_R4:
4258                 *(guint32*)addr = decode_int (buf, &buf, limit);
4259                 break;
4260         case MONO_TYPE_R8:
4261                 *(guint64*)addr = decode_long (buf, &buf, limit);
4262                 break;
4263         case MONO_TYPE_PTR:
4264                 /* We send these as I8, so we get them back as such */
4265                 g_assert (type == MONO_TYPE_I8);
4266                 *(gssize*)addr = decode_long (buf, &buf, limit);
4267                 break;
4268         case MONO_TYPE_GENERICINST:
4269                 if (MONO_TYPE_ISSTRUCT (t)) {
4270                         /* The client sends these as a valuetype */
4271                         goto handle_vtype;
4272                 } else {
4273                         goto handle_ref;
4274                 }
4275                 break;
4276         case MONO_TYPE_I:
4277         case MONO_TYPE_U:
4278                 /* We send these as vtypes, so we get them back as such */
4279                 g_assert (type == MONO_TYPE_VALUETYPE);
4280                 /* Fall through */
4281                 handle_vtype:
4282         case MONO_TYPE_VALUETYPE: {
4283                 gboolean is_enum = decode_byte (buf, &buf, limit);
4284                 MonoClass *klass;
4285                 MonoClassField *f;
4286                 int nfields;
4287                 gpointer iter = NULL;
4288                 MonoDomain *d;
4289
4290                 /* Enums are sent as a normal vtype */
4291                 if (is_enum)
4292                         return ERR_NOT_IMPLEMENTED;
4293                 klass = decode_typeid (buf, &buf, limit, &d, &err);
4294                 if (err)
4295                         return err;
4296
4297                 if (klass != mono_class_from_mono_type (t))
4298                         return ERR_INVALID_ARGUMENT;
4299
4300                 nfields = decode_int (buf, &buf, limit);
4301                 while ((f = mono_class_get_fields (klass, &iter))) {
4302                         if (f->type->attrs & FIELD_ATTRIBUTE_STATIC)
4303                                 continue;
4304                         if (mono_field_is_deleted (f))
4305                                 continue;
4306                         err = decode_value (f->type, domain, (guint8*)addr + f->offset - sizeof (MonoObject), buf, &buf, limit);
4307                         if (err)
4308                                 return err;
4309                         nfields --;
4310                 }
4311                 g_assert (nfields == 0);
4312                 break;
4313         }
4314         handle_ref:
4315         default:
4316                 if (MONO_TYPE_IS_REFERENCE (t)) {
4317                         if (type == MONO_TYPE_OBJECT) {
4318                                 int objid = decode_objid (buf, &buf, limit);
4319                                 int err;
4320                                 MonoObject *obj;
4321
4322                                 err = get_object (objid, (MonoObject**)&obj);
4323                                 if (err)
4324                                         return err;
4325
4326                                 if (obj && !mono_class_is_assignable_from (mono_class_from_mono_type (t), obj->vtable->klass))
4327                                         return ERR_INVALID_ARGUMENT;
4328                                 if (obj && obj->vtable->domain != domain)
4329                                         return ERR_INVALID_ARGUMENT;
4330
4331                                 mono_gc_wbarrier_generic_store (addr, obj);
4332                         } else if (type == VALUE_TYPE_ID_NULL) {
4333                                 *(MonoObject**)addr = NULL;
4334                         } else {
4335                                 return ERR_INVALID_ARGUMENT;
4336                         }
4337                 } else {
4338                         NOT_IMPLEMENTED;
4339                 }
4340                 break;
4341         }
4342
4343         *endbuf = buf;
4344
4345         return 0;
4346 }
4347
4348 static void
4349 add_var (Buffer *buf, MonoType *t, MonoDebugVarInfo *var, MonoContext *ctx, MonoDomain *domain, gboolean as_vtype)
4350 {
4351         guint32 flags;
4352         int reg;
4353         guint8 *addr;
4354         gpointer reg_val;
4355
4356         flags = var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
4357         reg = var->index & ~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
4358
4359         switch (flags) {
4360         case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
4361                 reg_val = mono_arch_context_get_int_reg (ctx, reg);
4362
4363                 buffer_add_value_full (buf, t, &reg_val, domain, as_vtype);
4364                 break;
4365         case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
4366                 addr = mono_arch_context_get_int_reg (ctx, reg);
4367                 addr += (gint32)var->offset;
4368
4369                 //printf ("[R%d+%d] = %p\n", reg, var->offset, addr);
4370
4371                 buffer_add_value_full (buf, t, addr, domain, as_vtype);
4372                 break;
4373         case MONO_DEBUG_VAR_ADDRESS_MODE_DEAD:
4374                 NOT_IMPLEMENTED;
4375                 break;
4376         default:
4377                 g_assert_not_reached ();
4378         }
4379 }
4380
4381 static void
4382 set_var (MonoType *t, MonoDebugVarInfo *var, MonoContext *ctx, MonoDomain *domain, guint8 *val)
4383 {
4384         guint32 flags;
4385         int reg, size;
4386         guint8 *addr;
4387
4388         flags = var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
4389         reg = var->index & ~MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
4390
4391         if (MONO_TYPE_IS_REFERENCE (t))
4392                 size = sizeof (gpointer);
4393         else
4394                 size = mono_class_value_size (mono_class_from_mono_type (t), NULL);
4395
4396         switch (flags) {
4397         case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
4398                 // FIXME: Can't set registers, so we disable linears
4399                 NOT_IMPLEMENTED;
4400                 break;
4401         case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
4402                 addr = mono_arch_context_get_int_reg (ctx, reg);
4403                 addr += (gint32)var->offset;
4404
4405                 //printf ("[R%d+%d] = %p\n", reg, var->offset, addr);
4406
4407                 // FIXME: Write barriers
4408                 memcpy (addr, val, size);
4409                 break;
4410         case MONO_DEBUG_VAR_ADDRESS_MODE_DEAD:
4411                 NOT_IMPLEMENTED;
4412                 break;
4413         default:
4414                 g_assert_not_reached ();
4415         }
4416 }
4417
4418 static void
4419 clear_event_request (int req_id, int etype)
4420 {
4421         int i;
4422
4423         mono_loader_lock ();
4424         for (i = 0; i < event_requests->len; ++i) {
4425                 EventRequest *req = g_ptr_array_index (event_requests, i);
4426
4427                 if (req->id == req_id && req->event_kind == etype) {
4428                         if (req->event_kind == EVENT_KIND_BREAKPOINT)
4429                                 clear_breakpoint (req->info);
4430                         if (req->event_kind == EVENT_KIND_STEP)
4431                                 ss_destroy (req->info);
4432                         if (req->event_kind == EVENT_KIND_METHOD_ENTRY)
4433                                 clear_breakpoint (req->info);
4434                         if (req->event_kind == EVENT_KIND_METHOD_EXIT)
4435                                 clear_breakpoint (req->info);
4436                         g_ptr_array_remove_index_fast (event_requests, i);
4437                         g_free (req);
4438                         break;
4439                 }
4440         }
4441         mono_loader_unlock ();
4442 }
4443
4444 static gboolean
4445 event_req_matches_assembly (EventRequest *req, MonoAssembly *assembly)
4446 {
4447         if (req->event_kind == EVENT_KIND_BREAKPOINT)
4448                 return breakpoint_matches_assembly (req->info, assembly);
4449         else {
4450                 int i, j;
4451
4452                 for (i = 0; i < req->nmodifiers; ++i) {
4453                         Modifier *m = &req->modifiers [i];
4454
4455                         if (m->kind == MOD_KIND_EXCEPTION_ONLY && m->data.exc_class && m->data.exc_class->image->assembly == assembly)
4456                                 return TRUE;
4457                         if (m->kind == MOD_KIND_ASSEMBLY_ONLY && m->data.assemblies) {
4458                                 for (j = 0; m->data.assemblies [j]; ++j)
4459                                         if (m->data.assemblies [j] == assembly)
4460                                                 return TRUE;
4461                         }
4462                 }
4463         }
4464
4465         return FALSE;
4466 }
4467
4468 /*
4469  * clear_event_requests_for_assembly:
4470  *
4471  *   Clear all events requests which reference ASSEMBLY.
4472  */
4473 static void
4474 clear_event_requests_for_assembly (MonoAssembly *assembly)
4475 {
4476         int i;
4477         gboolean found;
4478
4479         mono_loader_lock ();
4480         found = TRUE;
4481         while (found) {
4482                 found = FALSE;
4483                 for (i = 0; i < event_requests->len; ++i) {
4484                         EventRequest *req = g_ptr_array_index (event_requests, i);
4485
4486                         if (event_req_matches_assembly (req, assembly)) {
4487                                 clear_event_request (req->id, req->event_kind);
4488                                 found = TRUE;
4489                                 break;
4490                         }
4491                 }
4492         }
4493         mono_loader_unlock ();
4494 }
4495
4496 static void
4497 add_thread (gpointer key, gpointer value, gpointer user_data)
4498 {
4499         MonoInternalThread *thread = value;
4500         Buffer *buf = user_data;
4501
4502         buffer_add_objid (buf, (MonoObject*)thread);
4503 }
4504
4505 static ErrorCode
4506 do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke)
4507 {
4508         guint8 *p = invoke->p;
4509         guint8 *end = invoke->endp;
4510         MonoMethod *m;
4511         int i, err, nargs;
4512         MonoMethodSignature *sig;
4513         guint8 **arg_buf;
4514         void **args;
4515         MonoObject *this, *res, *exc;
4516         MonoDomain *domain;
4517         guint8 *this_buf;
4518 #ifdef MONO_ARCH_HAVE_FIND_JIT_INFO_EXT
4519         MonoLMFExt ext;
4520 #endif
4521
4522         if (invoke->method) {
4523                 /*
4524                  * Invoke this method directly, currently only Environment.Exit () is supported.
4525                  */
4526                 this = NULL;
4527                 DEBUG (1, printf ("[%p] Invoking method '%s' on receiver '%s'.\n", (gpointer)GetCurrentThreadId (), mono_method_full_name (invoke->method, TRUE), this ? this->vtable->klass->name : "<null>"));
4528                 mono_runtime_invoke (invoke->method, NULL, invoke->args, &exc);
4529                 g_assert_not_reached ();
4530         }
4531
4532         m = decode_methodid (p, &p, end, &domain, &err);
4533         if (err)
4534                 return err;
4535         sig = mono_method_signature (m);
4536
4537         if (m->klass->valuetype)
4538                 this_buf = g_alloca (mono_class_instance_size (m->klass));
4539         else
4540                 this_buf = g_alloca (sizeof (MonoObject*));
4541         if (m->klass->valuetype && (m->flags & METHOD_ATTRIBUTE_STATIC)) {
4542                 /* Should be null */
4543                 int type = decode_byte (p, &p, end);
4544                 if (type != VALUE_TYPE_ID_NULL)
4545                         return ERR_INVALID_ARGUMENT;
4546                 memset (this_buf, 0, mono_class_instance_size (m->klass));
4547         } else {
4548                 err = decode_value (&m->klass->byval_arg, domain, this_buf, p, &p, end);
4549                 if (err)
4550                         return err;
4551         }
4552
4553         if (!m->klass->valuetype)
4554                 this = *(MonoObject**)this_buf;
4555         else
4556                 this = NULL;
4557
4558         DEBUG (1, printf ("[%p] Invoking method '%s' on receiver '%s'.\n", (gpointer)GetCurrentThreadId (), mono_method_full_name (m, TRUE), this ? this->vtable->klass->name : "<null>"));
4559
4560         if (this && this->vtable->domain != domain)
4561                 NOT_IMPLEMENTED;
4562
4563         if (!m->klass->valuetype && !(m->flags & METHOD_ATTRIBUTE_STATIC) && !this) {
4564                 if (!strcmp (m->name, ".ctor")) {
4565                         if (m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT)
4566                                 return ERR_INVALID_ARGUMENT;
4567                         else
4568                                 this = mono_object_new (domain, m->klass);
4569                 } else {
4570                         return ERR_INVALID_ARGUMENT;
4571                 }
4572         }
4573
4574         if (this && !mono_class_is_assignable_from (m->klass, this->vtable->klass))
4575                 return ERR_INVALID_ARGUMENT;
4576
4577         nargs = decode_int (p, &p, end);
4578         if (nargs != sig->param_count)
4579                 return ERR_INVALID_ARGUMENT;
4580         /* Use alloca to get gc tracking */
4581         arg_buf = g_alloca (nargs * sizeof (gpointer));
4582         memset (arg_buf, 0, nargs * sizeof (gpointer));
4583         args = g_alloca (nargs * sizeof (gpointer));
4584         for (i = 0; i < nargs; ++i) {
4585                 if (MONO_TYPE_IS_REFERENCE (sig->params [i])) {
4586                         err = decode_value (sig->params [i], domain, (guint8*)&args [i], p, &p, end);
4587                         if (err)
4588                                 break;
4589
4590                         if (args [i] && ((MonoObject*)args [i])->vtable->domain != domain)
4591                                 NOT_IMPLEMENTED;
4592                 } else {
4593                         arg_buf [i] = g_alloca (mono_class_instance_size (mono_class_from_mono_type (sig->params [i])));
4594                         err = decode_value (sig->params [i], domain, arg_buf [i], p, &p, end);
4595                         if (err)
4596                                 break;
4597                         args [i] = arg_buf [i];
4598                 }
4599         }
4600
4601         if (i < nargs)
4602                 return err;
4603
4604         if (invoke->flags & INVOKE_FLAG_DISABLE_BREAKPOINTS)
4605                 tls->disable_breakpoints = TRUE;
4606         else
4607                 tls->disable_breakpoints = FALSE;
4608
4609         /*
4610          * Add an LMF frame to link the stack frames on the invoke method with our caller.
4611          */
4612         /* FIXME: Move this to arch specific code */
4613 #ifdef MONO_ARCH_HAVE_FIND_JIT_INFO_EXT
4614         if (invoke->has_ctx) {
4615                 MonoLMF **lmf_addr;
4616
4617                 lmf_addr = mono_get_lmf_addr ();
4618
4619                 /* Setup our lmf */
4620                 memset (&ext, 0, sizeof (ext));
4621 #ifdef TARGET_AMD64
4622                 ext.lmf.previous_lmf = *(lmf_addr);
4623                 /* Mark that this is a MonoLMFExt */
4624                 ext.lmf.previous_lmf = (gpointer)(((gssize)ext.lmf.previous_lmf) | 2);
4625                 ext.lmf.rsp = (gssize)&ext;
4626 #elif defined(TARGET_X86)
4627                 ext.lmf.previous_lmf = (gsize)*(lmf_addr);
4628                 /* Mark that this is a MonoLMFExt */
4629                 ext.lmf.previous_lmf = (gsize)(gpointer)(((gssize)ext.lmf.previous_lmf) | 2);
4630                 ext.lmf.ebp = (gssize)&ext;
4631 #elif defined(TARGET_ARM)
4632                 ext.lmf.previous_lmf = *(lmf_addr);
4633                 /* Mark that this is a MonoLMFExt */
4634                 ext.lmf.previous_lmf = (gpointer)(((gssize)ext.lmf.previous_lmf) | 2);
4635                 ext.lmf.ebp = (gssize)&ext;
4636 #elif defined(TARGET_POWERPC)
4637                 ext.lmf.previous_lmf = *(lmf_addr);
4638                 /* Mark that this is a MonoLMFExt */
4639                 ext.lmf.previous_lmf = (gpointer)(((gssize)ext.lmf.previous_lmf) | 2);
4640                 ext.lmf.ebp = (gssize)&ext;
4641 #else
4642                 g_assert_not_reached ();
4643 #endif
4644
4645                 ext.debugger_invoke = TRUE;
4646                 memcpy (&ext.ctx, &invoke->ctx, sizeof (MonoContext));
4647
4648                 mono_set_lmf ((MonoLMF*)&ext);
4649         }
4650 #endif
4651
4652         if (m->klass->valuetype)
4653                 res = mono_runtime_invoke (m, this_buf, args, &exc);
4654         else
4655                 res = mono_runtime_invoke (m, this, args, &exc);
4656         if (exc) {
4657                 buffer_add_byte (buf, 0);
4658                 buffer_add_value (buf, &mono_defaults.object_class->byval_arg, &exc, domain);
4659         } else {
4660                 buffer_add_byte (buf, 1);
4661                 if (sig->ret->type == MONO_TYPE_VOID) {
4662                         if (!strcmp (m->name, ".ctor") && !m->klass->valuetype) {
4663                                 buffer_add_value (buf, &mono_defaults.object_class->byval_arg, &this, domain);
4664                         }
4665                         else
4666                                 buffer_add_value (buf, &mono_defaults.void_class->byval_arg, NULL, domain);
4667                 } else if (MONO_TYPE_IS_REFERENCE (sig->ret)) {
4668                         buffer_add_value (buf, sig->ret, &res, domain);
4669                 } else if (mono_class_from_mono_type (sig->ret)->valuetype) {
4670                         g_assert (res);
4671                         buffer_add_value (buf, sig->ret, mono_object_unbox (res), domain);
4672                 } else {
4673                         NOT_IMPLEMENTED;
4674                 }
4675         }
4676
4677         tls->disable_breakpoints = FALSE;
4678
4679 #ifdef MONO_ARCH_HAVE_FIND_JIT_INFO_EXT
4680         if (invoke->has_ctx)
4681                 mono_set_lmf ((gpointer)(((gssize)ext.lmf.previous_lmf) & ~3));
4682 #endif
4683
4684         // FIXME: byref arguments
4685         // FIXME: varargs
4686         return ERR_NONE;
4687 }
4688
4689 /*
4690  * invoke_method:
4691  *
4692  *   Invoke the method given by tls->pending_invoke in the current thread.
4693  */
4694 static void
4695 invoke_method (void)
4696 {
4697         DebuggerTlsData *tls;
4698         InvokeData *invoke;
4699         int id;
4700         int err;
4701         Buffer buf;
4702         static void (*restore_context) (void *);
4703         MonoContext restore_ctx;
4704
4705         if (!restore_context)
4706                 restore_context = mono_get_restore_context ();
4707
4708         tls = TlsGetValue (debugger_tls_id);
4709         g_assert (tls);
4710
4711         /*
4712          * Store the `InvokeData *' in `tls->invoke' until we're done with
4713          * the invocation, so CMD_VM_ABORT_INVOKE can check it.
4714          */
4715
4716         mono_loader_lock ();
4717
4718         invoke = tls->pending_invoke;
4719         g_assert (invoke);
4720         tls->pending_invoke = NULL;
4721
4722         invoke->last_invoke = tls->invoke;
4723         tls->invoke = invoke;
4724
4725         mono_loader_unlock ();
4726
4727         tls->frames_up_to_date = FALSE;
4728
4729         id = invoke->id;
4730
4731         buffer_init (&buf, 128);
4732
4733         err = do_invoke_method (tls, &buf, invoke);
4734
4735         /* Start suspending before sending the reply */
4736         if (!(invoke->flags & INVOKE_FLAG_SINGLE_THREADED))
4737                 suspend_vm ();
4738
4739         send_reply_packet (id, err, &buf);
4740
4741         buffer_free (&buf);
4742
4743         memcpy (&restore_ctx, &invoke->ctx, sizeof (MonoContext));
4744
4745         if (invoke->has_ctx)
4746                 save_thread_context (&restore_ctx);
4747
4748         if (invoke->flags & INVOKE_FLAG_SINGLE_THREADED) {
4749                 g_assert (tls->resume_count);
4750                 tls->resume_count -= invoke->suspend_count;
4751         }
4752
4753         DEBUG (1, printf ("[%p] Invoke finished, resume_count = %d.\n", (gpointer)GetCurrentThreadId (), tls->resume_count));
4754
4755         /*
4756          * Take the loader lock to avoid race conditions with CMD_VM_ABORT_INVOKE:
4757          *
4758          * It is possible that ves_icall_System_Threading_Thread_Abort () was called
4759          * after the mono_runtime_invoke() already returned, but it doesn't matter
4760          * because we reset the abort here.
4761          */
4762
4763         mono_loader_lock ();
4764
4765         if (tls->abort_requested)
4766                 mono_thread_internal_reset_abort (tls->thread);
4767
4768         tls->invoke = tls->invoke->last_invoke;
4769         tls->abort_requested = FALSE;
4770
4771         mono_loader_unlock ();
4772
4773         g_free (invoke->p);
4774         g_free (invoke);
4775
4776         suspend_current ();
4777 }
4778
4779 static gboolean
4780 is_really_suspended (gpointer key, gpointer value, gpointer user_data)
4781 {
4782         MonoThread *thread = value;
4783         DebuggerTlsData *tls;
4784         gboolean res;
4785
4786         mono_loader_lock ();
4787         tls = mono_g_hash_table_lookup (thread_to_tls, thread);
4788         g_assert (tls);
4789         res = tls->really_suspended;
4790         mono_loader_unlock ();
4791
4792         return res;
4793 }
4794
4795 static ErrorCode
4796 vm_commands (int command, int id, guint8 *p, guint8 *end, Buffer *buf)
4797 {
4798         switch (command) {
4799         case CMD_VM_VERSION: {
4800                 char *build_info, *version;
4801
4802                 build_info = mono_get_runtime_build_info ();
4803                 version = g_strdup_printf ("mono %s", build_info);
4804
4805                 buffer_add_string (buf, version); /* vm version */
4806                 buffer_add_int (buf, MAJOR_VERSION);
4807                 buffer_add_int (buf, MINOR_VERSION);
4808                 g_free (build_info);
4809                 g_free (version);
4810                 break;
4811         }
4812         case CMD_VM_SET_PROTOCOL_VERSION: {
4813                 major_version = decode_int (p, &p, end);
4814                 minor_version = decode_int (p, &p, end);
4815                 protocol_version_set = TRUE;
4816                 DEBUG(1, fprintf (log_file, "[dbg] Protocol version %d.%d, client protocol version %d.%d.\n", MAJOR_VERSION, MINOR_VERSION, major_version, minor_version));
4817                 break;
4818         }
4819         case CMD_VM_ALL_THREADS: {
4820                 // FIXME: Domains
4821                 mono_loader_lock ();
4822                 buffer_add_int (buf, mono_g_hash_table_size (tid_to_thread_obj));
4823                 mono_g_hash_table_foreach (tid_to_thread_obj, add_thread, buf);
4824                 mono_loader_unlock ();
4825                 break;
4826         }
4827         case CMD_VM_SUSPEND:
4828                 suspend_vm ();
4829                 wait_for_suspend ();
4830                 break;
4831         case CMD_VM_RESUME:
4832                 if (suspend_count == 0)
4833                         return ERR_NOT_SUSPENDED;
4834                 resume_vm ();
4835                 break;
4836         case CMD_VM_DISPOSE:
4837                 /* Clear all event requests */
4838                 mono_loader_lock ();
4839                 while (event_requests->len > 0) {
4840                         EventRequest *req = g_ptr_array_index (event_requests, 0);
4841
4842                         clear_event_request (req->id, req->event_kind);
4843                 }
4844                 mono_loader_unlock ();
4845
4846                 // FIXME: Count resumes
4847                 resume_vm ();
4848                 disconnected = TRUE;
4849                 break;
4850         case CMD_VM_EXIT: {
4851                 MonoInternalThread *thread;
4852                 DebuggerTlsData *tls;
4853                 MonoClass *env_class;
4854                 MonoMethod *exit_method;
4855                 gpointer *args;
4856                 int exit_code;
4857
4858                 exit_code = decode_int (p, &p, end);
4859
4860                 // FIXME: What if there is a VM_DEATH event request with SUSPEND_ALL ?
4861
4862                 /* Have to send a reply before exiting */
4863                 send_reply_packet (id, 0, buf);
4864
4865                 /* Clear all event requests */
4866                 mono_loader_lock ();
4867                 while (event_requests->len > 0) {
4868                         EventRequest *req = g_ptr_array_index (event_requests, 0);
4869
4870                         clear_event_request (req->id, req->event_kind);
4871                 }
4872                 mono_loader_unlock ();
4873
4874                 /*
4875                  * The JDWP documentation says that the shutdown is not orderly. It doesn't
4876                  * specify whenever a VM_DEATH event is sent. We currently do an orderly
4877                  * shutdown by hijacking a thread to execute Environment.Exit (). This is
4878                  * better than doing the shutdown ourselves, since it avoids various races.
4879                  */
4880
4881                 suspend_vm ();
4882                 wait_for_suspend ();
4883
4884                 env_class = mono_class_from_name (mono_defaults.corlib, "System", "Environment");
4885                 g_assert (env_class);
4886                 exit_method = mono_class_get_method_from_name (env_class, "Exit", 1);
4887                 g_assert (exit_method);
4888
4889                 mono_loader_lock ();
4890                 thread = mono_g_hash_table_find (tid_to_thread, is_really_suspended, NULL);
4891                 mono_loader_unlock ();
4892
4893                 if (thread) {
4894                         mono_loader_lock ();
4895                         tls = mono_g_hash_table_lookup (thread_to_tls, thread);
4896                         mono_loader_unlock ();
4897
4898                         args = g_new0 (gpointer, 1);
4899                         args [0] = g_malloc (sizeof (int));
4900                         *(int*)(args [0]) = exit_code;
4901
4902                         tls->pending_invoke = g_new0 (InvokeData, 1);
4903                         tls->pending_invoke->method = exit_method;
4904                         tls->pending_invoke->args = args;
4905
4906                         while (suspend_count > 0)
4907                                 resume_vm ();
4908                 } else {
4909                         /*
4910                          * No thread found, do it ourselves.
4911                          * FIXME: This can race with normal shutdown etc.
4912                          */
4913                         while (suspend_count > 0)
4914                                 resume_vm ();
4915
4916                         mono_runtime_set_shutting_down ();
4917
4918                         mono_threads_set_shutting_down ();
4919
4920                         /* Suspend all managed threads since the runtime is going away */
4921                         DEBUG(1, fprintf (log_file, "Suspending all threads...\n"));
4922                         mono_thread_suspend_all_other_threads ();
4923                         DEBUG(1, fprintf (log_file, "Shutting down the runtime...\n"));
4924                         mono_runtime_quit ();
4925 #ifdef HOST_WIN32
4926                         shutdown (conn_fd, SD_BOTH);
4927 #else
4928                         shutdown (conn_fd, SHUT_RDWR);
4929 #endif
4930                         DEBUG(1, fprintf (log_file, "Exiting...\n"));
4931
4932                         exit (exit_code);
4933                 }
4934                 break;
4935         }
4936         case CMD_VM_INVOKE_METHOD: {
4937                 int objid = decode_objid (p, &p, end);
4938                 MonoThread *thread;
4939                 DebuggerTlsData *tls;
4940                 int err, flags;
4941
4942                 err = get_object (objid, (MonoObject**)&thread);
4943                 if (err)
4944                         return err;
4945
4946                 flags = decode_int (p, &p, end);
4947
4948                 // Wait for suspending if it already started
4949                 if (suspend_count)
4950                         wait_for_suspend ();
4951                 if (!is_suspended ())
4952                         return ERR_NOT_SUSPENDED;
4953
4954                 mono_loader_lock ();
4955                 tls = mono_g_hash_table_lookup (thread_to_tls, THREAD_TO_INTERNAL (thread));
4956                 mono_loader_unlock ();
4957                 g_assert (tls);
4958
4959                 if (!tls->really_suspended)
4960                         /* The thread is still running native code, can't do invokes */
4961                         return ERR_NOT_SUSPENDED;
4962
4963                 /*
4964                  * Store the invoke data into tls, the thread will execute it after it is
4965                  * resumed.
4966                  */
4967                 if (tls->pending_invoke)
4968                         NOT_IMPLEMENTED;
4969                 tls->pending_invoke = g_new0 (InvokeData, 1);
4970                 tls->pending_invoke->id = id;
4971                 tls->pending_invoke->flags = flags;
4972                 tls->pending_invoke->p = g_malloc (end - p);
4973                 memcpy (tls->pending_invoke->p, p, end - p);
4974                 tls->pending_invoke->endp = tls->pending_invoke->p + (end - p);
4975                 tls->pending_invoke->suspend_count = suspend_count;
4976
4977                 if (flags & INVOKE_FLAG_SINGLE_THREADED)
4978                         resume_thread (THREAD_TO_INTERNAL (thread));
4979                 else
4980                         resume_vm ();
4981                 break;
4982         }
4983         case CMD_VM_ABORT_INVOKE: {
4984                 int objid = decode_objid (p, &p, end);
4985                 MonoThread *thread;
4986                 DebuggerTlsData *tls;
4987                 int invoke_id, err;
4988
4989                 err = get_object (objid, (MonoObject**)&thread);
4990                 if (err)
4991                         return err;
4992
4993                 invoke_id = decode_int (p, &p, end);
4994
4995                 mono_loader_lock ();
4996                 tls = mono_g_hash_table_lookup (thread_to_tls, THREAD_TO_INTERNAL (thread));
4997                 g_assert (tls);
4998
4999                 if (tls->abort_requested) {
5000                         mono_loader_unlock ();
5001                         break;
5002                 }
5003
5004                 /*
5005                  * Check whether we're still inside the mono_runtime_invoke() and that it's
5006                  * actually the correct invocation.
5007                  *
5008                  * Careful, we do not stop the thread that's doing the invocation, so we can't
5009                  * inspect its stack.  However, invoke_method() also acquires the loader lock
5010                  * when it's done, so we're safe here.
5011                  *
5012                  */
5013
5014                 if (!tls->invoke || (tls->invoke->id != invoke_id)) {
5015                         mono_loader_unlock ();
5016                         return ERR_NO_INVOCATION;
5017                 }
5018
5019                 tls->abort_requested = TRUE;
5020
5021                 ves_icall_System_Threading_Thread_Abort (THREAD_TO_INTERNAL (thread), NULL);
5022                 mono_loader_unlock ();
5023                 break;
5024         }
5025
5026         default:
5027                 return ERR_NOT_IMPLEMENTED;
5028         }
5029
5030         return ERR_NONE;
5031 }
5032
5033 static ErrorCode
5034 event_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
5035 {
5036         int err;
5037
5038         switch (command) {
5039         case CMD_EVENT_REQUEST_SET: {
5040                 EventRequest *req;
5041                 int i, event_kind, suspend_policy, nmodifiers, mod;
5042                 MonoMethod *method;
5043                 long location = 0;
5044                 MonoThread *step_thread;
5045                 int size = 0, depth = 0, step_thread_id = 0;
5046                 MonoDomain *domain;
5047
5048                 event_kind = decode_byte (p, &p, end);
5049                 suspend_policy = decode_byte (p, &p, end);
5050                 nmodifiers = decode_byte (p, &p, end);
5051
5052                 req = g_malloc0 (sizeof (EventRequest) + (nmodifiers * sizeof (Modifier)));
5053                 req->id = InterlockedIncrement (&event_request_id);
5054                 req->event_kind = event_kind;
5055                 req->suspend_policy = suspend_policy;
5056                 req->nmodifiers = nmodifiers;
5057
5058                 method = NULL;
5059                 for (i = 0; i < nmodifiers; ++i) {
5060                         mod = decode_byte (p, &p, end);
5061
5062                         req->modifiers [i].kind = mod;
5063                         if (mod == MOD_KIND_COUNT) {
5064                                 req->modifiers [i].data.count = decode_int (p, &p, end);
5065                         } else if (mod == MOD_KIND_LOCATION_ONLY) {
5066                                 method = decode_methodid (p, &p, end, &domain, &err);
5067                                 if (err)
5068                                         return err;
5069                                 location = decode_long (p, &p, end);
5070                         } else if (mod == MOD_KIND_STEP) {
5071                                 step_thread_id = decode_id (p, &p, end);
5072                                 size = decode_int (p, &p, end);
5073                                 depth = decode_int (p, &p, end);
5074                         } else if (mod == MOD_KIND_THREAD_ONLY) {
5075                                 int id = decode_id (p, &p, end);
5076
5077                                 err = get_object (id, (MonoObject**)&req->modifiers [i].data.thread);
5078                                 if (err) {
5079                                         g_free (req);
5080                                         return err;
5081                                 }
5082                         } else if (mod == MOD_KIND_EXCEPTION_ONLY) {
5083                                 MonoClass *exc_class = decode_typeid (p, &p, end, &domain, &err);
5084
5085                                 if (err)
5086                                         return err;
5087                                 req->modifiers [i].caught = decode_byte (p, &p, end);
5088                                 req->modifiers [i].uncaught = decode_byte (p, &p, end);
5089                                 DEBUG(1, fprintf (log_file, "[dbg] \tEXCEPTION_ONLY filter (%s%s%s).\n", exc_class ? exc_class->name : "all", req->modifiers [i].caught ? ", caught" : "", req->modifiers [i].uncaught ? ", uncaught" : ""));
5090                                 if (exc_class) {
5091                                         req->modifiers [i].data.exc_class = exc_class;
5092
5093                                         if (!mono_class_is_assignable_from (mono_defaults.exception_class, exc_class)) {
5094                                                 g_free (req);
5095                                                 return ERR_INVALID_ARGUMENT;
5096                                         }
5097                                 }
5098                         } else if (mod == MOD_KIND_ASSEMBLY_ONLY) {
5099                                 int n = decode_int (p, &p, end);
5100                                 int j;
5101
5102                                 req->modifiers [i].data.assemblies = g_new0 (MonoAssembly*, n);
5103                                 for (j = 0; j < n; ++j) {
5104                                         req->modifiers [i].data.assemblies [j] = decode_assemblyid (p, &p, end, &domain, &err);
5105                                         if (err) {
5106                                                 g_free (req->modifiers [i].data.assemblies);
5107                                                 return err;
5108                                         }
5109                                 }
5110                         } else {
5111                                 g_free (req);
5112                                 return ERR_NOT_IMPLEMENTED;
5113                         }
5114                 }
5115
5116                 if (req->event_kind == EVENT_KIND_BREAKPOINT) {
5117                         g_assert (method);
5118
5119                         req->info = set_breakpoint (method, location, req);
5120                 } else if (req->event_kind == EVENT_KIND_STEP) {
5121                         g_assert (step_thread_id);
5122
5123                         err = get_object (step_thread_id, (MonoObject**)&step_thread);
5124                         if (err) {
5125                                 g_free (req);
5126                                 return err;
5127                         }
5128
5129                         err = ss_create (THREAD_TO_INTERNAL (step_thread), size, depth, req);
5130                         if (err) {
5131                                 g_free (req);
5132                                 return err;
5133                         }
5134                 } else if (req->event_kind == EVENT_KIND_METHOD_ENTRY) {
5135                         req->info = set_breakpoint (NULL, METHOD_ENTRY_IL_OFFSET, req);
5136                 } else if (req->event_kind == EVENT_KIND_METHOD_EXIT) {
5137                         req->info = set_breakpoint (NULL, METHOD_EXIT_IL_OFFSET, req);
5138                 } else if (req->event_kind == EVENT_KIND_EXCEPTION) {
5139                 } else {
5140                         if (req->nmodifiers) {
5141                                 g_free (req);
5142                                 return ERR_NOT_IMPLEMENTED;
5143                         }
5144                 }
5145
5146                 mono_loader_lock ();
5147                 g_ptr_array_add (event_requests, req);
5148                 mono_loader_unlock ();
5149
5150                 buffer_add_int (buf, req->id);
5151                 break;
5152         }
5153         case CMD_EVENT_REQUEST_CLEAR: {
5154                 int etype = decode_byte (p, &p, end);
5155                 int req_id = decode_int (p, &p, end);
5156
5157                 // FIXME: Make a faster mapping from req_id to request
5158                 mono_loader_lock ();
5159                 clear_event_request (req_id, etype);
5160                 mono_loader_unlock ();
5161                 break;
5162         }
5163         case CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS: {
5164                 int i;
5165
5166                 mono_loader_lock ();
5167                 i = 0;
5168                 while (i < event_requests->len) {
5169                         EventRequest *req = g_ptr_array_index (event_requests, i);
5170
5171                         if (req->event_kind == EVENT_KIND_BREAKPOINT) {
5172                                 clear_breakpoint (req->info);
5173
5174                                 g_ptr_array_remove_index_fast (event_requests, i);
5175                                 g_free (req);
5176                         } else {
5177                                 i ++;
5178                         }
5179                 }
5180                 mono_loader_unlock ();
5181                 break;
5182         }
5183         default:
5184                 return ERR_NOT_IMPLEMENTED;
5185         }
5186
5187         return ERR_NONE;
5188 }
5189
5190 static ErrorCode
5191 domain_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
5192 {
5193         int err;
5194         MonoDomain *domain;
5195
5196         switch (command) {
5197         case CMD_APPDOMAIN_GET_ROOT_DOMAIN: {
5198                 buffer_add_domainid (buf, mono_get_root_domain ());
5199                 break;
5200         }
5201         case CMD_APPDOMAIN_GET_FRIENDLY_NAME: {
5202                 domain = decode_domainid (p, &p, end, NULL, &err);
5203                 if (err)
5204                         return err;
5205                 buffer_add_string (buf, domain->friendly_name);
5206                 break;
5207         }
5208         case CMD_APPDOMAIN_GET_ASSEMBLIES: {
5209                 GSList *tmp;
5210                 MonoAssembly *ass;
5211                 int count;
5212
5213                 domain = decode_domainid (p, &p, end, NULL, &err);
5214                 if (err)
5215                         return err;
5216                 mono_loader_lock ();
5217                 count = 0;
5218                 for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
5219                         count ++;
5220                 }
5221                 buffer_add_int (buf, count);
5222                 for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
5223                         ass = tmp->data;
5224                         buffer_add_assemblyid (buf, domain, ass);
5225                 }
5226                 mono_loader_unlock ();
5227                 break;
5228         }
5229         case CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY: {
5230                 domain = decode_domainid (p, &p, end, NULL, &err);
5231                 if (err)
5232                         return err;
5233
5234                 buffer_add_assemblyid (buf, domain, domain->entry_assembly);
5235                 break;
5236         }
5237         case CMD_APPDOMAIN_GET_CORLIB: {
5238                 domain = decode_domainid (p, &p, end, NULL, &err);
5239                 if (err)
5240                         return err;
5241
5242                 buffer_add_assemblyid (buf, domain, domain->domain->mbr.obj.vtable->klass->image->assembly);
5243                 break;
5244         }
5245         case CMD_APPDOMAIN_CREATE_STRING: {
5246                 char *s;
5247                 MonoString *o;
5248
5249                 domain = decode_domainid (p, &p, end, NULL, &err);
5250                 if (err)
5251                         return err;
5252                 s = decode_string (p, &p, end);
5253
5254                 o = mono_string_new (domain, s);
5255                 buffer_add_objid (buf, (MonoObject*)o);
5256                 break;
5257         }
5258         case CMD_APPDOMAIN_CREATE_BOXED_VALUE: {
5259                 MonoClass *klass;
5260                 MonoDomain *domain2;
5261                 MonoObject *o;
5262
5263                 domain = decode_domainid (p, &p, end, NULL, &err);
5264                 if (err)
5265                         return err;
5266                 klass = decode_typeid (p, &p, end, &domain2, &err);
5267                 if (err)
5268                         return err;
5269
5270                 // FIXME:
5271                 g_assert (domain == domain2);
5272
5273                 o = mono_object_new (domain, klass);
5274
5275                 err = decode_value (&klass->byval_arg, domain, mono_object_unbox (o), p, &p, end);
5276                 if (err)
5277                         return err;
5278
5279                 buffer_add_objid (buf, o);
5280                 break;
5281         }
5282         default:
5283                 return ERR_NOT_IMPLEMENTED;
5284         }
5285
5286         return ERR_NONE;
5287 }
5288
5289 static ErrorCode
5290 assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
5291 {
5292         int err;
5293         MonoAssembly *ass;
5294         MonoDomain *domain;
5295
5296         ass = decode_assemblyid (p, &p, end, &domain, &err);
5297         if (err)
5298                 return err;
5299
5300         switch (command) {
5301         case CMD_ASSEMBLY_GET_LOCATION: {
5302                 buffer_add_string (buf, mono_image_get_filename (ass->image));
5303                 break;
5304         }
5305         case CMD_ASSEMBLY_GET_ENTRY_POINT: {
5306                 guint32 token;
5307                 MonoMethod *m;
5308
5309                 if (ass->image->dynamic) {
5310                         buffer_add_id (buf, 0);
5311                 } else {
5312                         token = mono_image_get_entry_point (ass->image);
5313                         if (token == 0) {
5314                                 buffer_add_id (buf, 0);
5315                         } else {
5316                                 m = mono_get_method (ass->image, token, NULL);
5317                                 buffer_add_methodid (buf, domain, m);
5318                         }
5319                 }
5320                 break;
5321         }
5322         case CMD_ASSEMBLY_GET_MANIFEST_MODULE: {
5323                 buffer_add_moduleid (buf, domain, ass->image);
5324                 break;
5325         }
5326         case CMD_ASSEMBLY_GET_OBJECT: {
5327                 MonoObject *o = (MonoObject*)mono_assembly_get_object (mono_domain_get (), ass);
5328                 buffer_add_objid (buf, o);
5329                 break;
5330         }
5331         case CMD_ASSEMBLY_GET_TYPE: {
5332                 char *s = decode_string (p, &p, end);
5333                 gboolean ignorecase = decode_byte (p, &p, end);
5334                 MonoTypeNameParse info;
5335                 MonoType *t;
5336                 gboolean type_resolve;
5337
5338                 if (!mono_reflection_parse_type (s, &info)) {
5339                         t = NULL;
5340                 } else {
5341                         if (info.assembly.name)
5342                                 NOT_IMPLEMENTED;
5343                         t = mono_reflection_get_type (ass->image, &info, ignorecase, &type_resolve);
5344                 }
5345                 buffer_add_typeid (buf, domain, t ? mono_class_from_mono_type (t) : NULL);
5346                 mono_reflection_free_type_info (&info);
5347                 g_free (s);
5348
5349                 break;
5350         }
5351         case CMD_ASSEMBLY_GET_NAME: {
5352                 gchar *name;
5353                 MonoAssembly *mass = ass;
5354
5355                 name = g_strdup_printf (
5356                   "%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s",
5357                   mass->aname.name,
5358                   mass->aname.major, mass->aname.minor, mass->aname.build, mass->aname.revision,
5359                   mass->aname.culture && *mass->aname.culture? mass->aname.culture: "neutral",
5360                   mass->aname.public_key_token [0] ? (char *)mass->aname.public_key_token : "null",
5361                   (mass->aname.flags & ASSEMBLYREF_RETARGETABLE_FLAG) ? ", Retargetable=Yes" : "");
5362
5363                 buffer_add_string (buf, name);
5364                 g_free (name);
5365                 break;
5366         }
5367         default:
5368                 return ERR_NOT_IMPLEMENTED;
5369         }
5370
5371         return ERR_NONE;
5372 }
5373
5374 static ErrorCode
5375 module_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
5376 {
5377         int err;
5378         MonoDomain *domain;
5379
5380         switch (command) {
5381         case CMD_MODULE_GET_INFO: {
5382                 MonoImage *image = decode_moduleid (p, &p, end, &domain, &err);
5383                 char *basename;
5384
5385                 basename = g_path_get_basename (image->name);
5386                 buffer_add_string (buf, basename); // name
5387                 buffer_add_string (buf, image->module_name); // scopename
5388                 buffer_add_string (buf, image->name); // fqname
5389                 buffer_add_string (buf, mono_image_get_guid (image)); // guid
5390                 buffer_add_assemblyid (buf, domain, image->assembly); // assembly
5391                 g_free (basename);
5392                 break;
5393         }
5394         default:
5395                 return ERR_NOT_IMPLEMENTED;
5396         }
5397
5398         return ERR_NONE;
5399 }
5400
5401 static void
5402 buffer_add_cattr_arg (Buffer *buf, MonoType *t, MonoDomain *domain, MonoObject *val)
5403 {
5404         if (val && val->vtable->klass == mono_defaults.monotype_class) {
5405                 /* Special case these so the client doesn't have to handle Type objects */
5406
5407                 buffer_add_byte (buf, VALUE_TYPE_ID_TYPE);
5408                 buffer_add_typeid (buf, domain, mono_class_from_mono_type (((MonoReflectionType*)val)->type));
5409         } else if (MONO_TYPE_IS_REFERENCE (t))
5410                 buffer_add_value (buf, t, &val, domain);
5411         else
5412                 buffer_add_value (buf, t, mono_object_unbox (val), domain);
5413 }
5414
5415 static void
5416 buffer_add_cattrs (Buffer *buf, MonoDomain *domain, MonoImage *image, MonoClass *attr_klass, MonoCustomAttrInfo *cinfo)
5417 {
5418         int i, j;
5419         int nattrs = 0;
5420
5421         if (!cinfo) {
5422                 buffer_add_int (buf, 0);
5423                 return;
5424         }
5425
5426         for (i = 0; i < cinfo->num_attrs; ++i) {
5427                 if (!attr_klass || mono_class_has_parent (cinfo->attrs [i].ctor->klass, attr_klass))
5428                         nattrs ++;
5429         }
5430         buffer_add_int (buf, nattrs);
5431
5432         for (i = 0; i < cinfo->num_attrs; ++i) {
5433                 MonoCustomAttrEntry *attr = &cinfo->attrs [i];
5434                 if (!attr_klass || mono_class_has_parent (attr->ctor->klass, attr_klass)) {
5435                         MonoArray *typed_args, *named_args;
5436                         MonoType *t;
5437                         CattrNamedArg *arginfo;
5438
5439                         mono_reflection_create_custom_attr_data_args (image, attr->ctor, attr->data, attr->data_size, &typed_args, &named_args, &arginfo);
5440
5441                         buffer_add_methodid (buf, domain, attr->ctor);
5442
5443                         /* Ctor args */
5444                         if (typed_args) {
5445                                 buffer_add_int (buf, mono_array_length (typed_args));
5446                                 for (j = 0; j < mono_array_length (typed_args); ++j) {
5447                                         MonoObject *val = mono_array_get (typed_args, MonoObject*, j);
5448
5449                                         t = mono_method_signature (attr->ctor)->params [j];
5450
5451                                         buffer_add_cattr_arg (buf, t, domain, val);
5452                                 }
5453                         } else {
5454                                 buffer_add_int (buf, 0);
5455                         }
5456
5457                         /* Named args */
5458                         if (named_args) {
5459                                 buffer_add_int (buf, mono_array_length (named_args));
5460
5461                                 for (j = 0; j < mono_array_length (named_args); ++j) {
5462                                         MonoObject *val = mono_array_get (named_args, MonoObject*, j);
5463
5464                                         if (arginfo [j].prop) {
5465                                                 buffer_add_byte (buf, 0x54);
5466                                                 buffer_add_propertyid (buf, domain, arginfo [j].prop);
5467                                         } else if (arginfo [j].field) {
5468                                                 buffer_add_byte (buf, 0x53);
5469                                         } else {
5470                                                 g_assert_not_reached ();
5471                                         }
5472
5473                                         buffer_add_cattr_arg (buf, arginfo [j].type, domain, val);
5474                                 }
5475                         } else {
5476                                 buffer_add_int (buf, 0);
5477                         }
5478                 }
5479         }
5480 }
5481
5482 static ErrorCode
5483 type_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
5484 {
5485         MonoClass *klass;
5486         MonoDomain *domain;
5487         MonoClass *nested;
5488         MonoType *type;
5489         gpointer iter;
5490         guint8 b;
5491         int err, nnested;
5492         char *name;
5493
5494         klass = decode_typeid (p, &p, end, &domain, &err);
5495         if (err)
5496                 return err;
5497
5498         switch (command) {
5499         case CMD_TYPE_GET_INFO: {
5500                 buffer_add_string (buf, klass->name_space);
5501                 buffer_add_string (buf, klass->name);
5502                 // FIXME: byref
5503                 name = mono_type_get_name_full (&klass->byval_arg, MONO_TYPE_NAME_FORMAT_FULL_NAME);
5504                 buffer_add_string (buf, name);
5505                 g_free (name);
5506                 buffer_add_assemblyid (buf, domain, klass->image->assembly);
5507                 buffer_add_moduleid (buf, domain, klass->image);
5508                 buffer_add_typeid (buf, domain, klass->parent);
5509                 if (klass->rank || klass->byval_arg.type == MONO_TYPE_PTR)
5510                         buffer_add_typeid (buf, domain, klass->element_class);
5511                 else
5512                         buffer_add_id (buf, 0);
5513                 buffer_add_int (buf, klass->type_token);
5514                 buffer_add_byte (buf, klass->rank);
5515                 buffer_add_int (buf, klass->flags);
5516                 b = 0;
5517                 type = &klass->byval_arg;
5518                 // FIXME: Can't decide whenever a class represents a byref type
5519                 if (FALSE)
5520                         b |= (1 << 0);
5521                 if (type->type == MONO_TYPE_PTR)
5522                         b |= (1 << 1);
5523                 if (!type->byref && (((type->type >= MONO_TYPE_BOOLEAN) && (type->type <= MONO_TYPE_R8)) || (type->type == MONO_TYPE_I) || (type->type == MONO_TYPE_U)))
5524                         b |= (1 << 2);
5525                 if (type->type == MONO_TYPE_VALUETYPE)
5526                         b |= (1 << 3);
5527                 if (klass->enumtype)
5528                         b |= (1 << 4);
5529                 buffer_add_byte (buf, b);
5530                 nnested = 0;
5531                 iter = NULL;
5532                 while ((nested = mono_class_get_nested_types (klass, &iter)))
5533                         nnested ++;
5534                 buffer_add_int (buf, nnested);
5535                 iter = NULL;
5536                 while ((nested = mono_class_get_nested_types (klass, &iter)))
5537                         buffer_add_typeid (buf, domain, nested);
5538                 break;
5539         }
5540         case CMD_TYPE_GET_METHODS: {
5541                 int nmethods;
5542                 int i = 0;
5543                 gpointer iter = NULL;
5544                 MonoMethod *m;
5545
5546                 mono_class_setup_methods (klass);
5547
5548                 nmethods = mono_class_num_methods (klass);
5549
5550                 buffer_add_int (buf, nmethods);
5551
5552                 while ((m = mono_class_get_methods (klass, &iter))) {
5553                         buffer_add_methodid (buf, domain, m);
5554                         i ++;
5555                 }
5556                 g_assert (i == nmethods);
5557                 break;
5558         }
5559         case CMD_TYPE_GET_FIELDS: {
5560                 int nfields;
5561                 int i = 0;
5562                 gpointer iter = NULL;
5563                 MonoClassField *f;
5564
5565                 nfields = mono_class_num_fields (klass);
5566
5567                 buffer_add_int (buf, nfields);
5568
5569                 while ((f = mono_class_get_fields (klass, &iter))) {
5570                         buffer_add_fieldid (buf, domain, f);
5571                         buffer_add_string (buf, f->name);
5572                         buffer_add_typeid (buf, domain, mono_class_from_mono_type (f->type));
5573                         buffer_add_int (buf, f->type->attrs);
5574                         i ++;
5575                 }
5576                 g_assert (i == nfields);
5577                 break;
5578         }
5579         case CMD_TYPE_GET_PROPERTIES: {
5580                 int nprops;
5581                 int i = 0;
5582                 gpointer iter = NULL;
5583                 MonoProperty *p;
5584
5585                 nprops = mono_class_num_properties (klass);
5586
5587                 buffer_add_int (buf, nprops);
5588
5589                 while ((p = mono_class_get_properties (klass, &iter))) {
5590                         buffer_add_propertyid (buf, domain, p);
5591                         buffer_add_string (buf, p->name);
5592                         buffer_add_methodid (buf, domain, p->get);
5593                         buffer_add_methodid (buf, domain, p->set);
5594                         buffer_add_int (buf, p->attrs);
5595                         i ++;
5596                 }
5597                 g_assert (i == nprops);
5598                 break;
5599         }
5600         case CMD_TYPE_GET_CATTRS: {
5601                 MonoClass *attr_klass = decode_typeid (p, &p, end, NULL, &err);
5602                 MonoCustomAttrInfo *cinfo;
5603
5604                 cinfo = mono_custom_attrs_from_class (klass);
5605
5606                 buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo);
5607                 break;
5608         }
5609         case CMD_TYPE_GET_FIELD_CATTRS: {
5610                 MonoClass *attr_klass;
5611                 MonoCustomAttrInfo *cinfo;
5612                 MonoClassField *field;
5613
5614                 field = decode_fieldid (p, &p, end, NULL, &err);
5615                 if (err)
5616                         return err;
5617                 attr_klass = decode_typeid (p, &p, end, NULL, &err);
5618                 if (err)
5619                         return err;
5620
5621                 cinfo = mono_custom_attrs_from_field (klass, field);
5622
5623                 buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo);
5624                 break;
5625         }
5626         case CMD_TYPE_GET_PROPERTY_CATTRS: {
5627                 MonoClass *attr_klass;
5628                 MonoCustomAttrInfo *cinfo;
5629                 MonoProperty *prop;
5630
5631                 prop = decode_propertyid (p, &p, end, NULL, &err);
5632                 if (err)
5633                         return err;
5634                 attr_klass = decode_typeid (p, &p, end, NULL, &err);
5635                 if (err)
5636                         return err;
5637
5638                 cinfo = mono_custom_attrs_from_property (klass, prop);
5639
5640                 buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo);
5641                 break;
5642         }
5643         case CMD_TYPE_GET_VALUES: {
5644                 guint8 *val;
5645                 MonoClassField *f;
5646                 MonoVTable *vtable;
5647                 MonoClass *k;
5648                 int len, i;
5649                 gboolean found;
5650
5651                 len = decode_int (p, &p, end);
5652                 for (i = 0; i < len; ++i) {
5653                         f = decode_fieldid (p, &p, end, NULL, &err);
5654                         if (err)
5655                                 return err;
5656
5657                         if (!(f->type->attrs & FIELD_ATTRIBUTE_STATIC))
5658                                 return ERR_INVALID_FIELDID;
5659                         if (mono_class_field_is_special_static (f))
5660                                 return ERR_INVALID_FIELDID;
5661
5662                         /* Check that the field belongs to the object */
5663                         found = FALSE;
5664                         for (k = klass; k; k = k->parent) {
5665                                 if (k == f->parent) {
5666                                         found = TRUE;
5667                                         break;
5668                                 }
5669                         }
5670                         if (!found)
5671                                 return ERR_INVALID_FIELDID;
5672
5673                         vtable = mono_class_vtable (domain, f->parent);
5674                         val = g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
5675                         mono_field_static_get_value (vtable, f, val);
5676                         buffer_add_value (buf, f->type, val, domain);
5677                         g_free (val);
5678                 }
5679                 break;
5680         }
5681         case CMD_TYPE_SET_VALUES: {
5682                 guint8 *val;
5683                 MonoClassField *f;
5684                 MonoVTable *vtable;
5685                 MonoClass *k;
5686                 int len, i;
5687                 gboolean found;
5688
5689                 len = decode_int (p, &p, end);
5690                 for (i = 0; i < len; ++i) {
5691                         f = decode_fieldid (p, &p, end, NULL, &err);
5692                         if (err)
5693                                 return err;
5694
5695                         if (!(f->type->attrs & FIELD_ATTRIBUTE_STATIC))
5696                                 return ERR_INVALID_FIELDID;
5697                         if (mono_class_field_is_special_static (f))
5698                                 return ERR_INVALID_FIELDID;
5699
5700                         /* Check that the field belongs to the object */
5701                         found = FALSE;
5702                         for (k = klass; k; k = k->parent) {
5703                                 if (k == f->parent) {
5704                                         found = TRUE;
5705                                         break;
5706                                 }
5707                         }
5708                         if (!found)
5709                                 return ERR_INVALID_FIELDID;
5710
5711                         // FIXME: Check for literal/const
5712
5713                         vtable = mono_class_vtable (domain, f->parent);
5714                         val = g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
5715                         err = decode_value (f->type, domain, val, p, &p, end);
5716                         if (err) {
5717                                 g_free (val);
5718                                 return err;
5719                         }
5720                         if (MONO_TYPE_IS_REFERENCE (f->type))
5721                                 mono_field_static_set_value (vtable, f, *(gpointer*)val);
5722                         else
5723                                 mono_field_static_set_value (vtable, f, val);
5724                         g_free (val);
5725                 }
5726                 break;
5727         }
5728         case CMD_TYPE_GET_OBJECT: {
5729                 MonoObject *o = (MonoObject*)mono_type_get_object (mono_domain_get (), &klass->byval_arg);
5730                 buffer_add_objid (buf, o);
5731                 break;
5732         }
5733         case CMD_TYPE_GET_SOURCE_FILES: {
5734                 gpointer iter = NULL;
5735                 MonoMethod *method;
5736                 char *source_file, *base;
5737                 GPtrArray *files;
5738                 int i;
5739
5740                 files = g_ptr_array_new ();
5741
5742                 while ((method = mono_class_get_methods (klass, &iter))) {
5743                         MonoDebugMethodInfo *minfo = mono_debug_lookup_method (method);
5744
5745                         if (minfo) {
5746                                 mono_debug_symfile_get_line_numbers (minfo, &source_file, NULL, NULL, NULL);
5747                                 if (!source_file)
5748                                         continue;
5749
5750                                 for (i = 0; i < files->len; ++i)
5751                                         if (!strcmp (g_ptr_array_index (files, i), source_file))
5752                                                 break;
5753                                 if (i == files->len)
5754                                         g_ptr_array_add (files, g_strdup (source_file));
5755                                 g_free (source_file);
5756                         }
5757                 }
5758
5759                 buffer_add_int (buf, files->len);
5760                 for (i = 0; i < files->len; ++i) {
5761                         source_file = g_ptr_array_index (files, i);
5762                         base = g_path_get_basename (source_file);
5763                         buffer_add_string (buf, base);
5764                         g_free (base);
5765                         g_free (source_file);
5766                 }
5767                 g_ptr_array_free (files, TRUE);
5768                 break;
5769         }
5770         case CMD_TYPE_IS_ASSIGNABLE_FROM: {
5771                 MonoClass *oklass = decode_typeid (p, &p, end, NULL, &err);
5772
5773                 if (err)
5774                         return err;
5775                 if (mono_class_is_assignable_from (klass, oklass))
5776                         buffer_add_byte (buf, 1);
5777                 else
5778                         buffer_add_byte (buf, 0);
5779                 break;
5780         }
5781         default:
5782                 return ERR_NOT_IMPLEMENTED;
5783         }
5784
5785         return ERR_NONE;
5786 }
5787
5788 static ErrorCode
5789 method_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
5790 {
5791         int err;
5792         MonoDomain *domain;
5793         MonoMethod *method;
5794         MonoMethodHeader *header;
5795
5796         method = decode_methodid (p, &p, end, &domain, &err);
5797         if (err)
5798                 return err;
5799
5800         switch (command) {
5801         case CMD_METHOD_GET_NAME: {
5802                 buffer_add_string (buf, method->name);
5803                 break;
5804         }
5805         case CMD_METHOD_GET_DECLARING_TYPE: {
5806                 buffer_add_typeid (buf, domain, method->klass);
5807                 break;
5808         }
5809         case CMD_METHOD_GET_DEBUG_INFO: {
5810                 MonoDebugMethodInfo *minfo;
5811                 char *source_file;
5812                 int i, n_il_offsets;
5813                 int *il_offsets;
5814                 int *line_numbers;
5815
5816                 header = mono_method_get_header (method);
5817                 if (!header) {
5818                         buffer_add_int (buf, 0);
5819                         buffer_add_string (buf, "");
5820                         buffer_add_int (buf, 0);
5821                         break;
5822                 }
5823
5824                 minfo = mono_debug_lookup_method (method);
5825                 if (!minfo) {
5826                         buffer_add_int (buf, header->code_size);
5827                         buffer_add_string (buf, "");
5828                         buffer_add_int (buf, 0);
5829                         mono_metadata_free_mh (header);
5830                         break;
5831                 }
5832
5833                 mono_debug_symfile_get_line_numbers (minfo, &source_file, &n_il_offsets, &il_offsets, &line_numbers);
5834                 buffer_add_int (buf, header->code_size);
5835                 buffer_add_string (buf, source_file);
5836                 buffer_add_int (buf, n_il_offsets);
5837                 //printf ("Line number table for method %s:\n", mono_method_full_name (method,  TRUE));
5838                 for (i = 0; i < n_il_offsets; ++i) {
5839                         //printf ("IL%d -> %d\n", il_offsets [i], line_numbers [i]);
5840                         buffer_add_int (buf, il_offsets [i]);
5841                         buffer_add_int (buf, line_numbers [i]);
5842                 }
5843                 g_free (source_file);
5844                 g_free (il_offsets);
5845                 g_free (line_numbers);
5846                 mono_metadata_free_mh (header);
5847                 break;
5848         }
5849         case CMD_METHOD_GET_PARAM_INFO: {
5850                 MonoMethodSignature *sig = mono_method_signature (method);
5851                 guint32 i;
5852                 char **names;
5853
5854                 /* FIXME: mono_class_from_mono_type () and byrefs */
5855
5856                 /* FIXME: Use a smaller encoding */
5857                 buffer_add_int (buf, sig->call_convention);
5858                 buffer_add_int (buf, sig->param_count);
5859                 buffer_add_int (buf, sig->generic_param_count);
5860                 buffer_add_typeid (buf, domain, mono_class_from_mono_type (sig->ret));
5861                 for (i = 0; i < sig->param_count; ++i) {
5862                         /* FIXME: vararg */
5863                         buffer_add_typeid (buf, domain, mono_class_from_mono_type (sig->params [i]));
5864                 }
5865
5866                 /* Emit parameter names */
5867                 names = g_new (char *, sig->param_count);
5868                 mono_method_get_param_names (method, (const char **) names);
5869                 for (i = 0; i < sig->param_count; ++i)
5870                         buffer_add_string (buf, names [i]);
5871                 g_free (names);
5872
5873                 break;
5874         }
5875         case CMD_METHOD_GET_LOCALS_INFO: {
5876                 int i, j, num_locals;
5877                 char **local_names;
5878                 int *local_indexes;
5879
5880                 header = mono_method_get_header (method);
5881                 g_assert (header);
5882
5883                 buffer_add_int (buf, header->num_locals);
5884
5885                 /* Types */
5886                 for (i = 0; i < header->num_locals; ++i)
5887                         buffer_add_typeid (buf, domain, mono_class_from_mono_type (header->locals [i]));
5888
5889                 /* Names */
5890                 num_locals = mono_debug_lookup_locals (method, &local_names, &local_indexes);
5891                 for (i = 0; i < header->num_locals; ++i) {
5892                         for (j = 0; j < num_locals; ++j)
5893                                 if (local_indexes [j] == i)
5894                                         break;
5895                         if (j < num_locals)
5896                                 buffer_add_string (buf, local_names [j]);
5897                         else
5898                                 buffer_add_string (buf, "");
5899                 }
5900                 g_free (local_names);
5901                 g_free (local_indexes);
5902
5903                 /* Live ranges */
5904                 /* FIXME: This works because we set debug_options.mdb_optimizations */
5905                 for (i = 0; i < header->num_locals; ++i) {
5906                         buffer_add_int (buf, 0);
5907                         buffer_add_int (buf, header->code_size);
5908                 }
5909                 mono_metadata_free_mh (header);
5910
5911                 break;
5912         }
5913         case CMD_METHOD_GET_INFO:
5914                 buffer_add_int (buf, method->flags);
5915                 buffer_add_int (buf, method->iflags);
5916                 buffer_add_int (buf, method->token);
5917                 break;
5918         case CMD_METHOD_GET_BODY: {
5919                 int i;
5920
5921                 header = mono_method_get_header (method);
5922                 if (!header) {
5923                         buffer_add_int (buf, 0);
5924                 } else {
5925                         buffer_add_int (buf, header->code_size);
5926                         for (i = 0; i < header->code_size; ++i)
5927                                 buffer_add_byte (buf, header->code [i]);
5928                 }
5929                 mono_metadata_free_mh (header);
5930                 break;
5931         }
5932         case CMD_METHOD_RESOLVE_TOKEN: {
5933                 guint32 token = decode_int (p, &p, end);
5934
5935                 // FIXME: Generics
5936                 switch (mono_metadata_token_code (token)) {
5937                 case MONO_TOKEN_STRING: {
5938                         MonoString *s;
5939                         char *s2;
5940
5941                         s = mono_ldstr (domain, method->klass->image, mono_metadata_token_index (token));
5942                         g_assert (s);
5943
5944                         s2 = mono_string_to_utf8 (s);
5945
5946                         buffer_add_byte (buf, TOKEN_TYPE_STRING);
5947                         buffer_add_string (buf, s2);
5948                         g_free (s2);
5949                         break;
5950                 }
5951                 default: {
5952                         gpointer val;
5953                         MonoClass *handle_class;
5954
5955                         if (method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD) {
5956                                 val = mono_method_get_wrapper_data (method, token);
5957                                 handle_class = mono_method_get_wrapper_data (method, token + 1);
5958
5959                                 if (handle_class == NULL) {
5960                                         // Can't figure out the token type
5961                                         buffer_add_byte (buf, TOKEN_TYPE_UNKNOWN);
5962                                         break;
5963                                 }
5964                         } else {
5965                                 val = mono_ldtoken (method->klass->image, token, &handle_class, NULL);
5966                                 g_assert (val);
5967                         }
5968
5969                         if (handle_class == mono_defaults.typehandle_class) {
5970                                 buffer_add_byte (buf, TOKEN_TYPE_TYPE);
5971                                 buffer_add_typeid (buf, domain, mono_class_from_mono_type ((MonoType*)val));
5972                         } else if (handle_class == mono_defaults.fieldhandle_class) {
5973                                 buffer_add_byte (buf, TOKEN_TYPE_FIELD);
5974                                 buffer_add_fieldid (buf, domain, val);
5975                         } else if (handle_class == mono_defaults.methodhandle_class) {
5976                                 buffer_add_byte (buf, TOKEN_TYPE_METHOD);
5977                                 buffer_add_methodid (buf, domain, val);
5978                         } else if (handle_class == mono_defaults.string_class) {
5979                                 char *s;
5980
5981                                 s = mono_string_to_utf8 (val);
5982                                 buffer_add_byte (buf, TOKEN_TYPE_STRING);
5983                                 buffer_add_string (buf, s);
5984                                 g_free (s);
5985                         } else {
5986                                 g_assert_not_reached ();
5987                         }
5988                         break;
5989                 }
5990                 }
5991                 break;
5992         }
5993         default:
5994                 return ERR_NOT_IMPLEMENTED;
5995         }
5996
5997         return ERR_NONE;
5998 }
5999
6000 static ErrorCode
6001 thread_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
6002 {
6003         int objid = decode_objid (p, &p, end);
6004         int err;
6005         MonoThread *thread_obj;
6006         MonoInternalThread *thread;
6007
6008         err = get_object (objid, (MonoObject**)&thread_obj);
6009         if (err)
6010                 return err;
6011
6012         thread = THREAD_TO_INTERNAL (thread_obj);
6013
6014         switch (command) {
6015         case CMD_THREAD_GET_NAME: {
6016                 guint32 name_len;
6017                 gunichar2 *s = mono_thread_get_name (thread, &name_len);
6018
6019                 if (!s) {
6020                         buffer_add_int (buf, 0);
6021                 } else {
6022                         char *name;
6023                         glong len;
6024
6025                         name = g_utf16_to_utf8 (s, name_len, NULL, &len, NULL);
6026                         g_assert (name);
6027                         buffer_add_int (buf, len);
6028                         buffer_add_data (buf, (guint8*)name, len);
6029                         g_free (s);
6030                 }
6031                 break;
6032         }
6033         case CMD_THREAD_GET_FRAME_INFO: {
6034                 DebuggerTlsData *tls;
6035                 int i, start_frame, length;
6036
6037                 // Wait for suspending if it already started
6038                 if (suspend_count)
6039                         wait_for_suspend ();
6040                 if (!is_suspended ())
6041                         return ERR_NOT_SUSPENDED;
6042
6043                 start_frame = decode_int (p, &p, end);
6044                 length = decode_int (p, &p, end);
6045
6046                 if (start_frame != 0 || length != -1)
6047                         return ERR_NOT_IMPLEMENTED;
6048
6049                 mono_loader_lock ();
6050                 tls = mono_g_hash_table_lookup (thread_to_tls, thread);
6051                 mono_loader_unlock ();
6052                 g_assert (tls);
6053
6054                 compute_frame_info (thread, tls);
6055
6056                 buffer_add_int (buf, tls->frame_count);
6057                 for (i = 0; i < tls->frame_count; ++i) {
6058                         buffer_add_int (buf, tls->frames [i]->id);
6059                         buffer_add_methodid (buf, tls->frames [i]->domain, tls->frames [i]->method);
6060                         buffer_add_int (buf, tls->frames [i]->il_offset);
6061                         /*
6062                          * Instead of passing the frame type directly to the client, we associate
6063                          * it with the previous frame using a set of flags. This avoids lots of
6064                          * conditional code in the client, since a frame whose type isn't
6065                          * FRAME_TYPE_MANAGED has no method, location, etc.
6066                          */
6067                         buffer_add_byte (buf, tls->frames [i]->flags);
6068                 }
6069
6070                 break;
6071         }
6072         case CMD_THREAD_GET_STATE:
6073                 buffer_add_int (buf, thread->state);
6074                 break;
6075         case CMD_THREAD_GET_INFO:
6076                 buffer_add_byte (buf, thread->threadpool_thread);
6077                 break;
6078         case CMD_THREAD_GET_ID:
6079                 buffer_add_long (buf, (guint64)thread);
6080                 break;
6081         default:
6082                 return ERR_NOT_IMPLEMENTED;
6083         }
6084
6085         return ERR_NONE;
6086 }
6087
6088 static ErrorCode
6089 frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
6090 {
6091         int objid;
6092         int err;
6093         MonoThread *thread_obj;
6094         MonoInternalThread *thread;
6095         int pos, i, len;
6096         DebuggerTlsData *tls;
6097         StackFrame *frame;
6098         MonoDebugMethodJitInfo *jit;
6099         MonoDebugVarInfo *var;
6100         MonoMethodSignature *sig;
6101         gssize id;
6102         MonoMethodHeader *header;
6103
6104         objid = decode_objid (p, &p, end);
6105         err = get_object (objid, (MonoObject**)&thread_obj);
6106         if (err)
6107                 return err;
6108
6109         thread = THREAD_TO_INTERNAL (thread_obj);
6110
6111         id = decode_id (p, &p, end);
6112
6113         mono_loader_lock ();
6114         tls = mono_g_hash_table_lookup (thread_to_tls, thread);
6115         mono_loader_unlock ();
6116         g_assert (tls);
6117
6118         for (i = 0; i < tls->frame_count; ++i) {
6119                 if (tls->frames [i]->id == id)
6120                         break;
6121         }
6122         if (i == tls->frame_count)
6123                 return ERR_INVALID_FRAMEID;
6124
6125         frame = tls->frames [i];
6126
6127         if (!frame->has_ctx)
6128                 // FIXME:
6129                 return ERR_INVALID_FRAMEID;
6130
6131         if (!frame->jit) {
6132                 frame->jit = mono_debug_find_method (frame->method, frame->domain);
6133                 g_assert (frame->jit);
6134         }
6135         jit = frame->jit;
6136
6137         sig = mono_method_signature (frame->method);
6138
6139         switch (command) {
6140         case CMD_STACK_FRAME_GET_VALUES: {
6141                 len = decode_int (p, &p, end);
6142                 header = mono_method_get_header (frame->method);
6143
6144                 for (i = 0; i < len; ++i) {
6145                         pos = decode_int (p, &p, end);
6146
6147                         if (pos < 0) {
6148                                 pos = - pos - 1;
6149
6150                                 g_assert (pos >= 0 && pos < jit->num_params);
6151
6152                                 var = &jit->params [pos];
6153
6154                                 add_var (buf, sig->params [pos], &jit->params [pos], &frame->ctx, frame->domain, FALSE);
6155                         } else {
6156                                 g_assert (pos >= 0 && pos < jit->num_locals);
6157
6158                                 var = &jit->locals [pos];
6159
6160                                 add_var (buf, header->locals [pos], &jit->locals [pos], &frame->ctx, frame->domain, FALSE);
6161                         }
6162                 }
6163                 mono_metadata_free_mh (header);
6164                 break;
6165         }
6166         case CMD_STACK_FRAME_GET_THIS: {
6167                 if (frame->method->klass->valuetype) {
6168                         if (!sig->hasthis) {
6169                                 MonoObject *p = NULL;
6170                                 buffer_add_value (buf, &mono_defaults.object_class->byval_arg, &p, frame->domain);
6171                         } else {
6172                                 add_var (buf, &frame->method->klass->this_arg, jit->this_var, &frame->ctx, frame->domain, TRUE);
6173                         }
6174                 } else {
6175                         if (!sig->hasthis) {
6176                                 MonoObject *p = NULL;
6177                                 buffer_add_value (buf, &frame->method->klass->byval_arg, &p, frame->domain);
6178                         } else {
6179                                 add_var (buf, &frame->method->klass->byval_arg, jit->this_var, &frame->ctx, frame->domain, TRUE);
6180                         }
6181                 }
6182                 break;
6183         }
6184         case CMD_STACK_FRAME_SET_VALUES: {
6185                 guint8 *val_buf;
6186                 MonoType *t;
6187                 MonoDebugVarInfo *var;
6188
6189                 len = decode_int (p, &p, end);
6190                 header = mono_method_get_header (frame->method);
6191
6192                 for (i = 0; i < len; ++i) {
6193                         pos = decode_int (p, &p, end);
6194
6195                         if (pos < 0) {
6196                                 pos = - pos - 1;
6197
6198                                 g_assert (pos >= 0 && pos < jit->num_params);
6199
6200                                 t = sig->params [pos];
6201                                 var = &jit->params [pos];
6202                         } else {
6203                                 g_assert (pos >= 0 && pos < jit->num_locals);
6204
6205                                 t = header->locals [pos];
6206                                 var = &jit->locals [pos];
6207                         }
6208
6209                         if (MONO_TYPE_IS_REFERENCE (t))
6210                                 val_buf = g_alloca (sizeof (MonoObject*));
6211                         else
6212                                 val_buf = g_alloca (mono_class_instance_size (mono_class_from_mono_type (t)));
6213                         err = decode_value (t, frame->domain, val_buf, p, &p, end);
6214                         if (err)
6215                                 return err;
6216
6217                         set_var (t, var, &frame->ctx, frame->domain, val_buf);
6218                 }
6219                 mono_metadata_free_mh (header);
6220                 break;
6221         }
6222         default:
6223                 return ERR_NOT_IMPLEMENTED;
6224         }
6225
6226         return ERR_NONE;
6227 }
6228
6229 static ErrorCode
6230 array_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
6231 {
6232         MonoArray *arr;
6233         int objid, err, index, len, i, esize;
6234         gpointer elem;
6235
6236         objid = decode_objid (p, &p, end);
6237         err = get_object (objid, (MonoObject**)&arr);
6238         if (err)
6239                 return err;
6240
6241         switch (command) {
6242         case CMD_ARRAY_REF_GET_LENGTH:
6243                 buffer_add_int (buf, arr->obj.vtable->klass->rank);
6244                 if (!arr->bounds) {
6245                         buffer_add_int (buf, arr->max_length);
6246                         buffer_add_int (buf, 0);
6247                 } else {
6248                         for (i = 0; i < arr->obj.vtable->klass->rank; ++i) {
6249                                 buffer_add_int (buf, arr->bounds [i].length);
6250                                 buffer_add_int (buf, arr->bounds [i].lower_bound);
6251                         }
6252                 }
6253                 break;
6254         case CMD_ARRAY_REF_GET_VALUES:
6255                 index = decode_int (p, &p, end);
6256                 len = decode_int (p, &p, end);
6257
6258                 g_assert (index >= 0 && len >= 0);
6259                 // Reordered to avoid integer overflow
6260                 g_assert (!(index > arr->max_length - len));
6261
6262                 esize = mono_array_element_size (arr->obj.vtable->klass);
6263                 for (i = index; i < index + len; ++i) {
6264                         elem = (gpointer*)((char*)arr->vector + (i * esize));
6265                         buffer_add_value (buf, &arr->obj.vtable->klass->element_class->byval_arg, elem, arr->obj.vtable->domain);
6266                 }
6267                 break;
6268         case CMD_ARRAY_REF_SET_VALUES:
6269                 index = decode_int (p, &p, end);
6270                 len = decode_int (p, &p, end);
6271
6272                 g_assert (index >= 0 && len >= 0);
6273                 // Reordered to avoid integer overflow
6274                 g_assert (!(index > arr->max_length - len));
6275
6276                 esize = mono_array_element_size (arr->obj.vtable->klass);
6277                 for (i = index; i < index + len; ++i) {
6278                         elem = (gpointer*)((char*)arr->vector + (i * esize));
6279
6280                         decode_value (&arr->obj.vtable->klass->element_class->byval_arg, arr->obj.vtable->domain, elem, p, &p, end);
6281                 }
6282                 break;
6283         default:
6284                 return ERR_NOT_IMPLEMENTED;
6285         }
6286
6287         return ERR_NONE;
6288 }
6289
6290 static ErrorCode
6291 string_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
6292 {
6293         int objid, err;
6294         MonoString *str;
6295         char *s;
6296
6297         objid = decode_objid (p, &p, end);
6298         err = get_object (objid, (MonoObject**)&str);
6299         if (err)
6300                 return err;
6301
6302         switch (command) {
6303         case CMD_STRING_REF_GET_VALUE:
6304                 s = mono_string_to_utf8 (str);
6305                 buffer_add_string (buf, s);
6306                 g_free (s);
6307                 break;
6308         default:
6309                 return ERR_NOT_IMPLEMENTED;
6310         }
6311
6312         return ERR_NONE;
6313 }
6314
6315 static ErrorCode
6316 object_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
6317 {
6318         int objid, err;
6319         MonoObject *obj;
6320         int len, i;
6321         MonoClassField *f;
6322         MonoClass *k;
6323         gboolean found;
6324
6325         if (command == CMD_OBJECT_REF_IS_COLLECTED) {
6326                 objid = decode_objid (p, &p, end);
6327                 err = get_object (objid, &obj);
6328                 if (err)
6329                         buffer_add_int (buf, 1);
6330                 else
6331                         buffer_add_int (buf, 0);
6332                 return 0;
6333         }
6334
6335         objid = decode_objid (p, &p, end);
6336         err = get_object (objid, &obj);
6337         if (err)
6338                 return err;
6339
6340         switch (command) {
6341         case CMD_OBJECT_REF_GET_TYPE:
6342                 buffer_add_typeid (buf, obj->vtable->domain, obj->vtable->klass);
6343                 break;
6344         case CMD_OBJECT_REF_GET_VALUES:
6345                 len = decode_int (p, &p, end);
6346
6347                 for (i = 0; i < len; ++i) {
6348                         MonoClassField *f = decode_fieldid (p, &p, end, NULL, &err);
6349                         if (err)
6350                                 return err;
6351
6352                         /* Check that the field belongs to the object */
6353                         found = FALSE;
6354                         for (k = obj->vtable->klass; k; k = k->parent) {
6355                                 if (k == f->parent) {
6356                                         found = TRUE;
6357                                         break;
6358                                 }
6359                         }
6360                         if (!found)
6361                                 return ERR_INVALID_FIELDID;
6362
6363                         if (f->type->attrs & FIELD_ATTRIBUTE_STATIC) {
6364                                 guint8 *val;
6365                                 MonoVTable *vtable;
6366
6367                                 if (mono_class_field_is_special_static (f))
6368                                         return ERR_INVALID_FIELDID;
6369
6370                                 g_assert (f->type->attrs & FIELD_ATTRIBUTE_STATIC);
6371                                 vtable = mono_class_vtable (obj->vtable->domain, f->parent);
6372                                 val = g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
6373                                 mono_field_static_get_value (vtable, f, val);
6374                                 buffer_add_value (buf, f->type, val, obj->vtable->domain);
6375                                 g_free (val);
6376                         } else {
6377                                 buffer_add_value (buf, f->type, (guint8*)obj + f->offset, obj->vtable->domain);
6378                         }
6379                 }
6380                 break;
6381         case CMD_OBJECT_REF_SET_VALUES:
6382                 len = decode_int (p, &p, end);
6383
6384                 for (i = 0; i < len; ++i) {
6385                         f = decode_fieldid (p, &p, end, NULL, &err);
6386                         if (err)
6387                                 return err;
6388
6389                         /* Check that the field belongs to the object */
6390                         found = FALSE;
6391                         for (k = obj->vtable->klass; k; k = k->parent) {
6392                                 if (k == f->parent) {
6393                                         found = TRUE;
6394                                         break;
6395                                 }
6396                         }
6397                         if (!found)
6398                                 return ERR_INVALID_FIELDID;
6399
6400                         if (f->type->attrs & FIELD_ATTRIBUTE_STATIC) {
6401                                 guint8 *val;
6402                                 MonoVTable *vtable;
6403
6404                                 if (mono_class_field_is_special_static (f))
6405                                         return ERR_INVALID_FIELDID;
6406
6407                                 g_assert (f->type->attrs & FIELD_ATTRIBUTE_STATIC);
6408                                 vtable = mono_class_vtable (obj->vtable->domain, f->parent);
6409
6410                                 val = g_malloc (mono_class_instance_size (mono_class_from_mono_type (f->type)));
6411                                 err = decode_value (f->type, obj->vtable->domain, val, p, &p, end);
6412                                 if (err) {
6413                                         g_free (val);
6414                                         return err;
6415                                 }
6416                                 mono_field_static_set_value (vtable, f, val);
6417                                 g_free (val);
6418                         } else {
6419                                 err = decode_value (f->type, obj->vtable->domain, (guint8*)obj + f->offset, p, &p, end);
6420                                 if (err)
6421                                         return err;
6422                         }
6423                 }
6424                 break;
6425         case CMD_OBJECT_REF_GET_ADDRESS:
6426                 buffer_add_long (buf, (gssize)obj);
6427                 break;
6428         case CMD_OBJECT_REF_GET_DOMAIN:
6429                 buffer_add_domainid (buf, obj->vtable->domain);
6430                 break;
6431         default:
6432                 return ERR_NOT_IMPLEMENTED;
6433         }
6434
6435         return ERR_NONE;
6436 }
6437
6438 static const char*
6439 command_set_to_string (CommandSet command_set)
6440 {
6441         switch (command_set) {
6442         case CMD_SET_VM:
6443                 return "VM";
6444         case CMD_SET_OBJECT_REF:
6445                 return "OBJECT_REF";
6446         case CMD_SET_STRING_REF:
6447                 return "STRING_REF";
6448         case CMD_SET_THREAD:
6449                 return "THREAD";
6450         case CMD_SET_ARRAY_REF:
6451                 return "ARRAY_REF";
6452         case CMD_SET_EVENT_REQUEST:
6453                 return "EVENT_REQUEST";
6454         case CMD_SET_STACK_FRAME:
6455                 return "STACK_FRAME";
6456         case CMD_SET_APPDOMAIN:
6457                 return "APPDOMAIN";
6458         case CMD_SET_ASSEMBLY:
6459                 return "ASSEMBLY";
6460         case CMD_SET_METHOD:
6461                 return "METHOD";
6462         case CMD_SET_TYPE:
6463                 return "TYPE";
6464         case CMD_SET_MODULE:
6465                 return "MODULE";
6466         case CMD_SET_EVENT:
6467                 return "EVENT";
6468         default:
6469                 return "";
6470         }
6471 }
6472
6473 /*
6474  * debugger_thread:
6475  *
6476  *   This thread handles communication with the debugger client using a JDWP
6477  * like protocol.
6478  */
6479 static guint32 WINAPI
6480 debugger_thread (void *arg)
6481 {
6482         int res, len, id, flags, command_set, command;
6483         guint8 header [HEADER_LENGTH];
6484         guint8 *data, *p, *end;
6485         Buffer buf;
6486         ErrorCode err;
6487         gboolean no_reply;
6488
6489         DEBUG (1, fprintf (log_file, "[dbg] Agent thread started, pid=%p\n", (gpointer)GetCurrentThreadId ()));
6490
6491         debugger_thread_id = GetCurrentThreadId ();
6492
6493         mono_jit_thread_attach (mono_get_root_domain ());
6494
6495         mono_thread_internal_current ()->flags |= MONO_THREAD_FLAG_DONT_MANAGE;
6496
6497         mono_set_is_debugger_attached (TRUE);
6498
6499         while (TRUE) {
6500                 res = recv_length (conn_fd, header, HEADER_LENGTH, 0);
6501
6502                 /* This will break if the socket is closed during shutdown too */
6503                 if (res != HEADER_LENGTH)
6504                         break;
6505
6506                 p = header;
6507                 end = header + HEADER_LENGTH;
6508
6509                 len = decode_int (p, &p, end);
6510                 id = decode_int (p, &p, end);
6511                 flags = decode_byte (p, &p, end);
6512                 command_set = decode_byte (p, &p, end);
6513                 command = decode_byte (p, &p, end);
6514
6515                 g_assert (flags == 0);
6516
6517                 DEBUG (1, fprintf (log_file, "[dbg] Received command %s(%d), id=%d.\n", command_set_to_string (command_set), command, id));
6518
6519                 data = g_malloc (len - HEADER_LENGTH);
6520                 if (len - HEADER_LENGTH > 0)
6521                 {
6522                         res = recv_length (conn_fd, data, len - HEADER_LENGTH, 0);
6523                         if (res != len - HEADER_LENGTH)
6524                                 break;
6525                 }
6526
6527                 p = data;
6528                 end = data + (len - HEADER_LENGTH);
6529
6530                 buffer_init (&buf, 128);
6531
6532                 err = ERR_NONE;
6533                 no_reply = FALSE;
6534
6535                 /* Process the request */
6536                 switch (command_set) {
6537                 case CMD_SET_VM:
6538                         err = vm_commands (command, id, p, end, &buf);
6539                         if (!err && command == CMD_VM_INVOKE_METHOD)
6540                                 /* Sent after the invoke is complete */
6541                                 no_reply = TRUE;
6542                         break;
6543                 case CMD_SET_EVENT_REQUEST:
6544                         err = event_commands (command, p, end, &buf);
6545                         break;
6546                 case CMD_SET_APPDOMAIN:
6547                         err = domain_commands (command, p, end, &buf);
6548                         break;
6549                 case CMD_SET_ASSEMBLY:
6550                         err = assembly_commands (command, p, end, &buf);
6551                         break;
6552                 case CMD_SET_MODULE:
6553                         err = module_commands (command, p, end, &buf);
6554                         break;
6555                 case CMD_SET_TYPE:
6556                         err = type_commands (command, p, end, &buf);
6557                         break;
6558                 case CMD_SET_METHOD:
6559                         err = method_commands (command, p, end, &buf);
6560                         break;
6561                 case CMD_SET_THREAD:
6562                         err = thread_commands (command, p, end, &buf);
6563                         break;
6564                 case CMD_SET_STACK_FRAME:
6565                         err = frame_commands (command, p, end, &buf);
6566                         break;
6567                 case CMD_SET_ARRAY_REF:
6568                         err = array_commands (command, p, end, &buf);
6569                         break;
6570                 case CMD_SET_STRING_REF:
6571                         err = string_commands (command, p, end, &buf);
6572                         break;
6573                 case CMD_SET_OBJECT_REF:
6574                         err = object_commands (command, p, end, &buf);
6575                         break;
6576                 default:
6577                         err = ERR_NOT_IMPLEMENTED;
6578                 }
6579
6580                 if (!no_reply)
6581                         send_reply_packet (id, err, &buf);
6582
6583                 g_free (data);
6584                 buffer_free (&buf);
6585
6586                 if (command_set == CMD_SET_VM && command == CMD_VM_DISPOSE)
6587                         break;
6588         }
6589
6590         mono_set_is_debugger_attached (FALSE);
6591
6592         mono_mutex_lock (&debugger_thread_exited_mutex);
6593         debugger_thread_exited = TRUE;
6594         mono_cond_signal (&debugger_thread_exited_cond);
6595         mono_mutex_unlock (&debugger_thread_exited_mutex);
6596
6597         DEBUG (1, printf ("[dbg] Debugger thread exited.\n"));
6598
6599         return 0;
6600 }
6601
6602 #else /* DISABLE_DEBUGGER_AGENT */
6603
6604 void
6605 mono_debugger_agent_parse_options (char *options)
6606 {
6607         g_error ("This runtime is configure with the debugger agent disabled.");
6608 }
6609
6610 void
6611 mono_debugger_agent_init (void)
6612 {
6613 }
6614
6615 void
6616 mono_debugger_agent_breakpoint_hit (void *sigctx)
6617 {
6618 }
6619
6620 void
6621 mono_debugger_agent_single_step_event (void *sigctx)
6622 {
6623 }
6624
6625 void
6626 mono_debugger_agent_free_domain_info (MonoDomain *domain)
6627 {
6628 }
6629
6630 gboolean
6631 mono_debugger_agent_thread_interrupt (void *sigctx, MonoJitInfo *ji)
6632 {
6633         return FALSE;
6634 }
6635
6636 void
6637 mono_debugger_agent_handle_exception (MonoException *ext, MonoContext *throw_ctx,
6638                                                                           MonoContext *catch_ctx)
6639 {
6640 }
6641 #endif
6642