mono/metadata/mono-debug.c

   1 /*
   2  * mono-debug.c:
   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  */
  11
  12 #include <config.h>
  13 #include <mono/metadata/assembly.h>
  14 #include <mono/metadata/tabledefs.h>
  15 #include <mono/metadata/tokentype.h>
  16 #include <mono/metadata/appdomain.h>
  17 #include <mono/metadata/class-internals.h>
  18 #include <mono/metadata/mono-debug.h>
  19 #include <mono/metadata/mono-debug-debugger.h>
  20 #include <mono/metadata/mono-endian.h>
  21 #include <mono/metadata/gc-internal.h>
  22 #include <mono/metadata/mempool.h>
  23 #include <string.h>
  24
  25 #define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
  26
  27 #if NO_UNALIGNED_ACCESS
  28 #define WRITE_UNALIGNED(type, addr, val) \
  29         memcpy(addr, &val, sizeof(type))
  30 #define READ_UNALIGNED(type, addr, val) \
  31         memcpy(&val, addr, sizeof(type))
  32 #else
  33 #define WRITE_UNALIGNED(type, addr, val) \
  34         (*(type *)(addr) = (val))
  35 #define READ_UNALIGNED(type, addr, val) \
  36         val = (*(type *)(addr))
  37 #endif
  38
  39 /* This contains per-domain info */
  40 struct _MonoDebugDataTable {
  41         MonoMemPool *mp;
  42         GHashTable *method_address_hash;
  43 };
  44
  45 /* This contains JIT debugging information about a method in serialized format */
  46 struct _MonoDebugMethodAddress {
  47         const guint8 *code_start;
  48         guint32 code_size;
  49         guint8 data [MONO_ZERO_LEN_ARRAY];
  50 };
  51
  52 static MonoDebugFormat mono_debug_format = MONO_DEBUG_FORMAT_NONE;
  53
  54 static gboolean mono_debug_initialized = FALSE;
  55 /* Maps MonoImage -> MonoMonoDebugHandle */
  56 static GHashTable *mono_debug_handles;
  57 /* Maps MonoDomain -> MonoDataTable */
  58 static GHashTable *data_table_hash;
  59
  60 static mono_mutex_t debugger_lock_mutex;
  61
  62 static int initialized = 0;
  63 static gboolean is_attached = FALSE;
  64
  65 static MonoDebugHandle     *mono_debug_open_image      (MonoImage *image, const guint8 *raw_contents, int size);
  66
  67 static MonoDebugHandle     *mono_debug_get_image      (MonoImage *image);
  68 static void                 mono_debug_add_assembly    (MonoAssembly *assembly,
  69                                                         gpointer user_data);
  70
  71 static MonoDebugHandle     *open_symfile_from_bundle   (MonoImage *image);
  72
  73 static MonoDebugDataTable *
  74 create_data_table (MonoDomain *domain)
  75 {
  76         MonoDebugDataTable *table;
  77
  78         table = g_new0 (MonoDebugDataTable, 1);
  79
  80         table->mp = mono_mempool_new ();
  81         table->method_address_hash = g_hash_table_new (NULL, NULL);
  82
  83         if (domain)
  84                 g_hash_table_insert (data_table_hash, domain, table);
  85
  86         return table;
  87 }
  88
  89 static void
  90 free_data_table (MonoDebugDataTable *table)
  91 {
  92         mono_mempool_destroy (table->mp);
  93         g_hash_table_destroy (table->method_address_hash);
  94
  95         g_free (table);
  96 }
  97
  98 static MonoDebugDataTable *
  99 lookup_data_table (MonoDomain *domain)
 100 {
 101         MonoDebugDataTable *table;
 102
 103         table = g_hash_table_lookup (data_table_hash, domain);
 104         if (!table) {
 105                 g_error ("lookup_data_table () failed for %p\n", domain);
 106                 g_assert (table);
 107         }
 108         return table;
 109 }
 110
 111 static void
 112 free_debug_handle (MonoDebugHandle *handle)
 113 {
 114         if (handle->symfile)
 115                 mono_debug_close_mono_symbol_file (handle->symfile);
 116         /* decrease the refcount added with mono_image_addref () */
 117         mono_image_close (handle->image);
 118         g_free (handle);
 119 }
 120
 121 /*
 122  * Initialize debugging support.
 123  *
 124  * This method must be called after loading corlib,
 125  * but before opening the application's main assembly because we need to set some
 126  * callbacks here.
 127  */
 128 void
 129 mono_debug_init (MonoDebugFormat format)
 130 {
 131         g_assert (!mono_debug_initialized);
 132         if (format == MONO_DEBUG_FORMAT_DEBUGGER)
 133                 g_error ("The mdb debugger is no longer supported.");
 134
 135         mono_debug_initialized = TRUE;
 136         mono_debug_format = format;
 137
 138         mono_debugger_initialize ();
 139
 140         mono_debugger_lock ();
 141
 142         mono_debug_handles = g_hash_table_new_full
 143                 (NULL, NULL, NULL, (GDestroyNotify) free_debug_handle);
 144
 145         data_table_hash = g_hash_table_new_full (
 146                 NULL, NULL, NULL, (GDestroyNotify) free_data_table);
 147
 148         mono_install_assembly_load_hook (mono_debug_add_assembly, NULL);
 149
 150         mono_debugger_unlock ();
 151 }
 152
 153 void
 154 mono_debug_open_image_from_memory (MonoImage *image, const guint8 *raw_contents, int size)
 155 {
 156         if (!mono_debug_initialized)
 157                 return;
 158
 159         mono_debug_open_image (image, raw_contents, size);
 160 }
 161
 162 void
 163 mono_debug_cleanup (void)
 164 {
 165         if (mono_debug_handles)
 166                 g_hash_table_destroy (mono_debug_handles);
 167         mono_debug_handles = NULL;
 168
 169         if (data_table_hash) {
 170                 g_hash_table_destroy (data_table_hash);
 171                 data_table_hash = NULL;
 172         }
 173 }
 174
 175 void
 176 mono_debug_domain_create (MonoDomain *domain)
 177 {
 178         MonoDebugDataTable *table;
 179
 180         if (!mono_debug_initialized)
 181                 return;
 182
 183         mono_debugger_lock ();
 184
 185         table = create_data_table (domain);
 186
 187         mono_debugger_unlock ();
 188 }
 189
 190 void
 191 mono_debug_domain_unload (MonoDomain *domain)
 192 {
 193         MonoDebugDataTable *table;
 194
 195         if (!mono_debug_initialized)
 196                 return;
 197
 198         mono_debugger_lock ();
 199
 200         table = g_hash_table_lookup (data_table_hash, domain);
 201         if (!table) {
 202                 g_warning (G_STRLOC ": unloading unknown domain %p / %d",
 203                            domain, mono_domain_get_id (domain));
 204                 mono_debugger_unlock ();
 205                 return;
 206         }
 207
 208         g_hash_table_remove (data_table_hash, domain);
 209
 210         mono_debugger_unlock ();
 211 }
 212
 213 /*
 214  * LOCKING: Assumes the debug lock is held.
 215  */
 216 static MonoDebugHandle *
 217 mono_debug_get_image (MonoImage *image)
 218 {
 219         return g_hash_table_lookup (mono_debug_handles, image);
 220 }
 221
 222 void
 223 mono_debug_close_image (MonoImage *image)
 224 {
 225         MonoDebugHandle *handle;
 226
 227         if (!mono_debug_initialized)
 228                 return;
 229
 230         mono_debugger_lock ();
 231
 232         handle = mono_debug_get_image (image);
 233         if (!handle) {
 234                 mono_debugger_unlock ();
 235                 return;
 236         }
 237
 238         g_hash_table_remove (mono_debug_handles, image);
 239
 240         mono_debugger_unlock ();
 241 }
 242
 243 static MonoDebugHandle *
 244 mono_debug_open_image (MonoImage *image, const guint8 *raw_contents, int size)
 245 {
 246         MonoDebugHandle *handle;
 247
 248         if (mono_image_is_dynamic (image))
 249                 return NULL;
 250
 251         mono_debugger_lock ();
 252
 253         handle = mono_debug_get_image (image);
 254         if (handle != NULL) {
 255                 mono_debugger_unlock ();
 256                 return handle;
 257         }
 258
 259         handle = g_new0 (MonoDebugHandle, 1);
 260
 261         handle->image = image;
 262         mono_image_addref (image);
 263
 264         handle->symfile = mono_debug_open_mono_symbols (
 265                 handle, raw_contents, size, FALSE);
 266
 267         g_hash_table_insert (mono_debug_handles, image, handle);
 268
 269         mono_debugger_unlock ();
 270
 271         return handle;
 272 }
 273
 274 static void
 275 mono_debug_add_assembly (MonoAssembly *assembly, gpointer user_data)
 276 {
 277         MonoDebugHandle *handle;
 278         MonoImage *image;
 279
 280         mono_debugger_lock ();
 281         image = mono_assembly_get_image (assembly);
 282         handle = open_symfile_from_bundle (image);
 283         if (!handle)
 284                 mono_debug_open_image (image, NULL, 0);
 285         mono_debugger_unlock ();
 286 }
 287
 288 struct LookupMethodData
 289 {
 290         MonoDebugMethodInfo *minfo;
 291         MonoMethod *method;
 292 };
 293
 294 static void
 295 lookup_method_func (gpointer key, gpointer value, gpointer user_data)
 296 {
 297         MonoDebugHandle *handle = (MonoDebugHandle *) value;
 298         struct LookupMethodData *data = (struct LookupMethodData *) user_data;
 299
 300         if (data->minfo)
 301                 return;
 302
 303         if (handle->symfile)
 304                 data->minfo = mono_debug_symfile_lookup_method (handle, data->method);
 305 }
 306
 307 static MonoDebugMethodInfo *
 308 mono_debug_lookup_method_internal (MonoMethod *method)
 309 {
 310         struct LookupMethodData data;
 311
 312         data.minfo = NULL;
 313         data.method = method;
 314
 315         if (!mono_debug_handles)
 316                 return NULL;
 317
 318         g_hash_table_foreach (mono_debug_handles, lookup_method_func, &data);
 319         return data.minfo;
 320 }
 321
 322 /**
 323  * mono_debug_lookup_method:
 324  *
 325  * Lookup symbol file information for the method @method.  The returned
 326  * `MonoDebugMethodInfo' is a private structure, but it can be passed to
 327  * mono_debug_symfile_lookup_location().
 328  */
 329 MonoDebugMethodInfo *
 330 mono_debug_lookup_method (MonoMethod *method)
 331 {
 332         MonoDebugMethodInfo *minfo;
 333
 334         mono_debugger_lock ();
 335         minfo = mono_debug_lookup_method_internal (method);
 336         mono_debugger_unlock ();
 337         return minfo;
 338 }
 339
 340 static inline void
 341 write_leb128 (guint32 value, guint8 *ptr, guint8 **rptr)
 342 {
 343         do {
 344                 guint8 byte = value & 0x7f;
 345                 value >>= 7;
 346                 if (value)
 347                         byte |= 0x80;
 348                 *ptr++ = byte;
 349         } while (value);
 350
 351         *rptr = ptr;
 352 }
 353
 354 static inline void
 355 write_sleb128 (gint32 value, guint8 *ptr, guint8 **rptr)
 356 {
 357         gboolean more = 1;
 358
 359         while (more) {
 360                 guint8 byte = value & 0x7f;
 361                 value >>= 7;
 362
 363                 if (((value == 0) && ((byte & 0x40) == 0)) || ((value == -1) && (byte & 0x40)))
 364                         more = 0;
 365                 else
 366                         byte |= 0x80;
 367                 *ptr++ = byte;
 368         }
 369
 370         *rptr = ptr;
 371 }
 372
 373 static void
 374 write_variable (MonoDebugVarInfo *var, guint8 *ptr, guint8 **rptr)
 375 {
 376         write_leb128 (var->index, ptr, &ptr);
 377         write_sleb128 (var->offset, ptr, &ptr);
 378         write_leb128 (var->size, ptr, &ptr);
 379         write_leb128 (var->begin_scope, ptr, &ptr);
 380         write_leb128 (var->end_scope, ptr, &ptr);
 381         WRITE_UNALIGNED (gpointer, ptr, var->type);
 382         ptr += sizeof (gpointer);
 383         *rptr = ptr;
 384 }
 385
 386 MonoDebugMethodAddress *
 387 mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain)
 388 {
 389         MonoDebugDataTable *table;
 390         MonoDebugMethodAddress *address;
 391         MonoDebugMethodInfo *minfo;
 392         MonoDebugHandle *handle;
 393         guint8 buffer [BUFSIZ];
 394         guint8 *ptr, *oldptr;
 395         guint32 i, size, total_size, max_size;
 396
 397         mono_debugger_lock ();
 398
 399         table = lookup_data_table (domain);
 400
 401         handle = mono_debug_get_image (method->klass->image);
 402         minfo = mono_debug_lookup_method_internal (method);
 403
 404         max_size = (5 * 5) + 1 + (10 * jit->num_line_numbers) +
 405                 (25 + sizeof (gpointer)) * (1 + jit->num_params + jit->num_locals);
 406
 407         if (max_size > BUFSIZ)
 408                 ptr = oldptr = g_malloc (max_size);
 409         else
 410                 ptr = oldptr = buffer;
 411
 412         write_leb128 (jit->prologue_end, ptr, &ptr);
 413         write_leb128 (jit->epilogue_begin, ptr, &ptr);
 414
 415         write_leb128 (jit->num_line_numbers, ptr, &ptr);
 416         for (i = 0; i < jit->num_line_numbers; i++) {
 417                 MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
 418
 419                 write_sleb128 (lne->il_offset, ptr, &ptr);
 420                 write_sleb128 (lne->native_offset, ptr, &ptr);
 421         }
 422
 423         *ptr++ = jit->this_var ? 1 : 0;
 424         if (jit->this_var)
 425                 write_variable (jit->this_var, ptr, &ptr);
 426
 427         write_leb128 (jit->num_params, ptr, &ptr);
 428         for (i = 0; i < jit->num_params; i++)
 429                 write_variable (&jit->params [i], ptr, &ptr);
 430
 431         write_leb128 (jit->num_locals, ptr, &ptr);
 432         for (i = 0; i < jit->num_locals; i++)
 433                 write_variable (&jit->locals [i], ptr, &ptr);
 434
 435         *ptr++ = jit->gsharedvt_info_var ? 1 : 0;
 436         if (jit->gsharedvt_info_var) {
 437                 write_variable (jit->gsharedvt_info_var, ptr, &ptr);
 438                 write_variable (jit->gsharedvt_locals_var, ptr, &ptr);
 439         }
 440
 441         size = ptr - oldptr;
 442         g_assert (size < max_size);
 443         total_size = size + sizeof (MonoDebugMethodAddress);
 444
 445         if (method_is_dynamic (method)) {
 446                 address = g_malloc0 (total_size);
 447         } else {
 448                 address = mono_mempool_alloc (table->mp, total_size);
 449         }
 450
 451         address->code_start = jit->code_start;
 452         address->code_size = jit->code_size;
 453
 454         memcpy (&address->data, oldptr, size);
 455         if (max_size > BUFSIZ)
 456                 g_free (oldptr);
 457
 458         g_hash_table_insert (table->method_address_hash, method, address);
 459
 460         mono_debugger_unlock ();
 461         return address;
 462 }
 463
 464 void
 465 mono_debug_remove_method (MonoMethod *method, MonoDomain *domain)
 466 {
 467         MonoDebugDataTable *table;
 468         MonoDebugMethodAddress *address;
 469
 470         if (!mono_debug_initialized)
 471                 return;
 472
 473         g_assert (method_is_dynamic (method));
 474
 475         mono_debugger_lock ();
 476
 477         table = lookup_data_table (domain);
 478
 479         address = g_hash_table_lookup (table->method_address_hash, method);
 480         if (address)
 481                 g_free (address);
 482
 483         g_hash_table_remove (table->method_address_hash, method);
 484
 485         mono_debugger_unlock ();
 486 }
 487
 488 void
 489 mono_debug_add_delegate_trampoline (gpointer code, int size)
 490 {
 491 }
 492
 493 static inline guint32
 494 read_leb128 (guint8 *ptr, guint8 **rptr)
 495 {
 496         guint32 result = 0, shift = 0;
 497
 498         while (TRUE) {
 499                 guint8 byte = *ptr++;
 500
 501                 result |= (byte & 0x7f) << shift;
 502                 if ((byte & 0x80) == 0)
 503                         break;
 504                 shift += 7;
 505         }
 506
 507         *rptr = ptr;
 508         return result;
 509 }
 510
 511 static inline gint32
 512 read_sleb128 (guint8 *ptr, guint8 **rptr)
 513 {
 514         gint32 result = 0;
 515         guint32 shift = 0;
 516
 517         while (TRUE) {
 518                 guint8 byte = *ptr++;
 519
 520                 result |= (byte & 0x7f) << shift;
 521                 shift += 7;
 522
 523                 if (byte & 0x80)
 524                         continue;
 525
 526                 if ((shift < 32) && (byte & 0x40))
 527                         result |= - (1 << shift);
 528                 break;
 529         }
 530
 531         *rptr = ptr;
 532         return result;
 533 }
 534
 535 static void
 536 read_variable (MonoDebugVarInfo *var, guint8 *ptr, guint8 **rptr)
 537 {
 538         var->index = read_leb128 (ptr, &ptr);
 539         var->offset = read_sleb128 (ptr, &ptr);
 540         var->size = read_leb128 (ptr, &ptr);
 541         var->begin_scope = read_leb128 (ptr, &ptr);
 542         var->end_scope = read_leb128 (ptr, &ptr);
 543         READ_UNALIGNED (gpointer, ptr, var->type);
 544         ptr += sizeof (gpointer);
 545         *rptr = ptr;
 546 }
 547
 548 void
 549 mono_debug_free_method_jit_info (MonoDebugMethodJitInfo *jit)
 550 {
 551         if (!jit)
 552                 return;
 553         g_free (jit->line_numbers);
 554         g_free (jit->this_var);
 555         g_free (jit->params);
 556         g_free (jit->locals);
 557         g_free (jit->gsharedvt_info_var);
 558         g_free (jit->gsharedvt_locals_var);
 559         g_free (jit);
 560 }
 561
 562 static MonoDebugMethodJitInfo *
 563 mono_debug_read_method (MonoDebugMethodAddress *address)
 564 {
 565         MonoDebugMethodJitInfo *jit;
 566         guint32 i;
 567         guint8 *ptr;
 568
 569         jit = g_new0 (MonoDebugMethodJitInfo, 1);
 570         jit->code_start = address->code_start;
 571         jit->code_size = address->code_size;
 572
 573         ptr = (guint8 *) &address->data;
 574
 575         jit->prologue_end = read_leb128 (ptr, &ptr);
 576         jit->epilogue_begin = read_leb128 (ptr, &ptr);
 577
 578         jit->num_line_numbers = read_leb128 (ptr, &ptr);
 579         jit->line_numbers = g_new0 (MonoDebugLineNumberEntry, jit->num_line_numbers);
 580         for (i = 0; i < jit->num_line_numbers; i++) {
 581                 MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
 582
 583                 lne->il_offset = read_sleb128 (ptr, &ptr);
 584                 lne->native_offset = read_sleb128 (ptr, &ptr);
 585         }
 586
 587         if (*ptr++) {
 588                 jit->this_var = g_new0 (MonoDebugVarInfo, 1);
 589                 read_variable (jit->this_var, ptr, &ptr);
 590         }
 591
 592         jit->num_params = read_leb128 (ptr, &ptr);
 593         jit->params = g_new0 (MonoDebugVarInfo, jit->num_params);
 594         for (i = 0; i < jit->num_params; i++)
 595                 read_variable (&jit->params [i], ptr, &ptr);
 596
 597         jit->num_locals = read_leb128 (ptr, &ptr);
 598         jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals);
 599         for (i = 0; i < jit->num_locals; i++)
 600                 read_variable (&jit->locals [i], ptr, &ptr);
 601
 602         if (*ptr++) {
 603                 jit->gsharedvt_info_var = g_new0 (MonoDebugVarInfo, 1);
 604                 jit->gsharedvt_locals_var = g_new0 (MonoDebugVarInfo, 1);
 605                 read_variable (jit->gsharedvt_info_var, ptr, &ptr);
 606                 read_variable (jit->gsharedvt_locals_var, ptr, &ptr);
 607         }
 608
 609         return jit;
 610 }
 611
 612 static MonoDebugMethodJitInfo *
 613 find_method (MonoMethod *method, MonoDomain *domain)
 614 {
 615         MonoDebugDataTable *table;
 616         MonoDebugMethodAddress *address;
 617
 618         table = lookup_data_table (domain);
 619         address = g_hash_table_lookup (table->method_address_hash, method);
 620
 621         if (!address)
 622                 return NULL;
 623
 624         return mono_debug_read_method (address);
 625 }
 626
 627 MonoDebugMethodJitInfo *
 628 mono_debug_find_method (MonoMethod *method, MonoDomain *domain)
 629 {
 630         MonoDebugMethodJitInfo *res;
 631
 632         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 633                 return NULL;
 634
 635         mono_debugger_lock ();
 636         res = find_method (method, domain);
 637         mono_debugger_unlock ();
 638         return res;
 639 }
 640
 641 MonoDebugMethodAddressList *
 642 mono_debug_lookup_method_addresses (MonoMethod *method)
 643 {
 644         g_assert_not_reached ();
 645         return NULL;
 646 }
 647
 648 static gint32
 649 il_offset_from_address (MonoMethod *method, MonoDomain *domain, guint32 native_offset)
 650 {
 651         MonoDebugMethodJitInfo *jit;
 652         int i;
 653
 654         jit = find_method (method, domain);
 655         if (!jit || !jit->line_numbers)
 656                 goto cleanup_and_fail;
 657
 658         for (i = jit->num_line_numbers - 1; i >= 0; i--) {
 659                 MonoDebugLineNumberEntry lne = jit->line_numbers [i];
 660
 661                 if (lne.native_offset <= native_offset) {
 662                         mono_debug_free_method_jit_info (jit);
 663                         return lne.il_offset;
 664                 }
 665         }
 666
 667 cleanup_and_fail:
 668         mono_debug_free_method_jit_info (jit);
 669         return -1;
 670 }
 671
 672 /**
 673  * mono_debug_il_offset_from_address:
 674  *
 675  *   Compute the IL offset corresponding to NATIVE_OFFSET inside the native
 676  * code of METHOD in DOMAIN.
 677  */
 678 gint32
 679 mono_debug_il_offset_from_address (MonoMethod *method, MonoDomain *domain, guint32 native_offset)
 680 {
 681         gint32 res;
 682
 683         mono_debugger_lock ();
 684
 685         res = il_offset_from_address (method, domain, native_offset);
 686
 687         mono_debugger_unlock ();
 688
 689         return res;
 690 }
 691
 692 /**
 693  * mono_debug_lookup_source_location:
 694  * @address: Native offset within the @method's machine code.
 695  *
 696  * Lookup the source code corresponding to the machine instruction located at
 697  * native offset @address within @method.
 698  *
 699  * The returned `MonoDebugSourceLocation' contains both file / line number
 700  * information and the corresponding IL offset.  It must be freed by
 701  * mono_debug_free_source_location().
 702  */
 703 MonoDebugSourceLocation *
 704 mono_debug_lookup_source_location (MonoMethod *method, guint32 address, MonoDomain *domain)
 705 {
 706         MonoDebugMethodInfo *minfo;
 707         MonoDebugSourceLocation *location;
 708         gint32 offset;
 709
 710         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 711                 return NULL;
 712
 713         mono_debugger_lock ();
 714         minfo = mono_debug_lookup_method_internal (method);
 715         if (!minfo || !minfo->handle || !minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile)) {
 716                 mono_debugger_unlock ();
 717                 return NULL;
 718         }
 719
 720         offset = il_offset_from_address (method, domain, address);
 721         if (offset < 0) {
 722                 mono_debugger_unlock ();
 723                 return NULL;
 724         }
 725
 726         location = mono_debug_symfile_lookup_location (minfo, offset);
 727         mono_debugger_unlock ();
 728         return location;
 729 }
 730
 731 /*
 732  * mono_debug_lookup_locals:
 733  *
 734  *   Return information about the local variables of MINFO.
 735  * The result should be freed using mono_debug_symfile_free_locals ().
 736  */
 737 MonoDebugLocalsInfo*
 738 mono_debug_lookup_locals (MonoMethod *method)
 739 {
 740         MonoDebugMethodInfo *minfo;
 741         MonoDebugLocalsInfo *res;
 742
 743         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 744                 return NULL;
 745
 746         mono_debugger_lock ();
 747         minfo = mono_debug_lookup_method_internal (method);
 748         if (!minfo || !minfo->handle || !minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile)) {
 749                 mono_debugger_unlock ();
 750                 return NULL;
 751         }
 752
 753         res = mono_debug_symfile_lookup_locals (minfo);
 754         mono_debugger_unlock ();
 755
 756         return res;
 757 }
 758
 759 /**
 760  * mono_debug_free_source_location:
 761  * @location: A `MonoDebugSourceLocation'.
 762  *
 763  * Frees the @location.
 764  */
 765 void
 766 mono_debug_free_source_location (MonoDebugSourceLocation *location)
 767 {
 768         if (location) {
 769                 g_free (location->source_file);
 770                 g_free (location);
 771         }
 772 }
 773
 774 /**
 775  * mono_debug_print_stack_frame:
 776  * @native_offset: Native offset within the @method's machine code.
 777  *
 778  * Conventient wrapper around mono_debug_lookup_source_location() which can be
 779  * used if you only want to use the location to print a stack frame.
 780  */
 781 gchar *
 782 mono_debug_print_stack_frame (MonoMethod *method, guint32 native_offset, MonoDomain *domain)
 783 {
 784         MonoDebugSourceLocation *location;
 785         gchar *fname, *ptr, *res;
 786         int offset;
 787
 788         fname = mono_method_full_name (method, TRUE);
 789         for (ptr = fname; *ptr; ptr++) {
 790                 if (*ptr == ':') *ptr = '.';
 791         }
 792
 793         location = mono_debug_lookup_source_location (method, native_offset, domain);
 794
 795         if (!location) {
 796                 if (mono_debug_initialized) {
 797                         mono_debugger_lock ();
 798                         offset = il_offset_from_address (method, domain, native_offset);
 799                         mono_debugger_unlock ();
 800                 } else {
 801                         offset = -1;
 802                 }
 803
 804                 if (offset < 0)
 805                         res = g_strdup_printf ("at %s <0x%05x>", fname, native_offset);
 806                 else
 807                         res = g_strdup_printf ("at %s <IL 0x%05x, 0x%05x>", fname, offset, native_offset);
 808                 g_free (fname);
 809                 return res;
 810         }
 811
 812         res = g_strdup_printf ("at %s [0x%05x] in %s:%d", fname, location->il_offset,
 813                                location->source_file, location->row);
 814
 815         g_free (fname);
 816         mono_debug_free_source_location (location);
 817         return res;
 818 }
 819
 820 void
 821 mono_set_is_debugger_attached (gboolean attached)
 822 {
 823         is_attached = attached;
 824 }
 825
 826 gboolean
 827 mono_is_debugger_attached (void)
 828 {
 829         return is_attached;
 830 }
 831
 832 /*
 833  * Bundles
 834  */
 835
 836 typedef struct _BundledSymfile BundledSymfile;
 837
 838 struct _BundledSymfile {
 839         BundledSymfile *next;
 840         const char *aname;
 841         const mono_byte *raw_contents;
 842         int size;
 843 };
 844
 845 static BundledSymfile *bundled_symfiles = NULL;
 846
 847 void
 848 mono_register_symfile_for_assembly (const char *assembly_name, const mono_byte *raw_contents, int size)
 849 {
 850         BundledSymfile *bsymfile;
 851
 852         bsymfile = g_new0 (BundledSymfile, 1);
 853         bsymfile->aname = assembly_name;
 854         bsymfile->raw_contents = raw_contents;
 855         bsymfile->size = size;
 856         bsymfile->next = bundled_symfiles;
 857         bundled_symfiles = bsymfile;
 858 }
 859
 860 static MonoDebugHandle *
 861 open_symfile_from_bundle (MonoImage *image)
 862 {
 863         BundledSymfile *bsymfile;
 864
 865         for (bsymfile = bundled_symfiles; bsymfile; bsymfile = bsymfile->next) {
 866                 if (strcmp (bsymfile->aname, image->module_name))
 867                         continue;
 868
 869                 return mono_debug_open_image (image, bsymfile->raw_contents, bsymfile->size);
 870         }
 871
 872         return NULL;
 873 }
 874
 875 void
 876 mono_debugger_lock (void)
 877 {
 878         g_assert (initialized);
 879         mono_mutex_lock (&debugger_lock_mutex);
 880 }
 881
 882 void
 883 mono_debugger_unlock (void)
 884 {
 885         g_assert (initialized);
 886         mono_mutex_unlock (&debugger_lock_mutex);
 887 }
 888
 889 void
 890 mono_debugger_initialize ()
 891 {
 892         mono_mutex_init_recursive (&debugger_lock_mutex);
 893         initialized = 1;
 894 }
 895
 896 /**
 897  * mono_debug_enabled:
 898  *
 899  * Returns true is debug information is enabled. This doesn't relate if a debugger is present or not.
 900  */
 901 mono_bool
 902 mono_debug_enabled (void)
 903 {
 904         return mono_debug_format != MONO_DEBUG_FORMAT_NONE;
 905 }