mono/metadata/mono-debug.c

   1 /**
   2  * \file
   3  *
   4  * Author:
   5  *      Mono Project (http://www.mono-project.com)
   6  *
   7  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   8  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
   9  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
  10  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  11  */
  12
  13 #include <config.h>
  14 #include <mono/metadata/assembly.h>
  15 #include <mono/metadata/assembly-internals.h>
  16 #include <mono/metadata/tabledefs.h>
  17 #include <mono/metadata/tokentype.h>
  18 #include <mono/metadata/appdomain.h>
  19 #include <mono/metadata/class-internals.h>
  20 #include <mono/metadata/mono-debug.h>
  21 #include <mono/metadata/debug-internals.h>
  22 #include <mono/metadata/mono-endian.h>
  23 #include <mono/metadata/gc-internals.h>
  24 #include <mono/metadata/mempool.h>
  25 #include <mono/metadata/debug-mono-symfile.h>
  26 #include <mono/metadata/debug-mono-ppdb.h>
  27 #include <mono/metadata/exception-internals.h>
  28 #include <mono/metadata/runtime.h>
  29 #include <string.h>
  30
  31 #if NO_UNALIGNED_ACCESS
  32 #define WRITE_UNALIGNED(type, addr, val) \
  33         memcpy(addr, &val, sizeof(type))
  34 #define READ_UNALIGNED(type, addr, val) \
  35         memcpy(&val, addr, sizeof(type))
  36 #else
  37 #define WRITE_UNALIGNED(type, addr, val) \
  38         (*(type *)(addr) = (val))
  39 #define READ_UNALIGNED(type, addr, val) \
  40         val = (*(type *)(addr))
  41 #endif
  42
  43 /* This contains per-domain info */
  44 struct _MonoDebugDataTable {
  45         MonoMemPool *mp;
  46         GHashTable *method_address_hash;
  47 };
  48
  49 /* This contains JIT debugging information about a method in serialized format */
  50 struct _MonoDebugMethodAddress {
  51         const guint8 *code_start;
  52         guint32 code_size;
  53         guint8 data [MONO_ZERO_LEN_ARRAY];
  54 };
  55
  56 static MonoDebugFormat mono_debug_format = MONO_DEBUG_FORMAT_NONE;
  57
  58 static gboolean mono_debug_initialized = FALSE;
  59 /* Maps MonoImage -> MonoMonoDebugHandle */
  60 static GHashTable *mono_debug_handles;
  61 /* Maps MonoDomain -> MonoDataTable */
  62 static GHashTable *data_table_hash;
  63
  64 static mono_mutex_t debugger_lock_mutex;
  65
  66 static gboolean is_attached = FALSE;
  67
  68 static MonoDebugHandle     *mono_debug_open_image      (MonoImage *image, const guint8 *raw_contents, int size);
  69
  70 static MonoDebugHandle     *mono_debug_get_image      (MonoImage *image);
  71 static void                 mono_debug_add_assembly    (MonoAssembly *assembly,
  72                                                         gpointer user_data);
  73
  74 static MonoDebugHandle     *open_symfile_from_bundle   (MonoImage *image);
  75
  76 static MonoDebugDataTable *
  77 create_data_table (MonoDomain *domain)
  78 {
  79         MonoDebugDataTable *table;
  80
  81         table = g_new0 (MonoDebugDataTable, 1);
  82
  83         table->mp = mono_mempool_new ();
  84         table->method_address_hash = g_hash_table_new (NULL, NULL);
  85
  86         if (domain)
  87                 g_hash_table_insert (data_table_hash, domain, table);
  88
  89         return table;
  90 }
  91
  92 static void
  93 free_data_table (MonoDebugDataTable *table)
  94 {
  95         mono_mempool_destroy (table->mp);
  96         g_hash_table_destroy (table->method_address_hash);
  97
  98         g_free (table);
  99 }
 100
 101 static MonoDebugDataTable *
 102 lookup_data_table (MonoDomain *domain)
 103 {
 104         MonoDebugDataTable *table;
 105
 106         table = (MonoDebugDataTable *)g_hash_table_lookup (data_table_hash, domain);
 107         if (!table) {
 108                 g_error ("lookup_data_table () failed for %p\n", domain);
 109                 g_assert (table);
 110         }
 111         return table;
 112 }
 113
 114 static void
 115 free_debug_handle (MonoDebugHandle *handle)
 116 {
 117         if (handle->ppdb)
 118                 mono_ppdb_close (handle);
 119         if (handle->symfile)
 120                 mono_debug_close_mono_symbol_file (handle->symfile);
 121         /* decrease the refcount added with mono_image_addref () */
 122         mono_image_close (handle->image);
 123         g_free (handle);
 124 }
 125
 126 /*
 127  * Initialize debugging support.
 128  *
 129  * This method must be called after loading corlib,
 130  * but before opening the application's main assembly because we need to set some
 131  * callbacks here.
 132  */
 133 void
 134 mono_debug_init (MonoDebugFormat format)
 135 {
 136         g_assert (!mono_debug_initialized);
 137         if (format == MONO_DEBUG_FORMAT_DEBUGGER)
 138                 g_error ("The mdb debugger is no longer supported.");
 139
 140         mono_debug_initialized = TRUE;
 141         mono_debug_format = format;
 142
 143         mono_os_mutex_init_recursive (&debugger_lock_mutex);
 144
 145         mono_debugger_lock ();
 146
 147         mono_debug_handles = g_hash_table_new_full
 148                 (NULL, NULL, NULL, (GDestroyNotify) free_debug_handle);
 149
 150         data_table_hash = g_hash_table_new_full (
 151                 NULL, NULL, NULL, (GDestroyNotify) free_data_table);
 152
 153         mono_install_assembly_load_hook (mono_debug_add_assembly, NULL);
 154
 155         mono_debugger_unlock ();
 156 }
 157
 158 void
 159 mono_debug_open_image_from_memory (MonoImage *image, const guint8 *raw_contents, int size)
 160 {
 161         MONO_ENTER_GC_UNSAFE;
 162         if (!mono_debug_initialized)
 163                 goto leave;
 164
 165         mono_debug_open_image (image, raw_contents, size);
 166 leave:
 167         MONO_EXIT_GC_UNSAFE;
 168 }
 169
 170 void
 171 mono_debug_cleanup (void)
 172 {
 173         if (mono_debug_handles)
 174                 g_hash_table_destroy (mono_debug_handles);
 175         mono_debug_handles = NULL;
 176
 177         if (data_table_hash) {
 178                 g_hash_table_destroy (data_table_hash);
 179                 data_table_hash = NULL;
 180         }
 181 }
 182
 183 /**
 184  * mono_debug_domain_create:
 185  */
 186 void
 187 mono_debug_domain_create (MonoDomain *domain)
 188 {
 189         if (!mono_debug_initialized)
 190                 return;
 191
 192         mono_debugger_lock ();
 193
 194         create_data_table (domain);
 195
 196         mono_debugger_unlock ();
 197 }
 198
 199 void
 200 mono_debug_domain_unload (MonoDomain *domain)
 201 {
 202         MonoDebugDataTable *table;
 203
 204         if (!mono_debug_initialized)
 205                 return;
 206
 207         mono_debugger_lock ();
 208
 209         table = (MonoDebugDataTable *)g_hash_table_lookup (data_table_hash, domain);
 210         if (!table) {
 211                 g_warning (G_STRLOC ": unloading unknown domain %p / %d",
 212                            domain, mono_domain_get_id (domain));
 213                 mono_debugger_unlock ();
 214                 return;
 215         }
 216
 217         g_hash_table_remove (data_table_hash, domain);
 218
 219         mono_debugger_unlock ();
 220 }
 221
 222 /*
 223  * LOCKING: Assumes the debug lock is held.
 224  */
 225 static MonoDebugHandle *
 226 mono_debug_get_image (MonoImage *image)
 227 {
 228         return (MonoDebugHandle *)g_hash_table_lookup (mono_debug_handles, image);
 229 }
 230
 231 /**
 232  * mono_debug_close_image:
 233  */
 234 void
 235 mono_debug_close_image (MonoImage *image)
 236 {
 237         MonoDebugHandle *handle;
 238
 239         if (!mono_debug_initialized)
 240                 return;
 241
 242         mono_debugger_lock ();
 243
 244         handle = mono_debug_get_image (image);
 245         if (!handle) {
 246                 mono_debugger_unlock ();
 247                 return;
 248         }
 249
 250         g_hash_table_remove (mono_debug_handles, image);
 251
 252         mono_debugger_unlock ();
 253 }
 254
 255 MonoDebugHandle *
 256 mono_debug_get_handle (MonoImage *image)
 257 {
 258     return mono_debug_open_image (image, NULL, 0);
 259 }
 260
 261 static MonoDebugHandle *
 262 mono_debug_open_image (MonoImage *image, const guint8 *raw_contents, int size)
 263 {
 264         MonoDebugHandle *handle;
 265
 266         if (mono_image_is_dynamic (image))
 267                 return NULL;
 268
 269         mono_debugger_lock ();
 270
 271         handle = mono_debug_get_image (image);
 272         if (handle != NULL) {
 273                 mono_debugger_unlock ();
 274                 return handle;
 275         }
 276
 277         handle = g_new0 (MonoDebugHandle, 1);
 278
 279         handle->image = image;
 280         mono_image_addref (image);
 281
 282         /* Try a ppdb file first */
 283         handle->ppdb = mono_ppdb_load_file (handle->image, raw_contents, size);
 284
 285         if (!handle->ppdb)
 286                 handle->symfile = mono_debug_open_mono_symbols (handle, raw_contents, size, FALSE);
 287
 288         g_hash_table_insert (mono_debug_handles, image, handle);
 289
 290         mono_debugger_unlock ();
 291
 292         return handle;
 293 }
 294
 295 static void
 296 mono_debug_add_assembly (MonoAssembly *assembly, gpointer user_data)
 297 {
 298         MonoDebugHandle *handle;
 299         MonoImage *image;
 300
 301         mono_debugger_lock ();
 302         image = mono_assembly_get_image_internal (assembly);
 303         handle = open_symfile_from_bundle (image);
 304         if (!handle)
 305                 mono_debug_open_image (image, NULL, 0);
 306         mono_debugger_unlock ();
 307 }
 308
 309 struct LookupMethodData
 310 {
 311         MonoDebugMethodInfo *minfo;
 312         MonoMethod *method;
 313 };
 314
 315 static void
 316 lookup_method_func (gpointer key, gpointer value, gpointer user_data)
 317 {
 318         MonoDebugHandle *handle = (MonoDebugHandle *) value;
 319         struct LookupMethodData *data = (struct LookupMethodData *) user_data;
 320
 321         if (data->minfo)
 322                 return;
 323
 324         if (handle->ppdb)
 325                 data->minfo = mono_ppdb_lookup_method (handle, data->method);
 326         else if (handle->symfile)
 327                 data->minfo = mono_debug_symfile_lookup_method (handle, data->method);
 328 }
 329
 330 static MonoDebugMethodInfo *
 331 mono_debug_lookup_method_internal (MonoMethod *method)
 332 {
 333         struct LookupMethodData data;
 334
 335         data.minfo = NULL;
 336         data.method = method;
 337
 338         if (!mono_debug_handles)
 339                 return NULL;
 340
 341         g_hash_table_foreach (mono_debug_handles, lookup_method_func, &data);
 342         return data.minfo;
 343 }
 344
 345 /**
 346  * mono_debug_lookup_method:
 347  *
 348  * Lookup symbol file information for the method \p method.  The returned
 349  * \c MonoDebugMethodInfo is a private structure, but it can be passed to
 350  * \c mono_debug_symfile_lookup_location.
 351  */
 352 MonoDebugMethodInfo *
 353 mono_debug_lookup_method (MonoMethod *method)
 354 {
 355         MonoDebugMethodInfo *minfo;
 356
 357         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 358                 return NULL;
 359
 360         mono_debugger_lock ();
 361         minfo = mono_debug_lookup_method_internal (method);
 362         mono_debugger_unlock ();
 363         return minfo;
 364 }
 365
 366 typedef struct
 367 {
 368         gboolean found;
 369         MonoImage *image;
 370 } LookupImageData;
 371
 372 static void
 373 lookup_image_func (gpointer key, gpointer value, gpointer user_data)
 374 {
 375         MonoDebugHandle *handle = (MonoDebugHandle *) value;
 376         LookupImageData *data = (LookupImageData *) user_data;
 377
 378         if (data->found)
 379                 return;
 380
 381         if (handle->image == data->image && handle->symfile)
 382                 data->found = TRUE;
 383 }
 384
 385 gboolean
 386 mono_debug_image_has_debug_info (MonoImage *image)
 387 {
 388         LookupImageData data;
 389
 390         if (!mono_debug_handles)
 391                 return FALSE;
 392
 393         memset (&data, 0, sizeof (data));
 394         data.image = image;
 395
 396         mono_debugger_lock ();
 397         g_hash_table_foreach (mono_debug_handles, lookup_image_func, &data);
 398         mono_debugger_unlock ();
 399         return data.found;
 400 }
 401
 402 static inline void
 403 write_leb128 (guint32 value, guint8 *ptr, guint8 **rptr)
 404 {
 405         do {
 406                 guint8 byte = value & 0x7f;
 407                 value >>= 7;
 408                 if (value)
 409                         byte |= 0x80;
 410                 *ptr++ = byte;
 411         } while (value);
 412
 413         *rptr = ptr;
 414 }
 415
 416 static inline void
 417 write_sleb128 (gint32 value, guint8 *ptr, guint8 **rptr)
 418 {
 419         gboolean more = 1;
 420
 421         while (more) {
 422                 guint8 byte = value & 0x7f;
 423                 value >>= 7;
 424
 425                 if (((value == 0) && ((byte & 0x40) == 0)) || ((value == -1) && (byte & 0x40)))
 426                         more = 0;
 427                 else
 428                         byte |= 0x80;
 429                 *ptr++ = byte;
 430         }
 431
 432         *rptr = ptr;
 433 }
 434
 435 static void
 436 write_variable (MonoDebugVarInfo *var, guint8 *ptr, guint8 **rptr)
 437 {
 438         write_leb128 (var->index, ptr, &ptr);
 439         write_sleb128 (var->offset, ptr, &ptr);
 440         write_leb128 (var->size, ptr, &ptr);
 441         write_leb128 (var->begin_scope, ptr, &ptr);
 442         write_leb128 (var->end_scope, ptr, &ptr);
 443         WRITE_UNALIGNED (gpointer, ptr, var->type);
 444         ptr += sizeof (gpointer);
 445         *rptr = ptr;
 446 }
 447
 448 /**
 449  * mono_debug_add_method:
 450  */
 451 MonoDebugMethodAddress *
 452 mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain)
 453 {
 454         MonoDebugDataTable *table;
 455         MonoDebugMethodAddress *address;
 456         guint8 buffer [BUFSIZ];
 457         guint8 *ptr, *oldptr;
 458         guint32 i, size, total_size, max_size;
 459
 460         mono_debugger_lock ();
 461
 462         table = lookup_data_table (domain);
 463
 464         max_size = (5 * 5) + 1 + (10 * jit->num_line_numbers) +
 465                 (25 + sizeof (gpointer)) * (1 + jit->num_params + jit->num_locals);
 466
 467         if (max_size > BUFSIZ)
 468                 ptr = oldptr = (guint8 *)g_malloc (max_size);
 469         else
 470                 ptr = oldptr = buffer;
 471
 472         write_leb128 (jit->prologue_end, ptr, &ptr);
 473         write_leb128 (jit->epilogue_begin, ptr, &ptr);
 474
 475         write_leb128 (jit->num_line_numbers, ptr, &ptr);
 476         for (i = 0; i < jit->num_line_numbers; i++) {
 477                 MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
 478
 479                 write_sleb128 (lne->il_offset, ptr, &ptr);
 480                 write_sleb128 (lne->native_offset, ptr, &ptr);
 481         }
 482         write_leb128 (jit->has_var_info, ptr, &ptr);
 483         if (jit->has_var_info) {
 484                 *ptr++ = jit->this_var ? 1 : 0;
 485                 if (jit->this_var)
 486                         write_variable (jit->this_var, ptr, &ptr);
 487
 488                 write_leb128 (jit->num_params, ptr, &ptr);
 489                 for (i = 0; i < jit->num_params; i++)
 490                         write_variable (&jit->params [i], ptr, &ptr);
 491
 492                 write_leb128 (jit->num_locals, ptr, &ptr);
 493                 for (i = 0; i < jit->num_locals; i++)
 494                         write_variable (&jit->locals [i], ptr, &ptr);
 495
 496                 *ptr++ = jit->gsharedvt_info_var ? 1 : 0;
 497                 if (jit->gsharedvt_info_var) {
 498                         write_variable (jit->gsharedvt_info_var, ptr, &ptr);
 499                         write_variable (jit->gsharedvt_locals_var, ptr, &ptr);
 500                 }
 501         }
 502
 503         size = ptr - oldptr;
 504         g_assert (size < max_size);
 505         total_size = size + sizeof (MonoDebugMethodAddress);
 506
 507         if (method_is_dynamic (method)) {
 508                 address = (MonoDebugMethodAddress *)g_malloc0 (total_size);
 509         } else {
 510                 address = (MonoDebugMethodAddress *)mono_mempool_alloc (table->mp, total_size);
 511         }
 512
 513         address->code_start = jit->code_start;
 514         address->code_size = jit->code_size;
 515
 516         memcpy (&address->data, oldptr, size);
 517         if (max_size > BUFSIZ)
 518                 g_free (oldptr);
 519
 520         g_hash_table_insert (table->method_address_hash, method, address);
 521
 522         mono_debugger_unlock ();
 523         return address;
 524 }
 525
 526 void
 527 mono_debug_remove_method (MonoMethod *method, MonoDomain *domain)
 528 {
 529         MonoDebugDataTable *table;
 530         MonoDebugMethodAddress *address;
 531
 532         if (!mono_debug_initialized)
 533                 return;
 534
 535         g_assert (method_is_dynamic (method));
 536
 537         mono_debugger_lock ();
 538
 539         table = lookup_data_table (domain);
 540
 541         address = (MonoDebugMethodAddress *)g_hash_table_lookup (table->method_address_hash, method);
 542         if (address)
 543                 g_free (address);
 544
 545         g_hash_table_remove (table->method_address_hash, method);
 546
 547         mono_debugger_unlock ();
 548 }
 549
 550 /**
 551  * mono_debug_add_delegate_trampoline:
 552  */
 553 void
 554 mono_debug_add_delegate_trampoline (gpointer code, int size)
 555 {
 556 }
 557
 558 static inline guint32
 559 read_leb128 (guint8 *ptr, guint8 **rptr)
 560 {
 561         guint32 result = 0, shift = 0;
 562
 563         while (TRUE) {
 564                 guint8 byte = *ptr++;
 565
 566                 result |= (byte & 0x7f) << shift;
 567                 if ((byte & 0x80) == 0)
 568                         break;
 569                 shift += 7;
 570         }
 571
 572         *rptr = ptr;
 573         return result;
 574 }
 575
 576 static inline gint32
 577 read_sleb128 (guint8 *ptr, guint8 **rptr)
 578 {
 579         gint32 result = 0;
 580         guint32 shift = 0;
 581
 582         while (TRUE) {
 583                 guint8 byte = *ptr++;
 584
 585                 result |= (byte & 0x7f) << shift;
 586                 shift += 7;
 587
 588                 if (byte & 0x80)
 589                         continue;
 590
 591                 if ((shift < 32) && (byte & 0x40))
 592                         result |= - (1 << shift);
 593                 break;
 594         }
 595
 596         *rptr = ptr;
 597         return result;
 598 }
 599
 600 static void
 601 read_variable (MonoDebugVarInfo *var, guint8 *ptr, guint8 **rptr)
 602 {
 603         var->index = read_leb128 (ptr, &ptr);
 604         var->offset = read_sleb128 (ptr, &ptr);
 605         var->size = read_leb128 (ptr, &ptr);
 606         var->begin_scope = read_leb128 (ptr, &ptr);
 607         var->end_scope = read_leb128 (ptr, &ptr);
 608         READ_UNALIGNED (MonoType *, ptr, var->type);
 609         ptr += sizeof (gpointer);
 610         *rptr = ptr;
 611 }
 612
 613 static void
 614 mono_debug_free_method_jit_info_full (MonoDebugMethodJitInfo *jit, gboolean stack)
 615 {
 616         if (!jit)
 617                 return;
 618         g_free (jit->line_numbers);
 619         g_free (jit->this_var);
 620         g_free (jit->params);
 621         g_free (jit->locals);
 622         g_free (jit->gsharedvt_info_var);
 623         g_free (jit->gsharedvt_locals_var);
 624         if (!stack)
 625                 g_free (jit);
 626 }
 627
 628 void
 629 mono_debug_free_method_jit_info (MonoDebugMethodJitInfo *jit)
 630 {
 631         return mono_debug_free_method_jit_info_full (jit, FALSE);
 632 }
 633
 634 static MonoDebugMethodJitInfo *
 635 mono_debug_read_method (MonoDebugMethodAddress *address, MonoDebugMethodJitInfo *jit)
 636 {
 637         guint32 i;
 638         guint8 *ptr;
 639
 640         memset (jit, 0, sizeof (*jit));
 641         jit->code_start = address->code_start;
 642         jit->code_size = address->code_size;
 643
 644         ptr = (guint8 *) &address->data;
 645
 646         jit->prologue_end = read_leb128 (ptr, &ptr);
 647         jit->epilogue_begin = read_leb128 (ptr, &ptr);
 648
 649         jit->num_line_numbers = read_leb128 (ptr, &ptr);
 650         jit->line_numbers = g_new0 (MonoDebugLineNumberEntry, jit->num_line_numbers);
 651         for (i = 0; i < jit->num_line_numbers; i++) {
 652                 MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
 653
 654                 lne->il_offset = read_sleb128 (ptr, &ptr);
 655                 lne->native_offset = read_sleb128 (ptr, &ptr);
 656         }
 657         jit->has_var_info = read_leb128 (ptr, &ptr);
 658         if (jit->has_var_info) {
 659                 if (*ptr++) {
 660                         jit->this_var = g_new0 (MonoDebugVarInfo, 1);
 661                         read_variable (jit->this_var, ptr, &ptr);
 662                 }
 663
 664                 jit->num_params = read_leb128 (ptr, &ptr);
 665                 jit->params = g_new0 (MonoDebugVarInfo, jit->num_params);
 666                 for (i = 0; i < jit->num_params; i++)
 667                         read_variable (&jit->params [i], ptr, &ptr);
 668
 669                 jit->num_locals = read_leb128 (ptr, &ptr);
 670                 jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals);
 671                 for (i = 0; i < jit->num_locals; i++)
 672                         read_variable (&jit->locals [i], ptr, &ptr);
 673
 674                 if (*ptr++) {
 675                         jit->gsharedvt_info_var = g_new0 (MonoDebugVarInfo, 1);
 676                         jit->gsharedvt_locals_var = g_new0 (MonoDebugVarInfo, 1);
 677                         read_variable (jit->gsharedvt_info_var, ptr, &ptr);
 678                         read_variable (jit->gsharedvt_locals_var, ptr, &ptr);
 679                 }
 680         }
 681
 682         return jit;
 683 }
 684
 685 static MonoDebugMethodJitInfo *
 686 find_method (MonoMethod *method, MonoDomain *domain, MonoDebugMethodJitInfo *jit)
 687 {
 688         MonoDebugDataTable *table;
 689         MonoDebugMethodAddress *address;
 690
 691         table = lookup_data_table (domain);
 692         address = (MonoDebugMethodAddress *)g_hash_table_lookup (table->method_address_hash, method);
 693
 694         if (!address)
 695                 return NULL;
 696
 697         return mono_debug_read_method (address, jit);
 698 }
 699
 700 MonoDebugMethodJitInfo *
 701 mono_debug_find_method (MonoMethod *method, MonoDomain *domain)
 702 {
 703         MonoDebugMethodJitInfo *res = g_new0 (MonoDebugMethodJitInfo, 1);
 704
 705         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 706                 return NULL;
 707
 708         mono_debugger_lock ();
 709         find_method (method, domain, res);
 710         mono_debugger_unlock ();
 711         return res;
 712 }
 713
 714 MonoDebugMethodAddressList *
 715 mono_debug_lookup_method_addresses (MonoMethod *method)
 716 {
 717         g_assert_not_reached ();
 718         return NULL;
 719 }
 720
 721 static gint32
 722 il_offset_from_address (MonoMethod *method, MonoDomain *domain, guint32 native_offset)
 723 {
 724         MonoDebugMethodJitInfo mem;
 725         int i;
 726
 727         MonoDebugMethodJitInfo *jit = find_method (method, domain, &mem);
 728         if (!jit || !jit->line_numbers)
 729                 goto cleanup_and_fail;
 730
 731         for (i = jit->num_line_numbers - 1; i >= 0; i--) {
 732                 MonoDebugLineNumberEntry lne = jit->line_numbers [i];
 733
 734                 if (lne.native_offset <= native_offset) {
 735                         mono_debug_free_method_jit_info_full (jit, TRUE);
 736                         return lne.il_offset;
 737                 }
 738         }
 739
 740 cleanup_and_fail:
 741         mono_debug_free_method_jit_info_full (jit, TRUE);
 742         return -1;
 743 }
 744
 745 /**
 746  * mono_debug_il_offset_from_address:
 747  *
 748  * Compute the IL offset corresponding to \p native_offset inside the native
 749  * code of \p method in \p domain.
 750  */
 751 gint32
 752 mono_debug_il_offset_from_address (MonoMethod *method, MonoDomain *domain, guint32 native_offset)
 753 {
 754         gint32 res;
 755
 756         mono_debugger_lock ();
 757
 758         res = il_offset_from_address (method, domain, native_offset);
 759
 760         mono_debugger_unlock ();
 761
 762         return res;
 763 }
 764
 765 /**
 766  * mono_debug_lookup_source_location:
 767  * \param address Native offset within the \p method's machine code.
 768  * Lookup the source code corresponding to the machine instruction located at
 769  * native offset \p address within \p method.
 770  * The returned \c MonoDebugSourceLocation contains both file / line number
 771  * information and the corresponding IL offset.  It must be freed by
 772  * \c mono_debug_free_source_location.
 773  */
 774 MonoDebugSourceLocation *
 775 mono_debug_lookup_source_location (MonoMethod *method, guint32 address, MonoDomain *domain)
 776 {
 777         MonoDebugMethodInfo *minfo;
 778         MonoDebugSourceLocation *location;
 779         gint32 offset;
 780
 781         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 782                 return NULL;
 783
 784         mono_debugger_lock ();
 785         minfo = mono_debug_lookup_method_internal (method);
 786         if (!minfo || !minfo->handle) {
 787                 mono_debugger_unlock ();
 788                 return NULL;
 789         }
 790
 791         if (!minfo->handle->ppdb && (!minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile))) {
 792                 mono_debugger_unlock ();
 793                 return NULL;
 794         }
 795
 796         offset = il_offset_from_address (method, domain, address);
 797         if (offset < 0) {
 798                 mono_debugger_unlock ();
 799                 return NULL;
 800         }
 801
 802         if (minfo->handle->ppdb)
 803                 location = mono_ppdb_lookup_location (minfo, offset);
 804         else
 805                 location = mono_debug_symfile_lookup_location (minfo, offset);
 806         mono_debugger_unlock ();
 807         return location;
 808 }
 809
 810 /**
 811  * mono_debug_lookup_source_location_by_il:
 812  *
 813  *   Same as mono_debug_lookup_source_location but take an IL_OFFSET argument.
 814  */
 815 MonoDebugSourceLocation *
 816 mono_debug_lookup_source_location_by_il (MonoMethod *method, guint32 il_offset, MonoDomain *domain)
 817 {
 818         MonoDebugMethodInfo *minfo;
 819         MonoDebugSourceLocation *location;
 820
 821         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 822                 return NULL;
 823
 824         mono_debugger_lock ();
 825         minfo = mono_debug_lookup_method_internal (method);
 826         if (!minfo || !minfo->handle) {
 827                 mono_debugger_unlock ();
 828                 return NULL;
 829         }
 830
 831         if (!minfo->handle->ppdb && (!minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile))) {
 832                 mono_debugger_unlock ();
 833                 return NULL;
 834         }
 835
 836         if (minfo->handle->ppdb)
 837                 location = mono_ppdb_lookup_location (minfo, il_offset);
 838         else
 839                 location = mono_debug_symfile_lookup_location (minfo, il_offset);
 840         mono_debugger_unlock ();
 841         return location;
 842 }
 843
 844 MonoDebugSourceLocation *
 845 mono_debug_method_lookup_location (MonoDebugMethodInfo *minfo, int il_offset)
 846 {
 847         MonoDebugSourceLocation *location;
 848
 849         mono_debugger_lock ();
 850         if (minfo->handle->ppdb)
 851                 location = mono_ppdb_lookup_location (minfo, il_offset);
 852         else
 853                 location = mono_debug_symfile_lookup_location (minfo, il_offset);
 854         mono_debugger_unlock ();
 855         return location;
 856 }
 857
 858 /*
 859  * mono_debug_lookup_locals:
 860  *
 861  *   Return information about the local variables of MINFO.
 862  * The result should be freed using mono_debug_free_locals ().
 863  */
 864 MonoDebugLocalsInfo*
 865 mono_debug_lookup_locals (MonoMethod *method)
 866 {
 867         MonoDebugMethodInfo *minfo;
 868         MonoDebugLocalsInfo *res;
 869
 870         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 871                 return NULL;
 872
 873         mono_debugger_lock ();
 874         minfo = mono_debug_lookup_method_internal (method);
 875         if (!minfo || !minfo->handle) {
 876                 mono_debugger_unlock ();
 877                 return NULL;
 878         }
 879
 880         if (minfo->handle->ppdb) {
 881                 res = mono_ppdb_lookup_locals (minfo);
 882         } else {
 883                 if (!minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile))
 884                         res = NULL;
 885                 else
 886                         res = mono_debug_symfile_lookup_locals (minfo);
 887         }
 888         mono_debugger_unlock ();
 889
 890         return res;
 891 }
 892
 893 /*
 894  * mono_debug_free_locals:
 895  *
 896  *   Free all the data allocated by mono_debug_lookup_locals ().
 897  */
 898 void
 899 mono_debug_free_locals (MonoDebugLocalsInfo *info)
 900 {
 901         int i;
 902
 903         for (i = 0; i < info->num_locals; ++i)
 904                 g_free (info->locals [i].name);
 905         g_free (info->locals);
 906         g_free (info->code_blocks);
 907         g_free (info);
 908 }
 909
 910 /*
 911 * mono_debug_lookup_method_async_debug_info:
 912 *
 913 *   Return information about the async stepping information of method.
 914 * The result should be freed using mono_debug_free_async_debug_info ().
 915 */
 916 MonoDebugMethodAsyncInfo*
 917 mono_debug_lookup_method_async_debug_info (MonoMethod *method)
 918 {
 919         MonoDebugMethodInfo *minfo;
 920         MonoDebugMethodAsyncInfo *res = NULL;
 921
 922         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 923                 return NULL;
 924
 925         mono_debugger_lock ();
 926         minfo = mono_debug_lookup_method_internal (method);
 927         if (!minfo || !minfo->handle) {
 928                 mono_debugger_unlock ();
 929                 return NULL;
 930         }
 931
 932         if (minfo->handle->ppdb)
 933                 res = mono_ppdb_lookup_method_async_debug_info (minfo);
 934
 935         mono_debugger_unlock ();
 936
 937         return res;
 938 }
 939
 940 /*
 941  * mono_debug_free_method_async_debug_info:
 942  *
 943  *   Free all the data allocated by mono_debug_lookup_method_async_debug_info ().
 944  */
 945 void
 946 mono_debug_free_method_async_debug_info (MonoDebugMethodAsyncInfo *info)
 947 {
 948         if (info->num_awaits) {
 949                 g_free (info->yield_offsets);
 950                 g_free (info->resume_offsets);
 951                 g_free (info->move_next_method_token);
 952         }
 953         g_free (info);
 954 }
 955
 956 /**
 957  * mono_debug_free_source_location:
 958  * \param location A \c MonoDebugSourceLocation
 959  * Frees the \p location.
 960  */
 961 void
 962 mono_debug_free_source_location (MonoDebugSourceLocation *location)
 963 {
 964         if (location) {
 965                 g_free (location->source_file);
 966                 g_free (location);
 967         }
 968 }
 969
 970 static int (*get_seq_point) (MonoDomain *domain, MonoMethod *method, gint32 native_offset);
 971
 972 void
 973 mono_install_get_seq_point (MonoGetSeqPointFunc func)
 974 {
 975         get_seq_point = func;
 976 }
 977
 978 /**
 979  * mono_debug_print_stack_frame:
 980  * \param native_offset Native offset within the \p method's machine code.
 981  * Conventient wrapper around \c mono_debug_lookup_source_location which can be
 982  * used if you only want to use the location to print a stack frame.
 983  */
 984 gchar *
 985 mono_debug_print_stack_frame (MonoMethod *method, guint32 native_offset, MonoDomain *domain)
 986 {
 987         MonoDebugSourceLocation *location;
 988         gchar *fname, *ptr, *res;
 989         int offset;
 990
 991         fname = mono_method_full_name (method, TRUE);
 992         for (ptr = fname; *ptr; ptr++) {
 993                 if (*ptr == ':') *ptr = '.';
 994         }
 995
 996         location = mono_debug_lookup_source_location (method, native_offset, domain);
 997
 998         if (!location) {
 999                 if (mono_debug_initialized) {
1000                         mono_debugger_lock ();
1001                         offset = il_offset_from_address (method, domain, native_offset);
1002                         mono_debugger_unlock ();
1003                 } else {
1004                         offset = -1;
1005                 }
1006
1007                 if (offset < 0 && get_seq_point)
1008                         offset = get_seq_point (domain, method, native_offset);
1009
1010                 if (offset < 0)
1011                         res = g_strdup_printf ("at %s <0x%05x>", fname, native_offset);
1012                 else {
1013                         char *mvid = mono_guid_to_string_minimal ((uint8_t*)m_class_get_image (method->klass)->heap_guid.data);
1014                         char *aotid = mono_runtime_get_aotid ();
1015                         if (aotid)
1016                                 res = g_strdup_printf ("at %s [0x%05x] in <%s#%s>:0" , fname, offset, mvid, aotid);
1017                         else
1018                                 res = g_strdup_printf ("at %s [0x%05x] in <%s>:0" , fname, offset, mvid);
1019
1020                         g_free (aotid);
1021                         g_free (mvid);
1022                 }
1023                 g_free (fname);
1024                 return res;
1025         }
1026
1027         res = g_strdup_printf ("at %s [0x%05x] in %s:%d", fname, location->il_offset,
1028                                location->source_file, location->row);
1029
1030         g_free (fname);
1031         mono_debug_free_source_location (location);
1032         return res;
1033 }
1034
1035 void
1036 mono_set_is_debugger_attached (gboolean attached)
1037 {
1038         is_attached = attached;
1039 }
1040
1041 gboolean
1042 mono_is_debugger_attached (void)
1043 {
1044         return is_attached;
1045 }
1046
1047 /*
1048  * Bundles
1049  */
1050
1051 typedef struct _BundledSymfile BundledSymfile;
1052
1053 struct _BundledSymfile {
1054         BundledSymfile *next;
1055         const char *aname;
1056         const mono_byte *raw_contents;
1057         int size;
1058 };
1059
1060 static BundledSymfile *bundled_symfiles = NULL;
1061
1062 /**
1063  * mono_register_symfile_for_assembly:
1064  */
1065 void
1066 mono_register_symfile_for_assembly (const char *assembly_name, const mono_byte *raw_contents, int size)
1067 {
1068         BundledSymfile *bsymfile;
1069
1070         bsymfile = g_new0 (BundledSymfile, 1);
1071         bsymfile->aname = assembly_name;
1072         bsymfile->raw_contents = raw_contents;
1073         bsymfile->size = size;
1074         bsymfile->next = bundled_symfiles;
1075         bundled_symfiles = bsymfile;
1076 }
1077
1078 static MonoDebugHandle *
1079 open_symfile_from_bundle (MonoImage *image)
1080 {
1081         BundledSymfile *bsymfile;
1082
1083         for (bsymfile = bundled_symfiles; bsymfile; bsymfile = bsymfile->next) {
1084                 if (strcmp (bsymfile->aname, image->module_name))
1085                         continue;
1086
1087                 return mono_debug_open_image (image, bsymfile->raw_contents, bsymfile->size);
1088         }
1089
1090         return NULL;
1091 }
1092
1093 void
1094 mono_debugger_lock (void)
1095 {
1096         g_assert (mono_debug_initialized);
1097         mono_os_mutex_lock (&debugger_lock_mutex);
1098 }
1099
1100 void
1101 mono_debugger_unlock (void)
1102 {
1103         g_assert (mono_debug_initialized);
1104         mono_os_mutex_unlock (&debugger_lock_mutex);
1105 }
1106
1107 /**
1108  * mono_debug_enabled:
1109  *
1110  * Returns true is debug information is enabled. This doesn't relate if a debugger is present or not.
1111  */
1112 mono_bool
1113 mono_debug_enabled (void)
1114 {
1115         return mono_debug_format != MONO_DEBUG_FORMAT_NONE;
1116 }
1117
1118 void
1119 mono_debug_get_seq_points (MonoDebugMethodInfo *minfo, char **source_file, GPtrArray **source_file_list, int **source_files, MonoSymSeqPoint **seq_points, int *n_seq_points)
1120 {
1121         if (minfo->handle->ppdb)
1122                 mono_ppdb_get_seq_points (minfo, source_file, source_file_list, source_files, seq_points, n_seq_points);
1123         else
1124                 mono_debug_symfile_get_seq_points (minfo, source_file, source_file_list, source_files, seq_points, n_seq_points);
1125 }