mono/metadata/debug-mono-symfile.c

   1 #include <config.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <signal.h>
   5 #include <mono/metadata/metadata.h>
   6 #include <mono/metadata/tabledefs.h>
   7 #include <mono/metadata/rawbuffer.h>
   8 #include <mono/metadata/tokentype.h>
   9 #include <mono/metadata/appdomain.h>
  10 #include <mono/metadata/exception.h>
  11 #include <mono/metadata/debug-helpers.h>
  12 #include <mono/metadata/debug-mono-symfile.h>
  13
  14 #include <fcntl.h>
  15 #include <unistd.h>
  16
  17 struct MonoSymbolFilePriv
  18 {
  19         int fd;
  20         int error;
  21         char *file_name;
  22         char *source_file;
  23         guint32 string_table_size;
  24         guint32 string_offset_size;
  25         MonoImage *image;
  26         GHashTable *method_table;
  27         GHashTable *method_hash;
  28         MonoSymbolFileOffsetTable *offset_table;
  29         GPtrArray *range_table;
  30 };
  31
  32 typedef struct
  33 {
  34         MonoMethod *method;
  35         MonoDebugMethodInfo *minfo;
  36         MonoSymbolFileMethodEntry *entry;
  37         guint32 method_name_offset;
  38         guint32 index;
  39         gchar *name;
  40 } MonoSymbolFileMethodEntryPriv;
  41
  42 static int write_string_table (MonoSymbolFile *symfile);
  43 static int create_symfile (MonoSymbolFile *symfile, gboolean emit_warnings);
  44 static void close_symfile (MonoSymbolFile *symfile);
  45
  46 static void
  47 free_method_info (MonoDebugMethodInfo *minfo)
  48 {
  49         g_free (minfo->jit);
  50         g_free (minfo);
  51 }
  52
  53 static int
  54 load_symfile (MonoSymbolFile *symfile)
  55 {
  56         MonoSymbolFilePriv *priv = symfile->_priv;
  57         MonoSymbolFileMethodEntry *me;
  58         const char *ptr, *start;
  59         guint64 magic;
  60         long version;
  61         int i;
  62
  63         ptr = start = symfile->raw_contents;
  64
  65         magic = *((guint64 *) ptr)++;
  66         if (magic != MONO_SYMBOL_FILE_MAGIC) {
  67                 g_warning ("Symbol file %s has is not a mono symbol file", priv->file_name);
  68                 return FALSE;
  69         }
  70
  71         version = *((guint32 *) ptr)++;
  72         if (version != MONO_SYMBOL_FILE_VERSION) {
  73                 g_warning ("Symbol file %s has incorrect line number table version "
  74                            "(expected %d, got %ld)", priv->file_name,
  75                            MONO_SYMBOL_FILE_VERSION, version);
  76                 return FALSE;
  77         }
  78
  79         priv->offset_table = (MonoSymbolFileOffsetTable *) ptr;
  80         symfile->address_table_size = priv->offset_table->address_table_size;
  81
  82         /*
  83          * Read method table.
  84          *
  85          */
  86
  87         priv->method_table = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
  88                                                     (GDestroyNotify) g_free);
  89         priv->method_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
  90                                                    (GDestroyNotify) free_method_info);
  91
  92         ptr = symfile->raw_contents + priv->offset_table->method_table_offset;
  93         me = (MonoSymbolFileMethodEntry *) ptr;
  94
  95         for (i = 0; i < priv->offset_table->method_count; i++, me++) {
  96                 MonoMethod *method = mono_get_method (priv->image, me->token, NULL);
  97                 MonoSymbolFileMethodEntryPriv *mep;
  98                 MonoDebugMethodInfo *minfo;
  99
 100                 if (!method)
 101                         continue;
 102
 103                 if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
 104                     (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
 105                     (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
 106                         g_assert_not_reached ();
 107
 108                 if (!((MonoMethodNormal *) method)->header) {
 109                         g_warning (G_STRLOC ": Internal error: method %s.%s doesn't have a header",
 110                                    method->klass->name, method->name);
 111                         continue;
 112                 }
 113
 114                 minfo = g_new0 (MonoDebugMethodInfo, 1);
 115                 minfo->file_offset = ((const char *) me) - start;
 116                 minfo->method = method;
 117                 minfo->symfile = symfile;
 118                 minfo->num_il_offsets = me->num_line_numbers;
 119                 minfo->il_offsets = (MonoSymbolFileLineNumberEntry *)
 120                         (symfile->raw_contents + me->line_number_table_offset);
 121
 122                 mep = g_new0 (MonoSymbolFileMethodEntryPriv, 1);
 123                 mep->method = method;
 124                 mep->minfo = minfo;
 125                 mep->entry = me;
 126                 mep->index = i;
 127
 128                 mep->method_name_offset = priv->string_table_size;
 129                 mep->name = g_strdup_printf ("%s%s.%s", method->klass->name_space,
 130                                              method->klass->name, method->name);
 131                 priv->string_table_size += strlen (mep->name) + 1;
 132
 133                 g_hash_table_insert (priv->method_table, method, mep);
 134                 g_hash_table_insert (priv->method_hash, method, minfo);
 135         }
 136
 137         if (!write_string_table (symfile))
 138                 return FALSE;
 139
 140         return TRUE;
 141 }
 142
 143 MonoSymbolFile *
 144 mono_debug_open_mono_symbol_file (MonoImage *image, const char *filename, gboolean emit_warnings)
 145 {
 146         MonoSymbolFile *symfile;
 147         MonoSymbolFilePriv *priv;
 148         off_t file_size;
 149         void *ptr;
 150         int fd;
 151
 152         fd = open (filename, O_RDONLY);
 153         if (fd == -1) {
 154                 if (emit_warnings)
 155                         g_warning ("Can't open symbol file: %s", filename);
 156                 return NULL;
 157         }
 158
 159         file_size = lseek (fd, 0, SEEK_END);
 160         lseek (fd, 0, SEEK_SET);
 161
 162         if (file_size == (off_t) -1) {
 163                 if (emit_warnings)
 164                         g_warning ("Can't get size of symbol file: %s", filename);
 165                 return NULL;
 166         }
 167
 168         ptr = mono_raw_buffer_load (fd, FALSE, 0, file_size);
 169         if (!ptr) {
 170                 if (emit_warnings)
 171                         g_warning ("Can't read symbol file: %s", filename);
 172                 return NULL;
 173         }
 174
 175         symfile = g_new0 (MonoSymbolFile, 1);
 176         symfile->magic = MONO_SYMBOL_FILE_MAGIC;
 177         symfile->version = MONO_SYMBOL_FILE_VERSION;
 178         symfile->image_file = g_strdup (image->name);
 179         symfile->raw_contents = ptr;
 180         symfile->raw_contents_size = file_size;
 181
 182         symfile->_priv = priv = g_new0 (MonoSymbolFilePriv, 1);
 183
 184         priv->fd = fd;
 185         priv->image = image;
 186         priv->file_name = g_strdup (filename);
 187
 188         if (!load_symfile (symfile)) {
 189                 mono_debug_close_mono_symbol_file (symfile);
 190                 return NULL;
 191         }
 192
 193         return symfile;
 194 }
 195
 196 static void
 197 close_symfile (MonoSymbolFile *symfile)
 198 {
 199         MonoSymbolFilePriv *priv = symfile->_priv;
 200
 201         if (symfile->raw_contents) {
 202                 mono_raw_buffer_free (symfile->raw_contents);
 203                 symfile->raw_contents = NULL;
 204         }
 205
 206         if (priv->fd) {
 207                 close (priv->fd);
 208                 priv->fd = 0;
 209         }
 210
 211         if (priv->method_table) {
 212                 g_hash_table_destroy (priv->method_table);
 213                 priv->method_table = NULL;
 214         }
 215
 216         if (priv->method_hash) {
 217                 g_hash_table_destroy (priv->method_hash);
 218                 priv->method_hash = NULL;
 219         }
 220
 221         if (symfile->is_dynamic)
 222                 unlink (priv->file_name);
 223
 224         if (symfile->image_file) {
 225                 g_free (symfile->image_file);
 226                 symfile->image_file = NULL;
 227         }
 228
 229         if (priv->file_name) {
 230                 g_free (priv->file_name);
 231                 priv->file_name = NULL;
 232         }
 233
 234         priv->error = FALSE;
 235 }
 236
 237 void
 238 mono_debug_close_mono_symbol_file (MonoSymbolFile *symfile)
 239 {
 240         if (!symfile)
 241                 return;
 242
 243         close_symfile (symfile);
 244
 245         g_free (symfile->_priv->source_file);
 246         g_free (symfile->_priv);
 247         g_free (symfile);
 248 }
 249
 250 static int
 251 write_string (int fd, const char *string)
 252 {
 253         guint32 length = strlen (string);
 254
 255         if (write (fd, &length, sizeof (length)) < 0)
 256                 return FALSE;
 257
 258         if (write (fd, string, strlen (string)) < 0)
 259                 return FALSE;
 260
 261         return TRUE;
 262 }
 263
 264 static gchar *
 265 read_string (const char *ptr)
 266 {
 267         int len = *((guint32 *) ptr)++;
 268
 269         return g_filename_from_utf8 (ptr, len, NULL, NULL, NULL);
 270 }
 271
 272 gchar *
 273 mono_debug_find_source_location (MonoSymbolFile *symfile, MonoMethod *method, guint32 offset,
 274                                  guint32 *line_number)
 275 {
 276         MonoSymbolFilePriv *priv = symfile->_priv;
 277         MonoSymbolFileLineNumberEntry *lne;
 278         MonoSymbolFileMethodEntryPriv *mep;
 279         gchar *source_file = NULL;
 280         const char *ptr;
 281         int i;
 282
 283         if (!priv->method_table || symfile->is_dynamic)
 284                 return NULL;
 285
 286         mep = g_hash_table_lookup (priv->method_table, method);
 287         if (!mep)
 288                 return NULL;
 289
 290         if (mep->entry->source_file_offset)
 291                 source_file = read_string (symfile->raw_contents + mep->entry->source_file_offset);
 292
 293         ptr = symfile->raw_contents + mep->entry->line_number_table_offset;
 294
 295         lne = (MonoSymbolFileLineNumberEntry *) ptr;
 296
 297         for (i = 0; i < mep->entry->num_line_numbers; i++, lne++) {
 298                 if (lne->offset < offset)
 299                         continue;
 300
 301                 if (line_number) {
 302                         *line_number = lne->row;
 303                         if (source_file)
 304                                 return source_file;
 305                         else
 306                                 return NULL;
 307                 } else if (source_file) {
 308                         gchar *retval = g_strdup_printf ("%s:%d", source_file, lne->row);
 309                         g_free (source_file);
 310                         return retval;
 311                 } else
 312                         return g_strdup_printf ("%d", lne->row);
 313         }
 314
 315         return NULL;
 316 }
 317
 318 static void
 319 update_method_func (gpointer key, gpointer value, gpointer user_data)
 320 {
 321         MonoSymbolFile *symfile = (MonoSymbolFile *) user_data;
 322         MonoSymbolFileMethodEntryPriv *mep = (MonoSymbolFileMethodEntryPriv *) value;
 323         MonoSymbolFileMethodAddress *address;
 324         MonoSymbolFileLineNumberEntry *lne;
 325         MonoDebugRangeInfo *range;
 326         int i;
 327
 328         if (!mep->minfo) {
 329                 mep->minfo = g_hash_table_lookup (symfile->_priv->method_hash, mep->method);
 330                 if (!mep->minfo)
 331                         return;
 332         }
 333
 334         if (!mep->minfo->jit)
 335                 return;
 336
 337         address = (MonoSymbolFileMethodAddress *)
 338                 (symfile->address_table + mep->entry->address_table_offset);
 339
 340         address->is_valid = TRUE;
 341         address->start_address = GPOINTER_TO_UINT (mep->minfo->jit->code_start);
 342         address->end_address = GPOINTER_TO_UINT (mep->minfo->jit->code_start + mep->minfo->jit->code_size);
 343
 344         range = g_new0 (MonoDebugRangeInfo, 1);
 345         range->start_address = address->start_address;
 346         range->end_address = address->end_address;
 347         range->file_offset = mep->minfo->file_offset;
 348
 349         g_ptr_array_add (symfile->_priv->range_table, range);
 350
 351         lne = (MonoSymbolFileLineNumberEntry *)
 352                 (symfile->raw_contents + mep->entry->line_number_table_offset);
 353
 354         for (i = 0; i < mep->entry->num_line_numbers; i++, lne++) {
 355                 int j;
 356
 357                 if (i == 0) {
 358                         address->line_addresses [i] = 0;
 359                         continue;
 360                 } else if (lne->offset == 0) {
 361                         address->line_addresses [i] = mep->minfo->jit->prologue_end;
 362                         continue;
 363                 }
 364
 365                 address->line_addresses [i] = mep->minfo->jit->code_size;
 366
 367                 for (j = 0; j < mep->minfo->num_il_offsets; j++) {
 368                         MonoSymbolFileLineNumberEntry *il = &mep->minfo->il_offsets [j];
 369
 370                         if (il->offset >= lne->offset) {
 371                                 address->line_addresses [i] = mep->minfo->jit->il_addresses [j];
 372                                 break;
 373                         }
 374                 }
 375         }
 376 }
 377
 378 static gint
 379 range_table_compare_func (gconstpointer a, gconstpointer b)
 380 {
 381         const MonoDebugRangeInfo *r1 = (const MonoDebugRangeInfo *) a;
 382         const MonoDebugRangeInfo *r2 = (const MonoDebugRangeInfo *) b;
 383
 384         if (r1->start_address < r2->start_address)
 385                 return -1;
 386         else if (r1->start_address > r2->start_address)
 387                 return 1;
 388         else
 389                 return 0;
 390 }
 391
 392 void
 393 mono_debug_update_mono_symbol_file (MonoSymbolFile *symfile)
 394 {
 395         int i;
 396
 397         if (!symfile->_priv->method_table)
 398                 return;
 399
 400         symfile->_priv->range_table = g_ptr_array_new ();
 401
 402         if (!symfile->address_table)
 403                 symfile->address_table = g_malloc0 (symfile->address_table_size);
 404
 405         g_hash_table_foreach (symfile->_priv->method_table, update_method_func, symfile);
 406
 407         symfile->range_table_size = symfile->_priv->range_table->len * sizeof (MonoDebugRangeInfo);
 408         symfile->range_table = g_malloc0 (symfile->range_table_size);
 409
 410         g_ptr_array_sort (symfile->_priv->range_table, range_table_compare_func);
 411
 412         for (i = 0; i < symfile->_priv->range_table->len; i++) {
 413                 MonoDebugRangeInfo *range = g_ptr_array_index (symfile->_priv->range_table, i);
 414
 415                 symfile->range_table [i] = *range;
 416         }
 417
 418         g_ptr_array_free (symfile->_priv->range_table, TRUE);
 419         symfile->_priv->range_table = NULL;
 420 }
 421
 422 static void
 423 free_method_entry (MonoSymbolFileMethodEntryPriv *mep)
 424 {
 425         g_free (mep->name);
 426         g_free (mep->entry);
 427         g_free (mep);
 428 }
 429
 430 static void
 431 create_method (MonoSymbolFile *symfile, guint32 token, MonoMethod *method)
 432 {
 433         MonoSymbolFileMethodEntryPriv *mep;
 434         MonoDebugMethodInfo *minfo;
 435
 436         g_assert (method->klass->image == symfile->_priv->image);
 437
 438         mep = g_new0 (MonoSymbolFileMethodEntryPriv, 1);
 439         mep->entry = g_new0 (MonoSymbolFileMethodEntry, 1);
 440         mep->entry->token = token;
 441         mep->entry->source_file_offset = symfile->_priv->offset_table->source_table_offset;
 442
 443         mep->method_name_offset = symfile->_priv->string_table_size;
 444         mep->name = g_strdup_printf ("%s%s.%s", method->klass->name_space,
 445                                      method->klass->name, method->name);
 446         symfile->_priv->string_table_size += strlen (mep->name) + 1;
 447
 448         minfo = g_new0 (MonoDebugMethodInfo, 1);
 449         minfo->method = method;
 450         minfo->symfile = symfile;
 451
 452         mep->minfo = minfo;
 453         mep->method = method;
 454
 455         symfile->_priv->offset_table->method_count++;
 456
 457         g_hash_table_insert (symfile->_priv->method_table, method, mep);
 458         g_hash_table_insert (symfile->_priv->method_hash, method, minfo);
 459 }
 460
 461 static void
 462 write_method (gpointer key, gpointer value, gpointer user_data)
 463 {
 464         MonoSymbolFile *symfile = (MonoSymbolFile *) user_data;
 465         MonoSymbolFileMethodEntryPriv *mep = (MonoSymbolFileMethodEntryPriv *) value;
 466
 467         if (symfile->_priv->error)
 468                 return;
 469
 470         mep->minfo->file_offset = lseek (symfile->_priv->fd, 0, SEEK_CUR);
 471
 472         if (write (symfile->_priv->fd, mep->entry, sizeof (MonoSymbolFileMethodEntry)) < 0) {
 473                 symfile->_priv->error = TRUE;
 474                 return;
 475         }
 476 }
 477
 478 static void
 479 write_line_numbers (gpointer key, gpointer value, gpointer user_data)
 480 {
 481         MonoSymbolFile *symfile = (MonoSymbolFile *) user_data;
 482         MonoSymbolFilePriv *priv = symfile->_priv;
 483         MonoSymbolFileMethodEntryPriv *mep = (MonoSymbolFileMethodEntryPriv *) value;
 484         MonoSymbolFileLineNumberEntry lne;
 485         const unsigned char *ip, *start, *end;
 486         MonoMethodHeader *header;
 487
 488         if (priv->error)
 489                 return;
 490
 491         if ((mep->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
 492             (mep->method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
 493             (mep->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
 494                 g_assert_not_reached ();
 495
 496         header = ((MonoMethodNormal *) mep->method)->header;
 497         g_assert (header);
 498
 499         mep->entry->line_number_table_offset = lseek (priv->fd, 0, SEEK_CUR);
 500         ++mep->entry->num_line_numbers;
 501
 502         lne.offset = 0;
 503         lne.row = -1;
 504
 505         if (write (priv->fd, &lne, sizeof (MonoSymbolFileLineNumberEntry)) < 0) {
 506                 priv->error = TRUE;
 507                 return;
 508         }
 509
 510         ip = start = header->code;
 511         end = ip + header->code_size;
 512
 513         while (ip < end) {
 514                 gchar *line;
 515
 516                 ++mep->entry->num_line_numbers;
 517                 lne.offset = ip - start;
 518                 lne.row = -1;
 519
 520                 if (write (priv->fd, &lne, sizeof (MonoSymbolFileLineNumberEntry)) < 0) {
 521                         priv->error = TRUE;
 522                         return;
 523                 }
 524
 525                 line = mono_disasm_code_one (NULL, mep->method, ip, &ip);
 526                 g_free (line);
 527         }
 528
 529         mep->entry->address_table_offset = symfile->address_table_size;
 530         mep->entry->address_table_size = sizeof (MonoSymbolFileMethodAddress) +
 531                 mep->entry->num_line_numbers * sizeof (guint32);
 532
 533         symfile->address_table_size += mep->entry->address_table_size;
 534 }
 535
 536 static void
 537 create_methods (MonoSymbolFile *symfile)
 538 {
 539         MonoImage *image = symfile->_priv->image;
 540         MonoTableInfo *table = &image->tables [MONO_TABLE_METHOD];
 541         int idx;
 542
 543         for (idx = 1; idx <= table->rows; idx++) {
 544                 guint32 token = mono_metadata_make_token (MONO_TABLE_METHOD, idx);
 545                 MonoMethod *method = mono_get_method (image, token, NULL);
 546
 547                 if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
 548                     (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
 549                     (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
 550                         continue;
 551
 552                 if (method->wrapper_type != MONO_WRAPPER_NONE)
 553                         continue;
 554
 555                 if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
 556                     (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
 557                     (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
 558                         g_assert_not_reached ();
 559
 560                 if (!((MonoMethodNormal *) method)->header) {
 561                         g_warning (G_STRLOC ": Internal error: method %s.%s doesn't have a header",
 562                                    method->klass->name, method->name);
 563                         continue;
 564                 }
 565
 566                 create_method (symfile, token, method);
 567         }
 568 }
 569
 570 static void
 571 load_line_numbers (gpointer key, gpointer value, gpointer user_data)
 572 {
 573         MonoSymbolFile *symfile = (MonoSymbolFile *) user_data;
 574         MonoSymbolFileMethodEntryPriv *mep = (MonoSymbolFileMethodEntryPriv *) value;
 575
 576         mep->minfo->num_il_offsets = mep->entry->num_line_numbers;
 577         mep->minfo->il_offsets = (MonoSymbolFileLineNumberEntry *)
 578                 (symfile->raw_contents + mep->entry->line_number_table_offset);
 579 }
 580
 581 static int
 582 create_symfile (MonoSymbolFile *symfile, gboolean emit_warnings)
 583 {
 584         MonoSymbolFilePriv *priv = symfile->_priv;
 585         char *ptr;
 586         guint64 magic;
 587         long version;
 588         off_t offset;
 589
 590         priv->fd = g_file_open_tmp (NULL, &priv->file_name, NULL);
 591         if (priv->fd == -1) {
 592                 if (emit_warnings)
 593                         g_warning ("Can't create symbol file");
 594                 return FALSE;
 595         }
 596
 597         magic = MONO_SYMBOL_FILE_MAGIC;
 598         if (write (priv->fd, &magic, sizeof (magic)) < 0)
 599                 return FALSE;
 600
 601         version = MONO_SYMBOL_FILE_VERSION;
 602         if (write (priv->fd, &version, sizeof (version)) < 0)
 603                 return FALSE;
 604
 605         offset = lseek (priv->fd, 0, SEEK_CUR);
 606
 607         priv->offset_table = g_new0 (MonoSymbolFileOffsetTable, 1);
 608         if (write (priv->fd, priv->offset_table, sizeof (MonoSymbolFileOffsetTable)) < 0)
 609                 return FALSE;
 610
 611         //
 612         // Write source file table.
 613         //
 614         if (priv->source_file) {
 615                 priv->offset_table->source_table_offset = lseek (priv->fd, 0, SEEK_CUR);
 616                 if (!write_string (priv->fd, priv->source_file))
 617                         return FALSE;
 618                 priv->offset_table->source_table_size = lseek (priv->fd, 0, SEEK_CUR) -
 619                         priv->offset_table->source_table_offset;
 620         }
 621
 622         //
 623         // Create method table.
 624         //
 625
 626         priv->method_table = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
 627                                                     (GDestroyNotify) free_method_entry);
 628         priv->method_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
 629                                                    (GDestroyNotify) free_method_info);
 630
 631         create_methods (symfile);
 632
 633         //
 634         // Write line numbers.
 635         //
 636
 637         priv->offset_table->line_number_table_offset = lseek (priv->fd, 0, SEEK_CUR);
 638
 639         g_hash_table_foreach (priv->method_table, write_line_numbers, symfile);
 640         if (priv->error)
 641                 return FALSE;
 642
 643         priv->offset_table->line_number_table_size = lseek (priv->fd, 0, SEEK_CUR) -
 644                 priv->offset_table->line_number_table_offset;
 645
 646         //
 647         // Write method table.
 648         //
 649
 650         priv->offset_table->method_table_offset = lseek (priv->fd, 0, SEEK_CUR);
 651
 652         g_hash_table_foreach (priv->method_table, write_method, symfile);
 653         if (priv->error)
 654                 return FALSE;
 655
 656         priv->offset_table->method_table_size = lseek (priv->fd, 0, SEEK_CUR) -
 657                 priv->offset_table->method_table_offset;
 658
 659         //
 660         // Write offset table.
 661         //
 662
 663         symfile->raw_contents_size = lseek (priv->fd, 0, SEEK_CUR);
 664         priv->offset_table->address_table_size = symfile->address_table_size;
 665
 666         lseek (priv->fd, offset, SEEK_SET);
 667         if (write (priv->fd, priv->offset_table, sizeof (MonoSymbolFileOffsetTable)) < 0)
 668                 return FALSE;
 669
 670         lseek (priv->fd, symfile->raw_contents_size, SEEK_SET);
 671
 672         ptr = mono_raw_buffer_load (priv->fd, TRUE, 0, symfile->raw_contents_size);
 673         if (!ptr)
 674                 return FALSE;
 675
 676         symfile->raw_contents = ptr;
 677
 678         //
 679         // Load line number table.
 680         //
 681         g_hash_table_foreach (priv->method_table, load_line_numbers, symfile);
 682         if (priv->error)
 683                 return FALSE;
 684
 685         if (!write_string_table (symfile))
 686                 return FALSE;
 687
 688         return TRUE;
 689 }
 690
 691 MonoSymbolFile *
 692 mono_debug_create_mono_symbol_file (MonoImage *image)
 693 {
 694         MonoSymbolFile *symfile;
 695
 696         symfile = g_new0 (MonoSymbolFile, 1);
 697         symfile->magic = MONO_SYMBOL_FILE_MAGIC;
 698         symfile->version = MONO_SYMBOL_FILE_VERSION;
 699         symfile->is_dynamic = TRUE;
 700         symfile->image_file = g_strdup (image->name);
 701
 702         symfile->_priv = g_new0 (MonoSymbolFilePriv, 1);
 703         symfile->_priv->image = image;
 704
 705         if (!create_symfile (symfile, TRUE)) {
 706                 mono_debug_close_mono_symbol_file (symfile);
 707                 return NULL;
 708         }
 709
 710         return symfile;
 711 }
 712
 713 MonoDebugMethodInfo *
 714 mono_debug_find_method (MonoSymbolFile *symfile, MonoMethod *method)
 715 {
 716         return g_hash_table_lookup (symfile->_priv->method_hash, method);
 717 }
 718
 719 static void
 720 write_method_name (gpointer key, gpointer value, gpointer user_data)
 721 {
 722         MonoSymbolFile *symfile = (MonoSymbolFile *) user_data;
 723         MonoSymbolFileMethodEntryPriv *mep = (MonoSymbolFileMethodEntryPriv *) value;
 724         MonoSymbolFilePriv *priv = symfile->_priv;
 725         guint8 *offset_ptr, *string_ptr;
 726         guint32 offset;
 727
 728         offset = mep->method_name_offset + priv->string_offset_size;
 729
 730         offset_ptr = symfile->string_table + mep->index * 4;
 731         string_ptr = symfile->string_table + offset;
 732
 733         *((guint32 *) offset_ptr) = offset;
 734         strcpy (string_ptr, mep->name);
 735 }
 736
 737 static int
 738 write_string_table (MonoSymbolFile *symfile)
 739 {
 740         MonoSymbolFilePriv *priv = symfile->_priv;
 741
 742         priv->string_offset_size = priv->offset_table->method_count * 4;
 743
 744         symfile->string_table_size = priv->string_table_size + priv->string_offset_size;
 745         symfile->string_table = g_malloc0 (symfile->string_table_size);
 746
 747         g_hash_table_foreach (symfile->_priv->method_table, write_method_name, symfile);
 748         return TRUE;
 749 }