mono/mini/dwarfwriter.c

   1 /*
   2  * dwarfwriter.c: Creation of DWARF debug information
   3  *
   4  * Author:
   5  *   Zoltan Varga (vargaz@gmail.com)
   6  *
   7  * (C) 2008-2009 Novell, Inc.
   8  */
   9
  10 #include "config.h"
  11
  12 #if !defined(DISABLE_AOT) && !defined(DISABLE_JIT)
  13 #include "dwarfwriter.h"
  14
  15 #include <sys/types.h>
  16 #include <ctype.h>
  17 #include <string.h>
  18 #ifdef HAVE_STDINT_H
  19 #include <stdint.h>
  20 #endif
  21
  22 #include <mono/metadata/mono-endian.h>
  23 #include <mono/metadata/debug-mono-symfile.h>
  24 #include <mono/utils/mono-compiler.h>
  25
  26 #ifndef PLATFORM_WIN32
  27 #include <mono/utils/freebsd-elf32.h>
  28 #include <mono/utils/freebsd-elf64.h>
  29 #endif
  30
  31 #include <mono/utils/freebsd-dwarf.h>
  32
  33 struct _MonoDwarfWriter
  34 {
  35         MonoImageWriter *w;
  36         GHashTable *class_to_die, *class_to_vtype_die, *class_to_pointer_die;
  37         GHashTable *class_to_reference_die;
  38         int fde_index, tdie_index, line_number_file_index, line_number_dir_index;
  39         GHashTable *file_to_index, *dir_to_index;
  40         FILE *il_file;
  41         int il_file_line_index, loclist_index;
  42         GSList *cie_program;
  43 };
  44
  45 /*
  46  * mono_dwarf_writer_create:
  47  *
  48  *   Create a DWARF writer object. WRITER is the underlying image writer this
  49  * writer will emit to. IL_FILE is the file where IL code will be dumped to for
  50  * methods which have no line number info. It can be NULL.
  51  */
  52 MonoDwarfWriter*
  53 mono_dwarf_writer_create (MonoImageWriter *writer, FILE *il_file)
  54 {
  55         MonoDwarfWriter *w = g_new0 (MonoDwarfWriter, 1);
  56
  57         w->w = writer;
  58         w->il_file = il_file;
  59
  60         return w;
  61 }
  62
  63 void
  64 mono_dwarf_writer_destroy (MonoDwarfWriter *w)
  65 {
  66         g_free (w);
  67 }
  68
  69 /* Wrappers around the image writer functions */
  70
  71 static inline void
  72 emit_section_change (MonoDwarfWriter *w, const char *section_name, int subsection_index)
  73 {
  74         img_writer_emit_section_change (w->w, section_name, subsection_index);
  75 }
  76
  77 static inline void
  78 emit_push_section (MonoDwarfWriter *w, const char *section_name, int subsection)
  79 {
  80         img_writer_emit_push_section (w->w, section_name, subsection);
  81 }
  82
  83 static inline void
  84 emit_pop_section (MonoDwarfWriter *w)
  85 {
  86         img_writer_emit_pop_section (w->w);
  87 }
  88
  89 static inline void
  90 emit_local_symbol (MonoDwarfWriter *w, const char *name, const char *end_label, gboolean func)
  91 {
  92         img_writer_emit_local_symbol (w->w, name, end_label, func);
  93 }
  94
  95 static inline void
  96 emit_label (MonoDwarfWriter *w, const char *name)
  97 {
  98         img_writer_emit_label (w->w, name);
  99 }
 100
 101 static inline void
 102 emit_bytes (MonoDwarfWriter *w, const guint8* buf, int size)
 103 {
 104         img_writer_emit_bytes (w->w, buf, size);
 105 }
 106
 107 static inline void
 108 emit_string (MonoDwarfWriter *w, const char *value)
 109 {
 110         img_writer_emit_string (w->w, value);
 111 }
 112
 113 static inline void
 114 emit_line (MonoDwarfWriter *w)
 115 {
 116         img_writer_emit_line (w->w);
 117 }
 118
 119 static inline void
 120 emit_alignment (MonoDwarfWriter *w, int size)
 121 {
 122         img_writer_emit_alignment (w->w, size);
 123 }
 124
 125 static inline void
 126 emit_pointer_unaligned (MonoDwarfWriter *w, const char *target)
 127 {
 128         img_writer_emit_pointer_unaligned (w->w, target);
 129 }
 130
 131 static inline void
 132 emit_pointer (MonoDwarfWriter *w, const char *target)
 133 {
 134         img_writer_emit_pointer (w->w, target);
 135 }
 136
 137 static inline void
 138 emit_int16 (MonoDwarfWriter *w, int value)
 139 {
 140         img_writer_emit_int16 (w->w, value);
 141 }
 142
 143 static inline void
 144 emit_int32 (MonoDwarfWriter *w, int value)
 145 {
 146         img_writer_emit_int32 (w->w, value);
 147 }
 148
 149 static inline void
 150 emit_symbol_diff (MonoDwarfWriter *w, const char *end, const char* start, int offset)
 151 {
 152         img_writer_emit_symbol_diff (w->w, end, start, offset);
 153 }
 154
 155 static inline void
 156 emit_zero_bytes (MonoDwarfWriter *w, int num)
 157 {
 158         img_writer_emit_zero_bytes (w->w, num);
 159 }
 160
 161 static inline void
 162 emit_byte (MonoDwarfWriter *w, guint8 val)
 163 {
 164         img_writer_emit_byte (w->w, val);
 165 }
 166
 167 static G_GNUC_UNUSED void
 168 emit_uleb128 (MonoDwarfWriter *w, guint32 value)
 169 {
 170         do {
 171                 guint8 b = value & 0x7f;
 172                 value >>= 7;
 173                 if (value != 0) /* more bytes to come */
 174                         b |= 0x80;
 175                 emit_byte (w, b);
 176         } while (value);
 177 }
 178
 179 static G_GNUC_UNUSED void
 180 emit_sleb128 (MonoDwarfWriter *w, gint64 value)
 181 {
 182         gboolean more = 1;
 183         gboolean negative = (value < 0);
 184         guint32 size = 64;
 185         guint8 byte;
 186
 187         while (more) {
 188                 byte = value & 0x7f;
 189                 value >>= 7;
 190                 /* the following is unnecessary if the
 191                  * implementation of >>= uses an arithmetic rather
 192                  * than logical shift for a signed left operand
 193                  */
 194                 if (negative)
 195                         /* sign extend */
 196                         value |= - ((gint64)1 <<(size - 7));
 197                 /* sign bit of byte is second high order bit (0x40) */
 198                 if ((value == 0 && !(byte & 0x40)) ||
 199                         (value == -1 && (byte & 0x40)))
 200                         more = 0;
 201                 else
 202                         byte |= 0x80;
 203                 emit_byte (w, byte);
 204         }
 205 }
 206
 207 static G_GNUC_UNUSED void
 208 encode_uleb128 (guint32 value, guint8 *buf, guint8 **endbuf)
 209 {
 210         guint8 *p = buf;
 211
 212         do {
 213                 guint8 b = value & 0x7f;
 214                 value >>= 7;
 215                 if (value != 0) /* more bytes to come */
 216                         b |= 0x80;
 217                 *p ++ = b;
 218         } while (value);
 219
 220         *endbuf = p;
 221 }
 222
 223 static G_GNUC_UNUSED void
 224 encode_sleb128 (gint32 value, guint8 *buf, guint8 **endbuf)
 225 {
 226         gboolean more = 1;
 227         gboolean negative = (value < 0);
 228         guint32 size = 32;
 229         guint8 byte;
 230         guint8 *p = buf;
 231
 232         while (more) {
 233                 byte = value & 0x7f;
 234                 value >>= 7;
 235                 /* the following is unnecessary if the
 236                  * implementation of >>= uses an arithmetic rather
 237                  * than logical shift for a signed left operand
 238                  */
 239                 if (negative)
 240                         /* sign extend */
 241                         value |= - (1 <<(size - 7));
 242                 /* sign bit of byte is second high order bit (0x40) */
 243                 if ((value == 0 && !(byte & 0x40)) ||
 244                         (value == -1 && (byte & 0x40)))
 245                         more = 0;
 246                 else
 247                         byte |= 0x80;
 248                 *p ++= byte;
 249         }
 250
 251         *endbuf = p;
 252 }
 253
 254 static void
 255 emit_dwarf_abbrev (MonoDwarfWriter *w, int code, int tag, gboolean has_child,
 256                                    int *attrs, int attrs_len)
 257 {
 258         int i;
 259
 260         emit_uleb128 (w, code);
 261         emit_uleb128 (w, tag);
 262         emit_byte (w, has_child);
 263
 264         for (i = 0; i < attrs_len; i++)
 265                 emit_uleb128 (w, attrs [i]);
 266         emit_uleb128 (w, 0);
 267         emit_uleb128 (w, 0);
 268 }
 269
 270 static void
 271 emit_cie (MonoDwarfWriter *w)
 272 {
 273         emit_section_change (w, ".debug_frame", 0);
 274
 275         emit_alignment (w, 8);
 276
 277         /* Emit a CIE */
 278         emit_symbol_diff (w, ".Lcie0_end", ".", -4); /* length */
 279         emit_int32 (w, 0xffffffff); /* CIE id */
 280         emit_byte (w, 3); /* version */
 281         emit_string (w, ""); /* augmention */
 282         emit_sleb128 (w, 1); /* code alignment factor */
 283         emit_sleb128 (w, mono_unwind_get_dwarf_data_align ()); /* data alignment factor */
 284         emit_uleb128 (w, mono_unwind_get_dwarf_pc_reg ());
 285
 286         w->cie_program = w->cie_program;
 287         if (w->cie_program) {
 288                 guint32 uw_info_len;
 289                 guint8 *uw_info = mono_unwind_ops_encode (w->cie_program, &uw_info_len);
 290                 emit_bytes (w, uw_info, uw_info_len);
 291                 g_free (uw_info);
 292         }
 293
 294         emit_alignment (w, sizeof (gpointer));
 295         emit_label (w, ".Lcie0_end");
 296 }
 297
 298 static void
 299 emit_pointer_value (MonoDwarfWriter *w, gpointer ptr)
 300 {
 301         gssize val = (gssize)ptr;
 302         emit_bytes (w, (guint8*)&val, sizeof (gpointer));
 303 }
 304
 305 static void
 306 emit_fde (MonoDwarfWriter *w, int fde_index, char *start_symbol, char *end_symbol,
 307                   guint8 *code, guint32 code_size, GSList *unwind_ops, gboolean use_cie)
 308 {
 309         char symbol [128];
 310         GSList *l;
 311         guint8 *uw_info;
 312         guint32 uw_info_len;
 313
 314         emit_section_change (w, ".debug_frame", 0);
 315
 316         sprintf (symbol, ".Lfde%d_end", fde_index);
 317         emit_symbol_diff (w, symbol, ".", -4); /* length */
 318         emit_int32 (w, 0); /* CIE_pointer */
 319         if (start_symbol) {
 320                 emit_pointer (w, start_symbol); /* initial_location */
 321                 if (end_symbol)
 322                         emit_symbol_diff (w, end_symbol, start_symbol, 0); /* address_range */
 323                 else {
 324                         g_assert (code_size);
 325                         emit_int32 (w, code_size);
 326                 }
 327         } else {
 328                 emit_pointer_value (w, code);
 329                 emit_int32 (w, code_size);
 330         }
 331 #if SIZEOF_VOID_P == 8
 332         /* Upper 32 bits of code size */
 333         emit_int32 (w, 0);
 334 #endif
 335
 336         l = unwind_ops;
 337         if (w->cie_program) {
 338                 // FIXME: Check that the ops really begin with the CIE program */
 339                 int i;
 340
 341                 for (i = 0; i < g_slist_length (w->cie_program); ++i)
 342                         l = l->next;
 343         }
 344
 345         /* Convert the list of MonoUnwindOps to the format used by DWARF */
 346         uw_info = mono_unwind_ops_encode (l, &uw_info_len);
 347         emit_bytes (w, uw_info, uw_info_len);
 348         g_free (uw_info);
 349
 350         emit_alignment (w, sizeof (gpointer));
 351         sprintf (symbol, ".Lfde%d_end", fde_index);
 352         emit_label (w, symbol);
 353 }
 354
 355 /* Abbrevations */
 356 #define ABBREV_COMPILE_UNIT 1
 357 #define ABBREV_SUBPROGRAM 2
 358 #define ABBREV_PARAM 3
 359 #define ABBREV_BASE_TYPE 4
 360 #define ABBREV_STRUCT_TYPE 5
 361 #define ABBREV_DATA_MEMBER 6
 362 #define ABBREV_TYPEDEF 7
 363 #define ABBREV_ENUM_TYPE 8
 364 #define ABBREV_ENUMERATOR 9
 365 #define ABBREV_NAMESPACE 10
 366 #define ABBREV_VARIABLE 11
 367 #define ABBREV_VARIABLE_LOCLIST 12
 368 #define ABBREV_POINTER_TYPE 13
 369 #define ABBREV_REFERENCE_TYPE 14
 370 #define ABBREV_PARAM_LOCLIST 15
 371 #define ABBREV_INHERITANCE 16
 372
 373 static int compile_unit_attr [] = {
 374         DW_AT_producer     ,DW_FORM_string,
 375     DW_AT_name         ,DW_FORM_string,
 376     DW_AT_comp_dir     ,DW_FORM_string,
 377         DW_AT_language     ,DW_FORM_data1,
 378     DW_AT_low_pc       ,DW_FORM_addr,
 379     DW_AT_high_pc      ,DW_FORM_addr,
 380         DW_AT_stmt_list    ,DW_FORM_data4
 381 };
 382
 383 static int subprogram_attr [] = {
 384         DW_AT_name         , DW_FORM_string,
 385     DW_AT_low_pc       , DW_FORM_addr,
 386     DW_AT_high_pc      , DW_FORM_addr,
 387         DW_AT_frame_base   , DW_FORM_block1
 388 };
 389
 390 static int param_attr [] = {
 391         DW_AT_name,     DW_FORM_string,
 392         DW_AT_type,     DW_FORM_ref4,
 393         DW_AT_location, DW_FORM_block1
 394 };
 395
 396 static int param_loclist_attr [] = {
 397         DW_AT_name,     DW_FORM_string,
 398         DW_AT_type,     DW_FORM_ref4,
 399         DW_AT_location, DW_FORM_data4
 400 };
 401
 402 static int base_type_attr [] = {
 403         DW_AT_byte_size,   DW_FORM_data1,
 404         DW_AT_encoding,    DW_FORM_data1,
 405         DW_AT_name,        DW_FORM_string
 406 };
 407
 408 static int struct_type_attr [] = {
 409         DW_AT_name,        DW_FORM_string,
 410         DW_AT_byte_size,   DW_FORM_udata,
 411 };
 412
 413 static int data_member_attr [] = {
 414         DW_AT_name,        DW_FORM_string,
 415         DW_AT_type,        DW_FORM_ref4,
 416         DW_AT_data_member_location, DW_FORM_block1
 417 };
 418
 419 static int typedef_attr [] = {
 420         DW_AT_name,        DW_FORM_string,
 421         DW_AT_type,        DW_FORM_ref4
 422 };
 423
 424 static int pointer_type_attr [] = {
 425         DW_AT_type,        DW_FORM_ref4,
 426 };
 427
 428 static int reference_type_attr [] = {
 429         DW_AT_type,        DW_FORM_ref4,
 430 };
 431
 432 static int enum_type_attr [] = {
 433         DW_AT_name,        DW_FORM_string,
 434         DW_AT_byte_size,   DW_FORM_udata,
 435         DW_AT_type,        DW_FORM_ref4,
 436 };
 437
 438 static int enumerator_attr [] = {
 439         DW_AT_name,        DW_FORM_string,
 440         DW_AT_const_value, DW_FORM_sdata,
 441 };
 442
 443 static int namespace_attr [] = {
 444         DW_AT_name,        DW_FORM_string,
 445 };
 446
 447 static int variable_attr [] = {
 448         DW_AT_name,     DW_FORM_string,
 449         DW_AT_type,     DW_FORM_ref4,
 450         DW_AT_location, DW_FORM_block1
 451 };
 452
 453 static int variable_loclist_attr [] = {
 454         DW_AT_name,     DW_FORM_string,
 455         DW_AT_type,     DW_FORM_ref4,
 456         DW_AT_location, DW_FORM_data4
 457 };
 458
 459 static int inheritance_attr [] = {
 460         DW_AT_type,        DW_FORM_ref4,
 461         DW_AT_data_member_location, DW_FORM_block1
 462 };
 463
 464 typedef struct DwarfBasicType {
 465         const char *die_name, *name;
 466         int type;
 467         int size;
 468         int encoding;
 469 } DwarfBasicType;
 470
 471 static DwarfBasicType basic_types [] = {
 472         { ".LDIE_I1", "sbyte", MONO_TYPE_I1, 1, DW_ATE_signed },
 473         { ".LDIE_U1", "byte", MONO_TYPE_U1, 1, DW_ATE_unsigned },
 474         { ".LDIE_I2", "short", MONO_TYPE_I2, 2, DW_ATE_signed },
 475         { ".LDIE_U2", "ushort", MONO_TYPE_U2, 2, DW_ATE_unsigned },
 476         { ".LDIE_I4", "int", MONO_TYPE_I4, 4, DW_ATE_signed },
 477         { ".LDIE_U4", "uint", MONO_TYPE_U4, 4, DW_ATE_unsigned },
 478         { ".LDIE_I8", "long", MONO_TYPE_I8, 8, DW_ATE_signed },
 479         { ".LDIE_U8", "ulong", MONO_TYPE_U8, 8, DW_ATE_unsigned },
 480         { ".LDIE_I", "intptr", MONO_TYPE_I, SIZEOF_VOID_P, DW_ATE_signed },
 481         { ".LDIE_U", "uintptr", MONO_TYPE_U, SIZEOF_VOID_P, DW_ATE_unsigned },
 482         { ".LDIE_R4", "float", MONO_TYPE_R4, 4, DW_ATE_float },
 483         { ".LDIE_R8", "double", MONO_TYPE_R8, 8, DW_ATE_float },
 484         { ".LDIE_BOOLEAN", "boolean", MONO_TYPE_BOOLEAN, 1, DW_ATE_boolean },
 485         { ".LDIE_CHAR", "char", MONO_TYPE_CHAR, 2, DW_ATE_unsigned_char },
 486         { ".LDIE_STRING", "string", MONO_TYPE_STRING, sizeof (gpointer), DW_ATE_address },
 487         { ".LDIE_OBJECT", "object", MONO_TYPE_OBJECT, sizeof (gpointer), DW_ATE_address },
 488         { ".LDIE_SZARRAY", "object", MONO_TYPE_SZARRAY, sizeof (gpointer), DW_ATE_address },
 489 };
 490
 491 /* Constants for encoding line number special opcodes */
 492 #define OPCODE_BASE 13
 493 #define LINE_BASE -5
 494 #define LINE_RANGE 14
 495
 496 /* Subsections of the .debug_line section */
 497 #define LINE_SUBSECTION_HEADER 1
 498 #define LINE_SUBSECTION_INCLUDES 2
 499 #define LINE_SUBSECTION_FILES 3
 500 #define LINE_SUBSECTION_DATA 4
 501 #define LINE_SUBSECTION_END 5
 502
 503 static int
 504 emit_line_number_file_name (MonoDwarfWriter *w, const char *name,
 505                                                         gint64 last_mod_time, gint64 file_size)
 506 {
 507         int index;
 508         int dir_index;
 509         char *basename = NULL;
 510
 511         if (!w->file_to_index)
 512                 w->file_to_index = g_hash_table_new (g_str_hash, g_str_equal);
 513
 514         index = GPOINTER_TO_UINT (g_hash_table_lookup (w->file_to_index, name));
 515         if (index > 0)
 516                 return index;
 517
 518         if (g_path_is_absolute (name)) {
 519                 char *dir = g_path_get_dirname (name);
 520
 521                 if (!w->dir_to_index)
 522                         w->dir_to_index = g_hash_table_new (g_str_hash, g_str_equal);
 523
 524                 dir_index = GPOINTER_TO_UINT (g_hash_table_lookup (w->dir_to_index, dir));
 525                 if (dir_index == 0) {
 526                         emit_section_change (w, ".debug_line", LINE_SUBSECTION_INCLUDES);
 527                         emit_string (w, dir);
 528
 529                         dir_index = ++ w->line_number_dir_index;
 530                         g_hash_table_insert (w->dir_to_index, g_strdup (dir), GUINT_TO_POINTER (dir_index));
 531                 }
 532
 533                 g_free (dir);
 534
 535                 basename = g_path_get_basename (name);
 536         } else {
 537                 dir_index = 0;
 538         }
 539
 540         emit_section_change (w, ".debug_line", LINE_SUBSECTION_FILES);
 541
 542         if (basename)
 543                 emit_string (w, basename);
 544         else
 545                 emit_string (w, name);
 546         emit_uleb128 (w, dir_index);
 547         emit_byte (w, 0);
 548         emit_byte (w, 0);
 549
 550         emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
 551
 552         if (basename)
 553                 g_free (basename);
 554
 555         index = ++ w->line_number_file_index;
 556         g_hash_table_insert (w->file_to_index, g_strdup (name), GUINT_TO_POINTER (index));
 557
 558         return index;
 559 }
 560
 561 static void
 562 emit_line_number_info_begin (MonoDwarfWriter *w)
 563 {
 564         /* Line number info header */
 565         /*
 566          * GAS seems to emit its own data to the end of the first subsection, so we use
 567          * subsections 1, 2 etc:
 568          * 1 - contains the header
 569          * 2 - contains the file names
 570          * 3 - contains the end of the header + the data
 571          * 4 - the end symbol
 572          */
 573         emit_section_change (w, ".debug_line", 0);
 574         emit_label (w, ".Ldebug_line_section_start");
 575         emit_section_change (w, ".debug_line", LINE_SUBSECTION_HEADER);
 576         emit_label (w, ".Ldebug_line_start");
 577         emit_symbol_diff (w, ".Ldebug_line_end", ".", -4); /* length */
 578         emit_int16 (w, 0x2); /* version */
 579         emit_symbol_diff (w, ".Ldebug_line_header_end", ".", -4); /* header_length */
 580         emit_byte (w, 1); /* minimum_instruction_length */
 581         emit_byte (w, 1); /* default_is_stmt */
 582         emit_byte (w, LINE_BASE); /* line_base */
 583         emit_byte (w, LINE_RANGE); /* line_range */
 584         emit_byte (w, OPCODE_BASE); /* opcode_base */
 585         emit_byte (w, 0); /* standard_opcode_lengths */
 586         emit_byte (w, 1);
 587         emit_byte (w, 1);
 588         emit_byte (w, 1);
 589         emit_byte (w, 1);
 590         emit_byte (w, 0);
 591         emit_byte (w, 0);
 592         emit_byte (w, 0);
 593         emit_byte (w, 1);
 594         emit_byte (w, 0);
 595         emit_byte (w, 0);
 596         emit_byte (w, 1);
 597
 598         /* Includes */
 599         emit_section_change (w, ".debug_line", LINE_SUBSECTION_INCLUDES);
 600
 601         /* End of Includes */
 602         emit_section_change (w, ".debug_line", LINE_SUBSECTION_FILES);
 603         emit_byte (w, 0);
 604
 605         /* Files */
 606         emit_line_number_file_name (w, "xdb.il", 0, 0);
 607
 608         /* End of Files */
 609         emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
 610         emit_byte (w, 0);
 611
 612         emit_label (w, ".Ldebug_line_header_end");
 613
 614         /* Emit this into a separate subsection so it gets placed at the end */
 615         emit_section_change (w, ".debug_line", LINE_SUBSECTION_END);
 616
 617         emit_byte (w, 0);
 618         emit_byte (w, 1);
 619         emit_byte (w, DW_LNE_end_sequence);
 620
 621         emit_label (w, ".Ldebug_line_end");
 622 }
 623
 624 void
 625 mono_dwarf_writer_emit_base_info (MonoDwarfWriter *w, GSList *base_unwind_program)
 626 {
 627         char *s, *build_info;
 628         int i;
 629
 630         w->cie_program = base_unwind_program;
 631
 632         emit_section_change (w, ".debug_abbrev", 0);
 633         emit_dwarf_abbrev (w, ABBREV_COMPILE_UNIT, DW_TAG_compile_unit, TRUE,
 634                                            compile_unit_attr, G_N_ELEMENTS (compile_unit_attr));
 635         emit_dwarf_abbrev (w, ABBREV_SUBPROGRAM, DW_TAG_subprogram, TRUE,
 636                                            subprogram_attr, G_N_ELEMENTS (subprogram_attr));
 637         emit_dwarf_abbrev (w, ABBREV_PARAM, DW_TAG_formal_parameter, FALSE,
 638                                            param_attr, G_N_ELEMENTS (param_attr));
 639         emit_dwarf_abbrev (w, ABBREV_PARAM_LOCLIST, DW_TAG_formal_parameter, FALSE,
 640                                            param_loclist_attr, G_N_ELEMENTS (param_loclist_attr));
 641         emit_dwarf_abbrev (w, ABBREV_BASE_TYPE, DW_TAG_base_type, FALSE,
 642                                            base_type_attr, G_N_ELEMENTS (base_type_attr));
 643         emit_dwarf_abbrev (w, ABBREV_STRUCT_TYPE, DW_TAG_class_type, TRUE,
 644                                            struct_type_attr, G_N_ELEMENTS (struct_type_attr));
 645         emit_dwarf_abbrev (w, ABBREV_DATA_MEMBER, DW_TAG_member, FALSE,
 646                                            data_member_attr, G_N_ELEMENTS (data_member_attr));
 647         emit_dwarf_abbrev (w, ABBREV_TYPEDEF, DW_TAG_typedef, FALSE,
 648                                            typedef_attr, G_N_ELEMENTS (typedef_attr));
 649         emit_dwarf_abbrev (w, ABBREV_ENUM_TYPE, DW_TAG_enumeration_type, TRUE,
 650                                            enum_type_attr, G_N_ELEMENTS (enum_type_attr));
 651         emit_dwarf_abbrev (w, ABBREV_ENUMERATOR, DW_TAG_enumerator, FALSE,
 652                                            enumerator_attr, G_N_ELEMENTS (enumerator_attr));
 653         emit_dwarf_abbrev (w, ABBREV_NAMESPACE, DW_TAG_namespace, TRUE,
 654                                            namespace_attr, G_N_ELEMENTS (namespace_attr));
 655         emit_dwarf_abbrev (w, ABBREV_VARIABLE, DW_TAG_variable, FALSE,
 656                                            variable_attr, G_N_ELEMENTS (variable_attr));
 657         emit_dwarf_abbrev (w, ABBREV_VARIABLE_LOCLIST, DW_TAG_variable, FALSE,
 658                                            variable_loclist_attr, G_N_ELEMENTS (variable_loclist_attr));
 659         emit_dwarf_abbrev (w, ABBREV_POINTER_TYPE, DW_TAG_pointer_type, FALSE,
 660                                            pointer_type_attr, G_N_ELEMENTS (pointer_type_attr));
 661         emit_dwarf_abbrev (w, ABBREV_REFERENCE_TYPE, DW_TAG_reference_type, FALSE,
 662                                            reference_type_attr, G_N_ELEMENTS (reference_type_attr));
 663         emit_dwarf_abbrev (w, ABBREV_INHERITANCE, DW_TAG_inheritance, FALSE,
 664                                            inheritance_attr, G_N_ELEMENTS (inheritance_attr));
 665         emit_byte (w, 0);
 666
 667         emit_section_change (w, ".debug_info", 0);
 668         emit_label (w, ".Ldebug_info_start");
 669         emit_symbol_diff (w, ".Ldebug_info_end", ".", -4); /* length */
 670         emit_int16 (w, 0x2); /* DWARF version 2 */
 671         emit_int32 (w, 0); /* .debug_abbrev offset */
 672         emit_byte (w, sizeof (gpointer)); /* address size */
 673
 674         /* Emit this into a separate section so it gets placed at the end */
 675         emit_section_change (w, ".debug_info", 1);
 676         emit_int32 (w, 0); /* close everything */
 677         emit_label (w, ".Ldebug_info_end");
 678         emit_section_change (w, ".debug_info", 0);
 679
 680         /* Compilation unit */
 681         emit_uleb128 (w, ABBREV_COMPILE_UNIT);
 682         build_info = mono_get_runtime_build_info ();
 683         s = g_strdup_printf ("Mono AOT Compiler %s", build_info);
 684         emit_string (w, s);
 685         g_free (build_info);
 686         g_free (s);
 687         emit_string (w, "JITted code");
 688         emit_string (w, "");
 689         emit_byte (w, DW_LANG_C);
 690         emit_pointer_value (w, 0);
 691         emit_pointer_value (w, 0);
 692         /* offset into .debug_line section */
 693         emit_symbol_diff (w, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
 694
 695         /* Base types */
 696         for (i = 0; i < G_N_ELEMENTS (basic_types); ++i) {
 697                 emit_label (w, basic_types [i].die_name);
 698                 emit_uleb128 (w, ABBREV_BASE_TYPE);
 699                 emit_byte (w, basic_types [i].size);
 700                 emit_byte (w, basic_types [i].encoding);
 701                 emit_string (w, basic_types [i].name);
 702         }
 703
 704         /* debug_loc section */
 705         emit_section_change (w, ".debug_loc", 0);
 706         emit_label (w, ".Ldebug_loc_start");
 707
 708         /* debug_line section */
 709         emit_line_number_info_begin (w);
 710
 711         emit_cie (w);
 712 }
 713
 714 static const char* emit_type (MonoDwarfWriter *w, MonoType *t);
 715
 716 /* Returns the local symbol pointing to the emitted debug info */
 717 static char*
 718 emit_class_dwarf_info (MonoDwarfWriter *w, MonoClass *klass, gboolean vtype)
 719 {
 720         char *die, *pointer_die, *reference_die;
 721         char *full_name, *p;
 722         gpointer iter;
 723         MonoClassField *field;
 724         const char *fdie;
 725         int k;
 726         gboolean emit_namespace = FALSE;
 727         GHashTable *cache;
 728
 729         // FIXME: Appdomains
 730         if (!w->class_to_die)
 731                 w->class_to_die = g_hash_table_new (NULL, NULL);
 732         if (!w->class_to_vtype_die)
 733                 w->class_to_vtype_die = g_hash_table_new (NULL, NULL);
 734         if (!w->class_to_pointer_die)
 735                 w->class_to_pointer_die = g_hash_table_new (NULL, NULL);
 736         if (!w->class_to_reference_die)
 737                 w->class_to_reference_die = g_hash_table_new (NULL, NULL);
 738
 739         if (vtype)
 740                 cache = w->class_to_vtype_die;
 741         else
 742                 cache = w->class_to_die;
 743
 744         die = g_hash_table_lookup (cache, klass);
 745         if (die)
 746                 return die;
 747
 748         if (!((klass->byval_arg.type == MONO_TYPE_CLASS) || (klass->byval_arg.type == MONO_TYPE_OBJECT) || klass->byval_arg.type == MONO_TYPE_GENERICINST || klass->enumtype || (klass->byval_arg.type == MONO_TYPE_VALUETYPE && vtype)))
 749                 return NULL;
 750
 751         /*
 752          * FIXME: gdb can't handle namespaces in languages it doesn't know about.
 753          */
 754         /*
 755         if (klass->name_space && klass->name_space [0] != '\0')
 756                 emit_namespace = TRUE;
 757         */
 758         if (emit_namespace) {
 759                 emit_uleb128 (w, ABBREV_NAMESPACE);
 760                 emit_string (w, klass->name_space);
 761         }
 762
 763         full_name = g_strdup_printf ("%s%s%s", klass->name_space, klass->name_space ? "." : "", klass->name);
 764         /*
 765          * gdb doesn't support namespaces for non-C++ dwarf objects, so use _
 766          * to separate components.
 767          */
 768         for (p = full_name; *p; p ++)
 769                 if (*p == '.')
 770                         *p = '_';
 771
 772         die = g_strdup_printf (".LTDIE_%d", w->tdie_index);
 773         pointer_die = g_strdup_printf (".LTDIE_%d_POINTER", w->tdie_index);
 774         reference_die = g_strdup_printf (".LTDIE_%d_REFERENCE", w->tdie_index);
 775         w->tdie_index ++;
 776
 777         g_hash_table_insert (w->class_to_pointer_die, klass, pointer_die);
 778         g_hash_table_insert (w->class_to_reference_die, klass, reference_die);
 779         g_hash_table_insert (cache, klass, die);
 780
 781         if (klass->enumtype) {
 782                 int size = mono_class_value_size (mono_class_from_mono_type (mono_class_enum_basetype (klass)), NULL);
 783
 784                 emit_label (w, die);
 785
 786                 emit_uleb128 (w, ABBREV_ENUM_TYPE);
 787                 emit_string (w, full_name);
 788                 emit_uleb128 (w, size);
 789                 for (k = 0; k < G_N_ELEMENTS (basic_types); ++k)
 790                         if (basic_types [k].type == mono_class_enum_basetype (klass)->type)
 791                                 break;
 792                 g_assert (k < G_N_ELEMENTS (basic_types));
 793                 emit_symbol_diff (w, basic_types [k].die_name, ".Ldebug_info_start", 0);
 794
 795                 /* Emit enum values */
 796                 iter = NULL;
 797                 while ((field = mono_class_get_fields (klass, &iter))) {
 798                         const char *p;
 799                         int len;
 800                         MonoTypeEnum def_type;
 801
 802                         if (strcmp ("value__", mono_field_get_name (field)) == 0)
 803                                 continue;
 804                         if (mono_field_is_deleted (field))
 805                                 continue;
 806
 807                         emit_uleb128 (w, ABBREV_ENUMERATOR);
 808                         emit_string (w, mono_field_get_name (field));
 809
 810                         p = mono_class_get_field_default_value (field, &def_type);
 811                         len = mono_metadata_decode_blob_size (p, &p);
 812                         switch (mono_class_enum_basetype (klass)->type) {
 813                         case MONO_TYPE_U1:
 814                         case MONO_TYPE_I1:
 815                         case MONO_TYPE_BOOLEAN:
 816                                 emit_sleb128 (w, *p);
 817                                 break;
 818                         case MONO_TYPE_U2:
 819                         case MONO_TYPE_I2:
 820                         case MONO_TYPE_CHAR:
 821                                 emit_sleb128 (w, read16 (p));
 822                                 break;
 823                         case MONO_TYPE_U4:
 824                         case MONO_TYPE_I4:
 825                                 emit_sleb128 (w, read32 (p));
 826                                 break;
 827                         case MONO_TYPE_U8:
 828                         case MONO_TYPE_I8:
 829                                 emit_sleb128 (w, read64 (p));
 830                                 break;
 831                         case MONO_TYPE_I:
 832                         case MONO_TYPE_U:
 833 #if SIZEOF_VOID_P == 8
 834                                 emit_sleb128 (w, read64 (p));
 835 #else
 836                                 emit_sleb128 (w, read32 (p));
 837 #endif
 838                                 break;
 839                         default:
 840                                 g_assert_not_reached ();
 841                         }
 842                 }
 843         } else {
 844                 guint8 buf [128];
 845                 guint8 *p;
 846                 char *parent_die;
 847
 848                 if (klass->parent)
 849                         parent_die = emit_class_dwarf_info (w, klass->parent, FALSE);
 850                 else
 851                         parent_die = NULL;
 852
 853                 /* Emit field types */
 854                 iter = NULL;
 855                 while ((field = mono_class_get_fields (klass, &iter))) {
 856                         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
 857                                 continue;
 858
 859                         emit_type (w, field->type);
 860                 }
 861
 862                 emit_label (w, die);
 863
 864                 emit_uleb128 (w, ABBREV_STRUCT_TYPE);
 865                 emit_string (w, full_name);
 866                 emit_uleb128 (w, klass->instance_size);
 867
 868                 if (parent_die) {
 869                         emit_uleb128 (w, ABBREV_INHERITANCE);
 870                         emit_symbol_diff (w, parent_die, ".Ldebug_info_start", 0);
 871
 872                         p = buf;
 873                         *p ++= DW_OP_plus_uconst;
 874                         encode_uleb128 (0, p, &p);
 875                         emit_byte (w, p - buf);
 876                         emit_bytes (w, buf, p - buf);
 877                 }
 878
 879                 /* Emit fields */
 880                 iter = NULL;
 881                 while ((field = mono_class_get_fields (klass, &iter))) {
 882                         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
 883                                 continue;
 884
 885                         fdie = emit_type (w, field->type);
 886                         if (fdie) {
 887                                 emit_uleb128 (w, ABBREV_DATA_MEMBER);
 888                                 emit_string (w, field->name);
 889                                 emit_symbol_diff (w, fdie, ".Ldebug_info_start", 0);
 890                                 /* location */
 891                                 p = buf;
 892                                 *p ++= DW_OP_plus_uconst;
 893                                 if (klass->valuetype && vtype)
 894                                         encode_uleb128 (field->offset - sizeof (MonoObject), p, &p);
 895                                 else
 896                                         encode_uleb128 (field->offset, p, &p);
 897
 898                                 emit_byte (w, p - buf);
 899                                 emit_bytes (w, buf, p - buf);
 900                         }
 901                 }
 902         }
 903
 904         /* Type end */
 905         emit_uleb128 (w, 0x0);
 906
 907         /* Add a typedef, so we can reference the type without a 'struct' in gdb */
 908         emit_uleb128 (w, ABBREV_TYPEDEF);
 909         emit_string (w, full_name);
 910         emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
 911
 912         /* Add a pointer type */
 913         emit_label (w, pointer_die);
 914
 915         emit_uleb128 (w, ABBREV_POINTER_TYPE);
 916         emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
 917
 918         /* Add a reference type */
 919         emit_label (w, reference_die);
 920
 921         emit_uleb128 (w, ABBREV_REFERENCE_TYPE);
 922         emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
 923
 924         g_free (full_name);
 925
 926         if (emit_namespace) {
 927                 /* Namespace end */
 928                 emit_uleb128 (w, 0x0);
 929         }
 930
 931         return die;
 932 }
 933
 934 static const char*
 935 emit_type (MonoDwarfWriter *w, MonoType *t)
 936 {
 937         MonoClass *klass = mono_class_from_mono_type (t);
 938         int j;
 939         const char *tdie;
 940
 941         if (t->byref) {
 942                 if (t->type == MONO_TYPE_VALUETYPE) {
 943                         tdie = emit_class_dwarf_info (w, klass, TRUE);
 944                         if (tdie)
 945                                 return g_hash_table_lookup (w->class_to_pointer_die, klass);
 946                 }
 947                 else {
 948                         tdie = emit_class_dwarf_info (w, klass, FALSE);
 949                         /* Should return a pointer type to a reference */
 950                 }
 951                 // FIXME:
 952                 t = &mono_defaults.int_class->byval_arg;
 953         }
 954         for (j = 0; j < G_N_ELEMENTS (basic_types); ++j)
 955                 if (basic_types [j].type == t->type)
 956                         break;
 957         if (j < G_N_ELEMENTS (basic_types))
 958                 tdie = basic_types [j].die_name;
 959         else {
 960                 switch (t->type) {
 961                 case MONO_TYPE_CLASS:
 962                         emit_class_dwarf_info (w, klass, FALSE);
 963                         tdie = g_hash_table_lookup (w->class_to_reference_die, klass);
 964                         //tdie = ".LDIE_OBJECT";
 965                         break;
 966                 case MONO_TYPE_ARRAY:
 967                         tdie = ".LDIE_OBJECT";
 968                         break;
 969                 case MONO_TYPE_VALUETYPE:
 970                         if (klass->enumtype)
 971                                 tdie = emit_class_dwarf_info (w, klass, FALSE);
 972                         else
 973                                 tdie = ".LDIE_I4";
 974                         break;
 975                 case MONO_TYPE_GENERICINST:
 976                         if (!MONO_TYPE_ISSTRUCT (t)) {
 977                                 emit_class_dwarf_info (w, klass, FALSE);
 978                                 tdie = g_hash_table_lookup (w->class_to_reference_die, klass);
 979                         } else {
 980                                 tdie = ".LDIE_I4";
 981                         }
 982                         break;
 983                 default:
 984                         tdie = ".LDIE_I4";
 985                         break;
 986                 }
 987         }
 988
 989         return tdie;
 990 }
 991
 992 static void
 993 emit_var_type (MonoDwarfWriter *w, MonoType *t)
 994 {
 995         const char *tdie;
 996
 997         tdie = emit_type (w, t);
 998
 999         emit_symbol_diff (w, tdie, ".Ldebug_info_start", 0);
1000 }
1001
1002 static void
1003 encode_var_location (MonoDwarfWriter *w, MonoInst *ins, guint8 *p, guint8 **endp)
1004 {
1005         /* location */
1006         /* FIXME: This needs a location list, since the args can go from reg->stack */
1007         if (!ins || ins->flags & MONO_INST_IS_DEAD) {
1008                 /* gdb treats this as optimized out */
1009         } else if (ins->opcode == OP_REGVAR) {
1010                 *p = DW_OP_reg0 + mono_hw_reg_to_dwarf_reg (ins->dreg);
1011                 p ++;
1012         } else if (ins->opcode == OP_REGOFFSET) {
1013                 *p ++= DW_OP_breg0 + mono_hw_reg_to_dwarf_reg (ins->inst_basereg);
1014                 encode_sleb128 (ins->inst_offset, p, &p);
1015         } else {
1016                 // FIXME:
1017                 *p ++ = DW_OP_reg0;
1018         }
1019
1020         *endp = p;
1021 }
1022
1023 static void
1024 emit_loclist (MonoDwarfWriter *w, MonoInst *ins,
1025                           guint8 *loclist_begin_addr, guint8 *loclist_end_addr,
1026                           guint8 *expr, guint32 expr_len)
1027 {
1028         char label [128];
1029
1030         emit_push_section (w, ".debug_loc", 0);
1031         sprintf (label, ".Lloclist_%d", w->loclist_index ++ );
1032         emit_label (w, label);
1033
1034         emit_pointer_value (w, loclist_begin_addr);
1035         emit_pointer_value (w, loclist_end_addr);
1036         emit_byte (w, expr_len % 256);
1037         emit_byte (w, expr_len / 256);
1038         emit_bytes (w, expr, expr_len);
1039
1040         emit_pointer_value (w, NULL);
1041         emit_pointer_value (w, NULL);
1042
1043         emit_pop_section (w);
1044         emit_symbol_diff (w, label, ".Ldebug_loc_start", 0);
1045 }
1046
1047 /*
1048  * MonoDisHelper->tokener doesn't take an IP argument, and we can't add one since
1049  * it is a public header.
1050  */
1051 static const guint8 *token_handler_ip;
1052
1053 static char*
1054 token_handler (MonoDisHelper *dh, MonoMethod *method, guint32 token)
1055 {
1056         char *res, *desc;
1057         MonoMethod *cmethod;
1058         MonoClass *klass;
1059         MonoClassField *field;
1060         gpointer data = NULL;
1061
1062         if (method->wrapper_type)
1063                 data = mono_method_get_wrapper_data (method, token);
1064
1065         switch (*token_handler_ip) {
1066         case CEE_ISINST:
1067         case CEE_CASTCLASS:
1068         case CEE_LDELEMA:
1069                 if (method->wrapper_type)
1070                         klass = data;
1071                 else
1072                         klass = mono_class_get_full (method->klass->image, token, NULL);
1073                 res = g_strdup_printf ("<%s>", klass->name);
1074                 break;
1075         case CEE_NEWOBJ:
1076         case CEE_CALL:
1077         case CEE_CALLVIRT:
1078                 if (method->wrapper_type)
1079                         cmethod = data;
1080                 else
1081                         cmethod = mono_get_method_full (method->klass->image, token, NULL, NULL);
1082                 desc = mono_method_full_name (cmethod, TRUE);
1083                 res = g_strdup_printf ("<%s>", desc);
1084                 g_free (desc);
1085                 break;
1086         case CEE_CALLI:
1087                 if (method->wrapper_type) {
1088                         desc = mono_signature_get_desc (data, FALSE);
1089                         res = g_strdup_printf ("<%s>", desc);
1090                         g_free (desc);
1091                 } else {
1092                         res = g_strdup_printf ("<0x%08x>", token);
1093                 }
1094                 break;
1095         case CEE_LDFLD:
1096         case CEE_LDSFLD:
1097         case CEE_STFLD:
1098         case CEE_STSFLD:
1099                 if (method->wrapper_type)
1100                         field = data;
1101                 else
1102                         field = mono_field_from_token (method->klass->image, token, &klass, NULL);
1103                 desc = mono_field_full_name (field);
1104                 res = g_strdup_printf ("<%s>", desc);
1105                 g_free (desc);
1106                 break;
1107         default:
1108                 res = g_strdup_printf ("<0x%08x>", token);
1109                 break;
1110         }
1111
1112         return res;
1113 }
1114
1115 /*
1116  * disasm_ins:
1117  *
1118  *   Produce a disassembled form of the IL instruction at IP. This is an extension
1119  * of mono_disasm_code_one () which can disasm tokens, handle wrapper methods, and
1120  * CEE_MONO_ opcodes.
1121  */
1122 static char*
1123 disasm_ins (MonoMethod *method, const guchar *ip, const guint8 **endip)
1124 {
1125         char *dis;
1126         MonoDisHelper dh;
1127         MonoMethodHeader *header = mono_method_get_header (method);
1128
1129         memset (&dh, 0, sizeof (dh));
1130         dh.newline = "";
1131         dh.label_format = "IL_%04x: ";
1132         dh.label_target = "IL_%04x";
1133         dh.tokener = token_handler;
1134
1135         token_handler_ip = ip;
1136         if (*ip == MONO_CUSTOM_PREFIX) {
1137                 guint32 token;
1138                 gpointer data;
1139
1140                 switch (ip [1]) {
1141                 case CEE_MONO_ICALL: {
1142                         MonoJitICallInfo *info;
1143
1144                         token = read32 (ip + 2);
1145                         data = mono_method_get_wrapper_data (method, token);
1146                         info = mono_find_jit_icall_by_addr (data);
1147                         g_assert (info);
1148
1149                         dis = g_strdup_printf ("IL_%04x: mono_icall <%s>", (int)(ip - header->code), info->name);
1150                         ip += 6;
1151                         break;
1152                 }
1153                 case CEE_MONO_CLASSCONST: {
1154                         token = read32 (ip + 2);
1155                         data = mono_method_get_wrapper_data (method, token);
1156
1157                         dis = g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip - header->code), ((MonoClass*)data)->name);
1158                         ip += 6;
1159                         break;
1160                 }
1161                 default:
1162                         dis = mono_disasm_code_one (&dh, method, ip, &ip);
1163                 }
1164         } else {
1165                 dis = mono_disasm_code_one (&dh, method, ip, &ip);
1166         }
1167         token_handler_ip = NULL;
1168
1169         *endip = ip;
1170         return dis;
1171 }
1172
1173 static gint32
1174 il_offset_from_address (MonoMethod *method, MonoDebugMethodJitInfo *jit,
1175                                                 guint32 native_offset)
1176 {
1177         int i;
1178
1179         if (!jit->line_numbers)
1180                 return -1;
1181
1182         for (i = jit->num_line_numbers - 1; i >= 0; i--) {
1183                 MonoDebugLineNumberEntry lne = jit->line_numbers [i];
1184
1185                 if (lne.native_offset <= native_offset)
1186                         return lne.il_offset;
1187         }
1188
1189         return -1;
1190 }
1191
1192 static int max_special_addr_diff = 0;
1193
1194 static inline void
1195 emit_advance_op (MonoDwarfWriter *w, int line_diff, int addr_diff)
1196 {
1197         gint64 opcode = 0;
1198
1199         /* Use a special opcode if possible */
1200         if (line_diff - LINE_BASE >= 0 && line_diff - LINE_BASE < LINE_RANGE) {
1201                 if (max_special_addr_diff == 0)
1202                         max_special_addr_diff = (255 - OPCODE_BASE) / LINE_RANGE;
1203
1204                 if (addr_diff > max_special_addr_diff && (addr_diff < 2 * max_special_addr_diff)) {
1205                         emit_byte (w, DW_LNS_const_add_pc);
1206                         addr_diff -= max_special_addr_diff;
1207                 }
1208
1209                 opcode = (line_diff - LINE_BASE) + (LINE_RANGE * addr_diff) + OPCODE_BASE;
1210                 if (opcode > 255)
1211                         opcode = 0;
1212         }
1213
1214         if (opcode != 0) {
1215                 emit_byte (w, opcode);
1216         } else {
1217                 emit_byte (w, DW_LNS_advance_line);
1218                 emit_sleb128 (w, line_diff);
1219                 emit_byte (w, DW_LNS_advance_pc);
1220                 emit_sleb128 (w, addr_diff);
1221                 emit_byte (w, DW_LNS_copy);
1222         }
1223 }
1224
1225 static gint
1226 compare_lne (MonoDebugLineNumberEntry *a, MonoDebugLineNumberEntry *b)
1227 {
1228         if (a->native_offset == b->native_offset)
1229                 return a->il_offset - b->il_offset;
1230         else
1231                 return a->native_offset - b->native_offset;
1232 }
1233
1234 static void
1235 emit_line_number_info (MonoDwarfWriter *w, MonoMethod *method,
1236                                            char *start_symbol, char *end_symbol,
1237                                            guint8 *code, guint32 code_size,
1238                                            MonoDebugMethodJitInfo *debug_info)
1239 {
1240         guint32 prev_line = 0;
1241         guint32 prev_native_offset = 0;
1242         int i, file_index, il_offset, prev_il_offset;
1243         gboolean first = TRUE;
1244         MonoDebugSourceLocation *loc;
1245         char *prev_file_name = NULL;
1246         MonoMethodHeader *header = mono_method_get_header (method);
1247         MonoDebugMethodInfo *minfo;
1248         GArray *ln_array;
1249         int *native_to_il_offset = NULL;
1250
1251         minfo = mono_debug_lookup_method (method);
1252
1253         /* Compute the native->IL offset mapping */
1254
1255         g_assert (code_size);
1256
1257 #ifndef _EGLIB_MAJOR
1258         ln_array = g_array_sized_new (FALSE, FALSE, sizeof (MonoDebugLineNumberEntry),
1259                                                                   debug_info->num_line_numbers);
1260         g_array_append_vals (ln_array, debug_info->line_numbers, debug_info->num_line_numbers);
1261         g_array_sort (ln_array, (GCompareFunc)compare_lne);
1262         native_to_il_offset = g_new0 (int, code_size + 1);
1263
1264         for (i = 0; i < debug_info->num_line_numbers; ++i) {
1265                 int j;
1266                 MonoDebugLineNumberEntry lne = g_array_index (ln_array, MonoDebugLineNumberEntry, i);
1267
1268                 if (i == 0) {
1269                         for (j = 0; j < lne.native_offset; ++j)
1270                                 native_to_il_offset [j] = -1;
1271                 }
1272
1273                 if (i < debug_info->num_line_numbers - 1) {
1274                         MonoDebugLineNumberEntry lne_next = g_array_index (ln_array, MonoDebugLineNumberEntry, i + 1);
1275
1276                         for (j = lne.native_offset; j < lne_next.native_offset; ++j)
1277                                 native_to_il_offset [j] = lne.il_offset;
1278                 } else {
1279                         for (j = lne.native_offset; j < code_size; ++j)
1280                                 native_to_il_offset [j] = lne.il_offset;
1281                 }
1282         }
1283         g_array_free (ln_array, TRUE);
1284 #endif
1285
1286         prev_line = 1;
1287         prev_il_offset = -1;
1288
1289         for (i = 0; i < code_size; ++i) {
1290                 if (!minfo)
1291                         continue;
1292
1293                 if (!debug_info->line_numbers)
1294                         continue;
1295
1296                 if (native_to_il_offset)
1297                         il_offset = native_to_il_offset [i];
1298                 else
1299                         il_offset = il_offset_from_address (method, debug_info, i);
1300                 /*
1301                 il_offset = il_offset_from_address (method, debug_info, i);
1302
1303                 g_assert (il_offset == native_to_il_offset [i]);
1304                 */
1305
1306                 il_offset = native_to_il_offset [i];
1307                 if (il_offset < 0)
1308                         continue;
1309
1310                 if (il_offset == prev_il_offset)
1311                         continue;
1312
1313                 prev_il_offset = il_offset;
1314
1315                 loc = mono_debug_symfile_lookup_location (minfo, il_offset);
1316
1317                 if (loc) {
1318                         int line_diff = (gint32)loc->row - (gint32)prev_line;
1319                         int addr_diff = i - prev_native_offset;
1320
1321                         if (first) {
1322                                 emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
1323
1324                                 emit_byte (w, 0);
1325                                 emit_byte (w, sizeof (gpointer) + 1);
1326                                 emit_byte (w, DW_LNE_set_address);
1327                                 if (start_symbol)
1328                                         emit_pointer_unaligned (w, start_symbol);
1329                                 else
1330                                         emit_pointer_value (w, code);
1331
1332                                 /*
1333                                  * The prolog+initlocals region does not have a line number, this
1334                                  * makes them belong to the first line of the method.
1335                                  */
1336                                 emit_byte (w, DW_LNS_advance_line);
1337                                 emit_sleb128 (w, (gint32)loc->row - (gint32)prev_line);
1338                                 prev_line = loc->row;
1339                         }
1340
1341                         if (loc->row != prev_line) {
1342                                 if (!prev_file_name || strcmp (loc->source_file, prev_file_name) != 0) {
1343                                         /* Add an entry to the file table */
1344                                         /* FIXME: Avoid duplicates */
1345                                         file_index = emit_line_number_file_name (w, loc->source_file, 0, 0);
1346                                         g_free (prev_file_name);
1347                                         prev_file_name = g_strdup (loc->source_file);
1348
1349                                         emit_byte (w, DW_LNS_set_file);
1350                                         emit_uleb128 (w, file_index);
1351                                         emit_byte (w, DW_LNS_copy);
1352                                 }
1353
1354                                 //printf ("X: %p(+0x%x) %d %s:%d(+%d)\n", code + i, addr_diff, loc->il_offset, loc->source_file, loc->row, line_diff);
1355
1356                                 emit_advance_op (w, line_diff, addr_diff);
1357
1358                                 prev_line = loc->row;
1359                                 prev_native_offset = i;
1360                         }
1361
1362                         first = FALSE;
1363                         g_free (loc);
1364                 }
1365         }
1366
1367         g_free (prev_file_name);
1368
1369         if (!first) {
1370                 emit_byte (w, DW_LNS_advance_pc);
1371                 emit_sleb128 (w, code_size - prev_native_offset);
1372                 emit_byte (w, DW_LNS_copy);
1373
1374                 emit_byte (w, 0);
1375                 emit_byte (w, 1);
1376                 emit_byte (w, DW_LNE_end_sequence);
1377         } else if (!start_symbol) {
1378                 /* No debug info, XDEBUG mode */
1379                 char *name, *dis;
1380                 const guint8 *ip = header->code;
1381                 int prev_line, prev_native_offset;
1382                 int *il_to_line;
1383
1384                 /*
1385                  * Emit the IL code into a temporary file and emit line number info
1386                  * referencing that file.
1387                  */
1388
1389                 name = mono_method_full_name (method, TRUE);
1390                 fprintf (w->il_file, "// %s\n", name);
1391                 w->il_file_line_index ++;
1392                 g_free (name);
1393
1394                 il_to_line = g_new0 (int, header->code_size);
1395
1396                 emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
1397                 emit_byte (w, 0);
1398                 emit_byte (w, sizeof (gpointer) + 1);
1399                 emit_byte (w, DW_LNE_set_address);
1400                 emit_pointer_value (w, code);
1401
1402                 // FIXME: Optimize this
1403                 while (ip < header->code + header->code_size) {
1404                         int il_offset = ip - header->code;
1405
1406                         /* Emit IL */
1407                         w->il_file_line_index ++;
1408
1409                         dis = disasm_ins (method, ip, &ip);
1410                         fprintf (w->il_file, "%s\n", dis);
1411                         g_free (dis);
1412
1413                         il_to_line [il_offset] = w->il_file_line_index;
1414                 }
1415
1416                 /* Emit line number info */
1417                 prev_line = 1;
1418                 prev_native_offset = 0;
1419                 for (i = 0; i < debug_info->num_line_numbers; ++i) {
1420                         MonoDebugLineNumberEntry *lne = &debug_info->line_numbers [i];
1421                         int line;
1422
1423                         if (lne->il_offset >= header->code_size)
1424                                 continue;
1425                         line = il_to_line [lne->il_offset];
1426                         if (!line) {
1427                                 /*
1428                                  * This seems to happen randomly, it looks like il_offset points
1429                                  * into the middle of an instruction.
1430                                  */
1431                                 continue;
1432                                 /*
1433                                 printf ("%s\n", mono_method_full_name (method, TRUE));
1434                                 printf ("%d %d\n", lne->il_offset, header->code_size);
1435                                 g_assert (line);
1436                                 */
1437                         }
1438
1439                         if (line - prev_line != 0) {
1440                                 emit_advance_op (w, line - prev_line, (gint32)lne->native_offset - prev_native_offset);
1441
1442                                 prev_line = line;
1443                                 prev_native_offset = lne->native_offset;
1444                         }
1445                 }
1446
1447                 emit_byte (w, DW_LNS_advance_pc);
1448                 emit_sleb128 (w, code_size - prev_native_offset);
1449                 emit_byte (w, DW_LNS_copy);
1450
1451                 emit_byte (w, 0);
1452                 emit_byte (w, 1);
1453                 emit_byte (w, DW_LNE_end_sequence);
1454
1455                 fflush (w->il_file);
1456                 g_free (il_to_line);
1457         }
1458 }
1459
1460 static MonoMethodVar*
1461 find_vmv (MonoCompile *cfg, MonoInst *ins)
1462 {
1463         int j;
1464
1465         if (cfg->varinfo) {
1466                 for (j = 0; j < cfg->num_varinfo; ++j) {
1467                         if (cfg->varinfo [j] == ins)
1468                                 break;
1469                 }
1470
1471                 if (j < cfg->num_varinfo) {
1472                         return MONO_VARINFO (cfg, j);
1473                 }
1474         }
1475
1476         return NULL;
1477 }
1478
1479 void
1480 mono_dwarf_writer_emit_method (MonoDwarfWriter *w, MonoCompile *cfg, MonoMethod *method, char *start_symbol, char *end_symbol, guint8 *code, guint32 code_size, MonoInst **args, MonoInst **locals, GSList *unwind_info, MonoDebugMethodJitInfo *debug_info)
1481 {
1482         char *name;
1483         MonoMethodSignature *sig;
1484         MonoMethodHeader *header;
1485         char **names, **tdies, **local_tdies;
1486         char **local_names;
1487         int *local_indexes;
1488         int i, num_locals;
1489         guint8 buf [128];
1490         guint8 *p;
1491
1492         emit_section_change (w, ".debug_info", 0);
1493
1494         sig = mono_method_signature (method);
1495         header = mono_method_get_header (method);
1496
1497         /* Parameter types */
1498         tdies = g_new0 (char *, sig->param_count + sig->hasthis);
1499         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
1500                 MonoType *t;
1501
1502                 if (i == 0 && sig->hasthis) {
1503                         if (method->klass->valuetype)
1504                                 t = &method->klass->this_arg;
1505                         else
1506                                 t = &method->klass->byval_arg;
1507                 } else {
1508                         t = sig->params [i - sig->hasthis];
1509                 }
1510
1511                 emit_type (w, t);
1512         }
1513
1514         /* Local types */
1515         local_tdies = g_new0 (char *, header->num_locals);
1516         for (i = 0; i < header->num_locals; ++i) {
1517                 emit_type (w, header->locals [i]);
1518         }
1519
1520         /* Subprogram */
1521         names = g_new0 (char *, sig->param_count);
1522         mono_method_get_param_names (method, (const char **) names);
1523
1524         emit_uleb128 (w, ABBREV_SUBPROGRAM);
1525         name = mono_method_full_name (method, FALSE);
1526         emit_string (w, name);
1527         g_free (name);
1528         if (start_symbol) {
1529                 emit_pointer_unaligned (w, start_symbol);
1530                 emit_pointer_unaligned (w, end_symbol);
1531         } else {
1532                 emit_pointer_value (w, code);
1533                 emit_pointer_value (w, code + code_size);
1534         }
1535         /* frame_base */
1536         emit_byte (w, 2);
1537         emit_byte (w, DW_OP_breg6);
1538         emit_byte (w, 16);
1539
1540         /* Parameters */
1541         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
1542                 MonoInst *arg = args ? args [i] : NULL;
1543                 MonoType *t;
1544                 const char *pname;
1545                 char pname_buf [128];
1546                 MonoMethodVar *vmv = NULL;
1547                 gboolean need_loclist = FALSE;
1548
1549                 vmv = find_vmv (cfg, arg);
1550                 if (code && vmv && (vmv->live_range_start || vmv->live_range_end))
1551                         need_loclist = TRUE;
1552
1553                 if (i == 0 && sig->hasthis) {
1554                         if (method->klass->valuetype)
1555                                 t = &method->klass->this_arg;
1556                         else
1557                                 t = &method->klass->byval_arg;
1558                         pname = "this";
1559                 } else {
1560                         t = sig->params [i - sig->hasthis];
1561                         pname = names [i - sig->hasthis];
1562                 }
1563
1564                 emit_uleb128 (w, need_loclist ? ABBREV_PARAM_LOCLIST : ABBREV_PARAM);
1565                 /* name */
1566                 if (pname[0] == '\0') {
1567                         sprintf (pname_buf, "param%d", i - sig->hasthis);
1568                         pname = pname_buf;
1569                 }
1570                 emit_string (w, pname);
1571                 /* type */
1572                 if (!arg || arg->flags & MONO_INST_IS_DEAD)
1573                         emit_var_type (w, &mono_defaults.int32_class->byval_arg);
1574                 else
1575                         emit_var_type (w, t);
1576
1577                 p = buf;
1578                 encode_var_location (w, arg, p, &p);
1579                 if (need_loclist) {
1580                         vmv->live_range_start = 0;
1581                         if (vmv->live_range_end == 0)
1582                                 /* FIXME: Uses made in calls are not recorded */
1583                                 vmv->live_range_end = code_size;
1584                         emit_loclist (w, arg, code + vmv->live_range_start, code + vmv->live_range_end, buf, p - buf);
1585                 } else {
1586                         emit_byte (w, p - buf);
1587                         emit_bytes (w, buf, p - buf);
1588                 }
1589         }
1590         g_free (names);
1591
1592         /* Locals */
1593         num_locals = mono_debug_lookup_locals (method, &local_names, &local_indexes);
1594
1595         for (i = 0; i < header->num_locals; ++i) {
1596                 MonoInst *ins = locals [i];
1597                 char name_buf [128];
1598                 int j;
1599                 MonoMethodVar *vmv = NULL;
1600                 gboolean need_loclist = FALSE;
1601
1602                 /* ins->dreg no longer contains the original vreg */
1603                 vmv = find_vmv (cfg, ins);
1604                 if (code && vmv) {
1605                         if (vmv->live_range_start) {
1606                                 /* This variable has a precise live range */
1607                                 need_loclist = TRUE;
1608                         }
1609                 }
1610
1611                 emit_uleb128 (w, need_loclist ? ABBREV_VARIABLE_LOCLIST : ABBREV_VARIABLE);
1612                 /* name */
1613                 for (j = 0; j < num_locals; ++j)
1614                         if (local_indexes [j] == i)
1615                                 break;
1616                 if (j < num_locals) {
1617                         emit_string (w, local_names [j]);
1618                 } else {
1619                         sprintf (name_buf, "V_%d", i);
1620                         emit_string (w, name_buf);
1621                 }
1622                 /* type */
1623                 if (!ins || ins->flags & MONO_INST_IS_DEAD)
1624                         emit_var_type (w, &mono_defaults.int32_class->byval_arg);
1625                 else
1626                         emit_var_type (w, header->locals [i]);
1627
1628                 p = buf;
1629                 encode_var_location (w, ins, p, &p);
1630
1631                 if (need_loclist) {
1632                         if (vmv->live_range_end == 0)
1633                                 /* FIXME: Uses made in calls are not recorded */
1634                                 vmv->live_range_end = code_size;
1635                         emit_loclist (w, ins, code + vmv->live_range_start, code + vmv->live_range_end, buf, p - buf);
1636                 } else {
1637                         emit_byte (w, p - buf);
1638                         emit_bytes (w, buf, p - buf);
1639                 }
1640         }
1641
1642         g_free (local_names);
1643         g_free (local_indexes);
1644
1645         /* Subprogram end */
1646         emit_uleb128 (w, 0x0);
1647
1648         emit_line (w);
1649
1650         /* Emit unwind info */
1651         if (unwind_info) {
1652                 emit_fde (w, w->fde_index, start_symbol, end_symbol, code, code_size, unwind_info, TRUE);
1653                 w->fde_index ++;
1654         }
1655
1656         /* Emit line number info */
1657         /* != could happen when using --regression */
1658         if (debug_info && (debug_info->code_start == code))
1659                 emit_line_number_info (w, method, start_symbol, end_symbol, code, code_size, debug_info);
1660
1661         emit_line (w);
1662 }
1663
1664 void
1665 mono_dwarf_writer_emit_trampoline (MonoDwarfWriter *w, const char *tramp_name, char *start_symbol, char *end_symbol, guint8 *code, guint32 code_size, GSList *unwind_info)
1666 {
1667         emit_section_change (w, ".debug_info", 0);
1668
1669         /* Subprogram */
1670         emit_uleb128 (w, ABBREV_SUBPROGRAM);
1671         emit_string (w, tramp_name);
1672         emit_pointer_value (w, code);
1673         emit_pointer_value (w, code + code_size);
1674         /* frame_base */
1675         emit_byte (w, 2);
1676         emit_byte (w, DW_OP_breg6);
1677         emit_byte (w, 16);
1678
1679         /* Subprogram end */
1680         emit_uleb128 (w, 0x0);
1681
1682         /* Emit unwind info */
1683         emit_fde (w, w->fde_index, start_symbol, end_symbol, code, code_size, unwind_info, FALSE);
1684         w->fde_index ++;
1685 }
1686 #endif /* End of: !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */