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         if (!w->il_file) {
 565                 /* FIXME: This doesn't seem to work with !xdebug */
 566                 emit_section_change (w, ".debug_line", 0);
 567                 emit_label (w, ".Ldebug_line_start");
 568                 emit_label (w, ".Ldebug_line_section_start");
 569                 return;
 570         }
 571
 572         /* Line number info header */
 573         /*
 574          * GAS seems to emit its own data to the end of the first subsection, so we use
 575          * subsections 1, 2 etc:
 576          * 1 - contains the header
 577          * 2 - contains the file names
 578          * 3 - contains the end of the header + the data
 579          * 4 - the end symbol
 580          */
 581         emit_section_change (w, ".debug_line", 0);
 582         emit_label (w, ".Ldebug_line_section_start");
 583         emit_section_change (w, ".debug_line", LINE_SUBSECTION_HEADER);
 584         emit_label (w, ".Ldebug_line_start");
 585         emit_symbol_diff (w, ".Ldebug_line_end", ".", -4); /* length */
 586         emit_int16 (w, 0x2); /* version */
 587         emit_symbol_diff (w, ".Ldebug_line_header_end", ".", -4); /* header_length */
 588         emit_byte (w, 1); /* minimum_instruction_length */
 589         emit_byte (w, 1); /* default_is_stmt */
 590         emit_byte (w, LINE_BASE); /* line_base */
 591         emit_byte (w, LINE_RANGE); /* line_range */
 592         emit_byte (w, OPCODE_BASE); /* opcode_base */
 593         emit_byte (w, 0); /* standard_opcode_lengths */
 594         emit_byte (w, 1);
 595         emit_byte (w, 1);
 596         emit_byte (w, 1);
 597         emit_byte (w, 1);
 598         emit_byte (w, 0);
 599         emit_byte (w, 0);
 600         emit_byte (w, 0);
 601         emit_byte (w, 1);
 602         emit_byte (w, 0);
 603         emit_byte (w, 0);
 604         emit_byte (w, 1);
 605
 606         /* Includes */
 607         emit_section_change (w, ".debug_line", LINE_SUBSECTION_INCLUDES);
 608
 609         /* End of Includes */
 610         emit_section_change (w, ".debug_line", LINE_SUBSECTION_FILES);
 611         emit_byte (w, 0);
 612
 613         /* Files */
 614         emit_line_number_file_name (w, "xdb.il", 0, 0);
 615
 616         /* End of Files */
 617         emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
 618         emit_byte (w, 0);
 619
 620         emit_label (w, ".Ldebug_line_header_end");
 621
 622         /* Emit this into a separate subsection so it gets placed at the end */
 623         emit_section_change (w, ".debug_line", LINE_SUBSECTION_END);
 624
 625         emit_byte (w, 0);
 626         emit_byte (w, 1);
 627         emit_byte (w, DW_LNE_end_sequence);
 628
 629         emit_label (w, ".Ldebug_line_end");
 630 }
 631
 632 void
 633 mono_dwarf_writer_emit_base_info (MonoDwarfWriter *w, GSList *base_unwind_program)
 634 {
 635         char *s, *build_info;
 636         int i;
 637
 638         w->cie_program = base_unwind_program;
 639
 640         emit_section_change (w, ".debug_abbrev", 0);
 641         emit_dwarf_abbrev (w, ABBREV_COMPILE_UNIT, DW_TAG_compile_unit, TRUE,
 642                                            compile_unit_attr, G_N_ELEMENTS (compile_unit_attr));
 643         emit_dwarf_abbrev (w, ABBREV_SUBPROGRAM, DW_TAG_subprogram, TRUE,
 644                                            subprogram_attr, G_N_ELEMENTS (subprogram_attr));
 645         emit_dwarf_abbrev (w, ABBREV_PARAM, DW_TAG_formal_parameter, FALSE,
 646                                            param_attr, G_N_ELEMENTS (param_attr));
 647         emit_dwarf_abbrev (w, ABBREV_PARAM_LOCLIST, DW_TAG_formal_parameter, FALSE,
 648                                            param_loclist_attr, G_N_ELEMENTS (param_loclist_attr));
 649         emit_dwarf_abbrev (w, ABBREV_BASE_TYPE, DW_TAG_base_type, FALSE,
 650                                            base_type_attr, G_N_ELEMENTS (base_type_attr));
 651         emit_dwarf_abbrev (w, ABBREV_STRUCT_TYPE, DW_TAG_class_type, TRUE,
 652                                            struct_type_attr, G_N_ELEMENTS (struct_type_attr));
 653         emit_dwarf_abbrev (w, ABBREV_DATA_MEMBER, DW_TAG_member, FALSE,
 654                                            data_member_attr, G_N_ELEMENTS (data_member_attr));
 655         emit_dwarf_abbrev (w, ABBREV_TYPEDEF, DW_TAG_typedef, FALSE,
 656                                            typedef_attr, G_N_ELEMENTS (typedef_attr));
 657         emit_dwarf_abbrev (w, ABBREV_ENUM_TYPE, DW_TAG_enumeration_type, TRUE,
 658                                            enum_type_attr, G_N_ELEMENTS (enum_type_attr));
 659         emit_dwarf_abbrev (w, ABBREV_ENUMERATOR, DW_TAG_enumerator, FALSE,
 660                                            enumerator_attr, G_N_ELEMENTS (enumerator_attr));
 661         emit_dwarf_abbrev (w, ABBREV_NAMESPACE, DW_TAG_namespace, TRUE,
 662                                            namespace_attr, G_N_ELEMENTS (namespace_attr));
 663         emit_dwarf_abbrev (w, ABBREV_VARIABLE, DW_TAG_variable, FALSE,
 664                                            variable_attr, G_N_ELEMENTS (variable_attr));
 665         emit_dwarf_abbrev (w, ABBREV_VARIABLE_LOCLIST, DW_TAG_variable, FALSE,
 666                                            variable_loclist_attr, G_N_ELEMENTS (variable_loclist_attr));
 667         emit_dwarf_abbrev (w, ABBREV_POINTER_TYPE, DW_TAG_pointer_type, FALSE,
 668                                            pointer_type_attr, G_N_ELEMENTS (pointer_type_attr));
 669         emit_dwarf_abbrev (w, ABBREV_REFERENCE_TYPE, DW_TAG_reference_type, FALSE,
 670                                            reference_type_attr, G_N_ELEMENTS (reference_type_attr));
 671         emit_dwarf_abbrev (w, ABBREV_INHERITANCE, DW_TAG_inheritance, FALSE,
 672                                            inheritance_attr, G_N_ELEMENTS (inheritance_attr));
 673         emit_byte (w, 0);
 674
 675         emit_section_change (w, ".debug_info", 0);
 676         emit_label (w, ".Ldebug_info_start");
 677         emit_symbol_diff (w, ".Ldebug_info_end", ".", -4); /* length */
 678         emit_int16 (w, 0x2); /* DWARF version 2 */
 679         emit_int32 (w, 0); /* .debug_abbrev offset */
 680         emit_byte (w, sizeof (gpointer)); /* address size */
 681
 682         /* Emit this into a separate section so it gets placed at the end */
 683         emit_section_change (w, ".debug_info", 1);
 684         emit_int32 (w, 0); /* close everything */
 685         emit_label (w, ".Ldebug_info_end");
 686         emit_section_change (w, ".debug_info", 0);
 687
 688         /* Compilation unit */
 689         emit_uleb128 (w, ABBREV_COMPILE_UNIT);
 690         build_info = mono_get_runtime_build_info ();
 691         s = g_strdup_printf ("Mono AOT Compiler %s", build_info);
 692         emit_string (w, s);
 693         g_free (build_info);
 694         g_free (s);
 695         emit_string (w, "JITted code");
 696         emit_string (w, "");
 697         emit_byte (w, DW_LANG_C);
 698         emit_pointer_value (w, 0);
 699         emit_pointer_value (w, 0);
 700         /* offset into .debug_line section */
 701         emit_symbol_diff (w, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
 702
 703         /* Base types */
 704         for (i = 0; i < G_N_ELEMENTS (basic_types); ++i) {
 705                 emit_label (w, basic_types [i].die_name);
 706                 emit_uleb128 (w, ABBREV_BASE_TYPE);
 707                 emit_byte (w, basic_types [i].size);
 708                 emit_byte (w, basic_types [i].encoding);
 709                 emit_string (w, basic_types [i].name);
 710         }
 711
 712         /* debug_loc section */
 713         emit_section_change (w, ".debug_loc", 0);
 714         emit_label (w, ".Ldebug_loc_start");
 715
 716         /* debug_line section */
 717         emit_line_number_info_begin (w);
 718
 719         emit_cie (w);
 720 }
 721
 722 static const char* emit_type (MonoDwarfWriter *w, MonoType *t);
 723
 724 /* Returns the local symbol pointing to the emitted debug info */
 725 static char*
 726 emit_class_dwarf_info (MonoDwarfWriter *w, MonoClass *klass, gboolean vtype)
 727 {
 728         char *die, *pointer_die, *reference_die;
 729         char *full_name, *p;
 730         gpointer iter;
 731         MonoClassField *field;
 732         const char *fdie;
 733         int k;
 734         gboolean emit_namespace = FALSE;
 735         GHashTable *cache;
 736
 737         // FIXME: Appdomains
 738         if (!w->class_to_die)
 739                 w->class_to_die = g_hash_table_new (NULL, NULL);
 740         if (!w->class_to_vtype_die)
 741                 w->class_to_vtype_die = g_hash_table_new (NULL, NULL);
 742         if (!w->class_to_pointer_die)
 743                 w->class_to_pointer_die = g_hash_table_new (NULL, NULL);
 744         if (!w->class_to_reference_die)
 745                 w->class_to_reference_die = g_hash_table_new (NULL, NULL);
 746
 747         if (vtype)
 748                 cache = w->class_to_vtype_die;
 749         else
 750                 cache = w->class_to_die;
 751
 752         die = g_hash_table_lookup (cache, klass);
 753         if (die)
 754                 return die;
 755
 756         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)))
 757                 return NULL;
 758
 759         /*
 760          * FIXME: gdb can't handle namespaces in languages it doesn't know about.
 761          */
 762         /*
 763         if (klass->name_space && klass->name_space [0] != '\0')
 764                 emit_namespace = TRUE;
 765         */
 766         if (emit_namespace) {
 767                 emit_uleb128 (w, ABBREV_NAMESPACE);
 768                 emit_string (w, klass->name_space);
 769         }
 770
 771         full_name = g_strdup_printf ("%s%s%s", klass->name_space, klass->name_space ? "." : "", klass->name);
 772         /*
 773          * gdb doesn't support namespaces for non-C++ dwarf objects, so use _
 774          * to separate components.
 775          */
 776         for (p = full_name; *p; p ++)
 777                 if (*p == '.')
 778                         *p = '_';
 779
 780         die = g_strdup_printf (".LTDIE_%d", w->tdie_index);
 781         pointer_die = g_strdup_printf (".LTDIE_%d_POINTER", w->tdie_index);
 782         reference_die = g_strdup_printf (".LTDIE_%d_REFERENCE", w->tdie_index);
 783         w->tdie_index ++;
 784
 785         g_hash_table_insert (w->class_to_pointer_die, klass, pointer_die);
 786         g_hash_table_insert (w->class_to_reference_die, klass, reference_die);
 787         g_hash_table_insert (cache, klass, die);
 788
 789         if (klass->enumtype) {
 790                 int size = mono_class_value_size (mono_class_from_mono_type (mono_class_enum_basetype (klass)), NULL);
 791
 792                 emit_label (w, die);
 793
 794                 emit_uleb128 (w, ABBREV_ENUM_TYPE);
 795                 emit_string (w, full_name);
 796                 emit_uleb128 (w, size);
 797                 for (k = 0; k < G_N_ELEMENTS (basic_types); ++k)
 798                         if (basic_types [k].type == mono_class_enum_basetype (klass)->type)
 799                                 break;
 800                 g_assert (k < G_N_ELEMENTS (basic_types));
 801                 emit_symbol_diff (w, basic_types [k].die_name, ".Ldebug_info_start", 0);
 802
 803                 /* Emit enum values */
 804                 iter = NULL;
 805                 while ((field = mono_class_get_fields (klass, &iter))) {
 806                         const char *p;
 807                         int len;
 808                         MonoTypeEnum def_type;
 809
 810                         if (strcmp ("value__", mono_field_get_name (field)) == 0)
 811                                 continue;
 812                         if (mono_field_is_deleted (field))
 813                                 continue;
 814
 815                         emit_uleb128 (w, ABBREV_ENUMERATOR);
 816                         emit_string (w, mono_field_get_name (field));
 817
 818                         p = mono_class_get_field_default_value (field, &def_type);
 819                         len = mono_metadata_decode_blob_size (p, &p);
 820                         switch (mono_class_enum_basetype (klass)->type) {
 821                         case MONO_TYPE_U1:
 822                         case MONO_TYPE_I1:
 823                         case MONO_TYPE_BOOLEAN:
 824                                 emit_sleb128 (w, *p);
 825                                 break;
 826                         case MONO_TYPE_U2:
 827                         case MONO_TYPE_I2:
 828                         case MONO_TYPE_CHAR:
 829                                 emit_sleb128 (w, read16 (p));
 830                                 break;
 831                         case MONO_TYPE_U4:
 832                         case MONO_TYPE_I4:
 833                                 emit_sleb128 (w, read32 (p));
 834                                 break;
 835                         case MONO_TYPE_U8:
 836                         case MONO_TYPE_I8:
 837                                 emit_sleb128 (w, read64 (p));
 838                                 break;
 839                         case MONO_TYPE_I:
 840                         case MONO_TYPE_U:
 841 #if SIZEOF_VOID_P == 8
 842                                 emit_sleb128 (w, read64 (p));
 843 #else
 844                                 emit_sleb128 (w, read32 (p));
 845 #endif
 846                                 break;
 847                         default:
 848                                 g_assert_not_reached ();
 849                         }
 850                 }
 851         } else {
 852                 guint8 buf [128];
 853                 guint8 *p;
 854                 char *parent_die;
 855
 856                 if (klass->parent)
 857                         parent_die = emit_class_dwarf_info (w, klass->parent, FALSE);
 858                 else
 859                         parent_die = NULL;
 860
 861                 /* Emit field types */
 862                 iter = NULL;
 863                 while ((field = mono_class_get_fields (klass, &iter))) {
 864                         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
 865                                 continue;
 866
 867                         emit_type (w, field->type);
 868                 }
 869
 870                 emit_label (w, die);
 871
 872                 emit_uleb128 (w, ABBREV_STRUCT_TYPE);
 873                 emit_string (w, full_name);
 874                 emit_uleb128 (w, klass->instance_size);
 875
 876                 if (parent_die) {
 877                         emit_uleb128 (w, ABBREV_INHERITANCE);
 878                         emit_symbol_diff (w, parent_die, ".Ldebug_info_start", 0);
 879
 880                         p = buf;
 881                         *p ++= DW_OP_plus_uconst;
 882                         encode_uleb128 (0, p, &p);
 883                         emit_byte (w, p - buf);
 884                         emit_bytes (w, buf, p - buf);
 885                 }
 886
 887                 /* Emit fields */
 888                 iter = NULL;
 889                 while ((field = mono_class_get_fields (klass, &iter))) {
 890                         if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
 891                                 continue;
 892
 893                         fdie = emit_type (w, field->type);
 894                         if (fdie) {
 895                                 emit_uleb128 (w, ABBREV_DATA_MEMBER);
 896                                 emit_string (w, field->name);
 897                                 emit_symbol_diff (w, fdie, ".Ldebug_info_start", 0);
 898                                 /* location */
 899                                 p = buf;
 900                                 *p ++= DW_OP_plus_uconst;
 901                                 if (klass->valuetype && vtype)
 902                                         encode_uleb128 (field->offset - sizeof (MonoObject), p, &p);
 903                                 else
 904                                         encode_uleb128 (field->offset, p, &p);
 905
 906                                 emit_byte (w, p - buf);
 907                                 emit_bytes (w, buf, p - buf);
 908                         }
 909                 }
 910         }
 911
 912         /* Type end */
 913         emit_uleb128 (w, 0x0);
 914
 915         /* Add a typedef, so we can reference the type without a 'struct' in gdb */
 916         emit_uleb128 (w, ABBREV_TYPEDEF);
 917         emit_string (w, full_name);
 918         emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
 919
 920         /* Add a pointer type */
 921         emit_label (w, pointer_die);
 922
 923         emit_uleb128 (w, ABBREV_POINTER_TYPE);
 924         emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
 925
 926         /* Add a reference type */
 927         emit_label (w, reference_die);
 928
 929         emit_uleb128 (w, ABBREV_REFERENCE_TYPE);
 930         emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
 931
 932         g_free (full_name);
 933
 934         if (emit_namespace) {
 935                 /* Namespace end */
 936                 emit_uleb128 (w, 0x0);
 937         }
 938
 939         return die;
 940 }
 941
 942 static const char*
 943 emit_type (MonoDwarfWriter *w, MonoType *t)
 944 {
 945         MonoClass *klass = mono_class_from_mono_type (t);
 946         int j;
 947         const char *tdie;
 948
 949         if (t->byref) {
 950                 if (t->type == MONO_TYPE_VALUETYPE) {
 951                         tdie = emit_class_dwarf_info (w, klass, TRUE);
 952                         if (tdie)
 953                                 return g_hash_table_lookup (w->class_to_pointer_die, klass);
 954                 }
 955                 else {
 956                         tdie = emit_class_dwarf_info (w, klass, FALSE);
 957                         /* Should return a pointer type to a reference */
 958                 }
 959                 // FIXME:
 960                 t = &mono_defaults.int_class->byval_arg;
 961         }
 962         for (j = 0; j < G_N_ELEMENTS (basic_types); ++j)
 963                 if (basic_types [j].type == t->type)
 964                         break;
 965         if (j < G_N_ELEMENTS (basic_types))
 966                 tdie = basic_types [j].die_name;
 967         else {
 968                 switch (t->type) {
 969                 case MONO_TYPE_CLASS:
 970                         emit_class_dwarf_info (w, klass, FALSE);
 971                         tdie = g_hash_table_lookup (w->class_to_reference_die, klass);
 972                         //tdie = ".LDIE_OBJECT";
 973                         break;
 974                 case MONO_TYPE_ARRAY:
 975                         tdie = ".LDIE_OBJECT";
 976                         break;
 977                 case MONO_TYPE_VALUETYPE:
 978                         if (klass->enumtype)
 979                                 tdie = emit_class_dwarf_info (w, klass, FALSE);
 980                         else
 981                                 tdie = ".LDIE_I4";
 982                         break;
 983                 case MONO_TYPE_GENERICINST:
 984                         if (!MONO_TYPE_ISSTRUCT (t)) {
 985                                 emit_class_dwarf_info (w, klass, FALSE);
 986                                 tdie = g_hash_table_lookup (w->class_to_reference_die, klass);
 987                         } else {
 988                                 tdie = ".LDIE_I4";
 989                         }
 990                         break;
 991                 default:
 992                         tdie = ".LDIE_I4";
 993                         break;
 994                 }
 995         }
 996
 997         return tdie;
 998 }
 999
1000 static void
1001 emit_var_type (MonoDwarfWriter *w, MonoType *t)
1002 {
1003         const char *tdie;
1004
1005         tdie = emit_type (w, t);
1006
1007         emit_symbol_diff (w, tdie, ".Ldebug_info_start", 0);
1008 }
1009
1010 static void
1011 encode_var_location (MonoDwarfWriter *w, MonoInst *ins, guint8 *p, guint8 **endp)
1012 {
1013         /* location */
1014         /* FIXME: This needs a location list, since the args can go from reg->stack */
1015         if (!ins || ins->flags & MONO_INST_IS_DEAD) {
1016                 /* gdb treats this as optimized out */
1017         } else if (ins->opcode == OP_REGVAR) {
1018                 *p = DW_OP_reg0 + mono_hw_reg_to_dwarf_reg (ins->dreg);
1019                 p ++;
1020         } else if (ins->opcode == OP_REGOFFSET) {
1021                 *p ++= DW_OP_breg0 + mono_hw_reg_to_dwarf_reg (ins->inst_basereg);
1022                 encode_sleb128 (ins->inst_offset, p, &p);
1023         } else {
1024                 // FIXME:
1025                 *p ++ = DW_OP_reg0;
1026         }
1027
1028         *endp = p;
1029 }
1030
1031 static void
1032 emit_loclist (MonoDwarfWriter *w, MonoInst *ins,
1033                           guint8 *loclist_begin_addr, guint8 *loclist_end_addr,
1034                           guint8 *expr, guint32 expr_len)
1035 {
1036         char label [128];
1037
1038         emit_push_section (w, ".debug_loc", 0);
1039         sprintf (label, ".Lloclist_%d", w->loclist_index ++ );
1040         emit_label (w, label);
1041
1042         emit_pointer_value (w, loclist_begin_addr);
1043         emit_pointer_value (w, loclist_end_addr);
1044         emit_byte (w, expr_len % 256);
1045         emit_byte (w, expr_len / 256);
1046         emit_bytes (w, expr, expr_len);
1047
1048         emit_pointer_value (w, NULL);
1049         emit_pointer_value (w, NULL);
1050
1051         emit_pop_section (w);
1052         emit_symbol_diff (w, label, ".Ldebug_loc_start", 0);
1053 }
1054
1055 /*
1056  * MonoDisHelper->tokener doesn't take an IP argument, and we can't add one since
1057  * it is a public header.
1058  */
1059 static const guint8 *token_handler_ip;
1060
1061 static char*
1062 token_handler (MonoDisHelper *dh, MonoMethod *method, guint32 token)
1063 {
1064         char *res, *desc;
1065         MonoMethod *cmethod;
1066         MonoClass *klass;
1067         MonoClassField *field;
1068         gpointer data = NULL;
1069
1070         if (method->wrapper_type)
1071                 data = mono_method_get_wrapper_data (method, token);
1072
1073         switch (*token_handler_ip) {
1074         case CEE_ISINST:
1075         case CEE_CASTCLASS:
1076         case CEE_LDELEMA:
1077                 if (method->wrapper_type)
1078                         klass = data;
1079                 else
1080                         klass = mono_class_get_full (method->klass->image, token, NULL);
1081                 res = g_strdup_printf ("<%s>", klass->name);
1082                 break;
1083         case CEE_NEWOBJ:
1084         case CEE_CALL:
1085         case CEE_CALLVIRT:
1086                 if (method->wrapper_type)
1087                         cmethod = data;
1088                 else
1089                         cmethod = mono_get_method_full (method->klass->image, token, NULL, NULL);
1090                 desc = mono_method_full_name (cmethod, TRUE);
1091                 res = g_strdup_printf ("<%s>", desc);
1092                 g_free (desc);
1093                 break;
1094         case CEE_CALLI:
1095                 if (method->wrapper_type) {
1096                         desc = mono_signature_get_desc (data, FALSE);
1097                         res = g_strdup_printf ("<%s>", desc);
1098                         g_free (desc);
1099                 } else {
1100                         res = g_strdup_printf ("<0x%08x>", token);
1101                 }
1102                 break;
1103         case CEE_LDFLD:
1104         case CEE_LDSFLD:
1105         case CEE_STFLD:
1106         case CEE_STSFLD:
1107                 if (method->wrapper_type)
1108                         field = data;
1109                 else
1110                         field = mono_field_from_token (method->klass->image, token, &klass, NULL);
1111                 desc = mono_field_full_name (field);
1112                 res = g_strdup_printf ("<%s>", desc);
1113                 g_free (desc);
1114                 break;
1115         default:
1116                 res = g_strdup_printf ("<0x%08x>", token);
1117                 break;
1118         }
1119
1120         return res;
1121 }
1122
1123 /*
1124  * disasm_ins:
1125  *
1126  *   Produce a disassembled form of the IL instruction at IP. This is an extension
1127  * of mono_disasm_code_one () which can disasm tokens, handle wrapper methods, and
1128  * CEE_MONO_ opcodes.
1129  */
1130 static char*
1131 disasm_ins (MonoMethod *method, const guchar *ip, const guint8 **endip)
1132 {
1133         char *dis;
1134         MonoDisHelper dh;
1135         MonoMethodHeader *header = mono_method_get_header (method);
1136
1137         memset (&dh, 0, sizeof (dh));
1138         dh.newline = "";
1139         dh.label_format = "IL_%04x: ";
1140         dh.label_target = "IL_%04x";
1141         dh.tokener = token_handler;
1142
1143         token_handler_ip = ip;
1144         if (*ip == MONO_CUSTOM_PREFIX) {
1145                 guint32 token;
1146                 gpointer data;
1147
1148                 switch (ip [1]) {
1149                 case CEE_MONO_ICALL: {
1150                         MonoJitICallInfo *info;
1151
1152                         token = read32 (ip + 2);
1153                         data = mono_method_get_wrapper_data (method, token);
1154                         info = mono_find_jit_icall_by_addr (data);
1155                         g_assert (info);
1156
1157                         dis = g_strdup_printf ("IL_%04x: mono_icall <%s>", (int)(ip - header->code), info->name);
1158                         ip += 6;
1159                         break;
1160                 }
1161                 case CEE_MONO_CLASSCONST: {
1162                         token = read32 (ip + 2);
1163                         data = mono_method_get_wrapper_data (method, token);
1164
1165                         dis = g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip - header->code), ((MonoClass*)data)->name);
1166                         ip += 6;
1167                         break;
1168                 }
1169                 default:
1170                         dis = mono_disasm_code_one (&dh, method, ip, &ip);
1171                 }
1172         } else {
1173                 dis = mono_disasm_code_one (&dh, method, ip, &ip);
1174         }
1175         token_handler_ip = NULL;
1176
1177         *endip = ip;
1178         return dis;
1179 }
1180
1181 static gint32
1182 il_offset_from_address (MonoMethod *method, MonoDebugMethodJitInfo *jit,
1183                                                 guint32 native_offset)
1184 {
1185         int i;
1186
1187         if (!jit->line_numbers)
1188                 return -1;
1189
1190         for (i = jit->num_line_numbers - 1; i >= 0; i--) {
1191                 MonoDebugLineNumberEntry lne = jit->line_numbers [i];
1192
1193                 if (lne.native_offset <= native_offset)
1194                         return lne.il_offset;
1195         }
1196
1197         return -1;
1198 }
1199
1200 static int max_special_addr_diff = 0;
1201
1202 static inline void
1203 emit_advance_op (MonoDwarfWriter *w, int line_diff, int addr_diff)
1204 {
1205         gint64 opcode = 0;
1206
1207         /* Use a special opcode if possible */
1208         if (line_diff - LINE_BASE >= 0 && line_diff - LINE_BASE < LINE_RANGE) {
1209                 if (max_special_addr_diff == 0)
1210                         max_special_addr_diff = (255 - OPCODE_BASE) / LINE_RANGE;
1211
1212                 if (addr_diff > max_special_addr_diff && (addr_diff < 2 * max_special_addr_diff)) {
1213                         emit_byte (w, DW_LNS_const_add_pc);
1214                         addr_diff -= max_special_addr_diff;
1215                 }
1216
1217                 opcode = (line_diff - LINE_BASE) + (LINE_RANGE * addr_diff) + OPCODE_BASE;
1218                 if (opcode > 255)
1219                         opcode = 0;
1220         }
1221
1222         if (opcode != 0) {
1223                 emit_byte (w, opcode);
1224         } else {
1225                 emit_byte (w, DW_LNS_advance_line);
1226                 emit_sleb128 (w, line_diff);
1227                 emit_byte (w, DW_LNS_advance_pc);
1228                 emit_sleb128 (w, addr_diff);
1229                 emit_byte (w, DW_LNS_copy);
1230         }
1231 }
1232
1233 static gint
1234 compare_lne (MonoDebugLineNumberEntry *a, MonoDebugLineNumberEntry *b)
1235 {
1236         if (a->native_offset == b->native_offset)
1237                 return a->il_offset - b->il_offset;
1238         else
1239                 return a->native_offset - b->native_offset;
1240 }
1241
1242 static void
1243 emit_line_number_info (MonoDwarfWriter *w, MonoMethod *method, guint8 *code,
1244                                            guint32 code_size, MonoDebugMethodJitInfo *debug_info)
1245 {
1246         guint32 prev_line = 0;
1247         guint32 prev_native_offset = 0;
1248         int i, file_index, il_offset, prev_il_offset;
1249         gboolean first = TRUE;
1250         MonoDebugSourceLocation *loc;
1251         char *prev_file_name = NULL;
1252         MonoMethodHeader *header = mono_method_get_header (method);
1253         MonoDebugMethodInfo *minfo;
1254         GArray *ln_array;
1255         int *native_to_il_offset = NULL;
1256
1257         if (!code)
1258                 // FIXME: The set_address op below only works with xdebug
1259                 return;
1260
1261         minfo = mono_debug_lookup_method (method);
1262
1263         /* Compute the native->IL offset mapping */
1264
1265 #ifndef _EGLIB_MAJOR
1266         ln_array = g_array_sized_new (FALSE, FALSE, sizeof (MonoDebugLineNumberEntry),
1267                                                                   debug_info->num_line_numbers);
1268         g_array_append_vals (ln_array, debug_info->line_numbers, debug_info->num_line_numbers);
1269         g_array_sort (ln_array, (GCompareFunc)compare_lne);
1270         native_to_il_offset = g_new0 (int, code_size + 1);
1271
1272         for (i = 0; i < debug_info->num_line_numbers; ++i) {
1273                 int j;
1274                 MonoDebugLineNumberEntry lne = g_array_index (ln_array, MonoDebugLineNumberEntry, i);
1275
1276                 if (i == 0) {
1277                         for (j = 0; j < lne.native_offset; ++j)
1278                                 native_to_il_offset [j] = -1;
1279                 }
1280
1281                 if (i < debug_info->num_line_numbers - 1) {
1282                         MonoDebugLineNumberEntry lne_next = g_array_index (ln_array, MonoDebugLineNumberEntry, i + 1);
1283
1284                         for (j = lne.native_offset; j < lne_next.native_offset; ++j)
1285                                 native_to_il_offset [j] = lne.il_offset;
1286                 } else {
1287                         for (j = lne.native_offset; j < code_size; ++j)
1288                                 native_to_il_offset [j] = lne.il_offset;
1289                 }
1290         }
1291         g_array_free (ln_array, TRUE);
1292 #endif
1293
1294         prev_line = 1;
1295         prev_il_offset = -1;
1296
1297         for (i = 0; i < code_size; ++i) {
1298                 if (!minfo)
1299                         continue;
1300
1301                 if (!debug_info->line_numbers)
1302                         continue;
1303
1304                 if (native_to_il_offset)
1305                         il_offset = native_to_il_offset [i];
1306                 else
1307                         il_offset = il_offset_from_address (method, debug_info, i);
1308                 /*
1309                 il_offset = il_offset_from_address (method, debug_info, i);
1310
1311                 g_assert (il_offset == native_to_il_offset [i]);
1312                 */
1313
1314                 il_offset = native_to_il_offset [i];
1315                 if (il_offset < 0)
1316                         continue;
1317
1318                 if (il_offset == prev_il_offset)
1319                         continue;
1320
1321                 prev_il_offset = il_offset;
1322
1323                 loc = mono_debug_symfile_lookup_location (minfo, il_offset);
1324
1325                 if (loc) {
1326                         int line_diff = (gint32)loc->row - (gint32)prev_line;
1327                         int addr_diff = i - prev_native_offset;
1328
1329                         if (first) {
1330                                 emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
1331
1332                                 emit_byte (w, 0);
1333                                 emit_byte (w, sizeof (gpointer) + 1);
1334                                 emit_byte (w, DW_LNE_set_address);
1335                                 emit_pointer_value (w, code);
1336
1337                                 /*
1338                                  * The prolog+initlocals region does not have a line number, this
1339                                  * makes them belong to the first line of the method.
1340                                  */
1341                                 emit_byte (w, DW_LNS_advance_line);
1342                                 emit_sleb128 (w, (gint32)loc->row - (gint32)prev_line);
1343                                 prev_line = loc->row;
1344                         }
1345
1346                         if (loc->row != prev_line) {
1347                                 if (!prev_file_name || strcmp (loc->source_file, prev_file_name) != 0) {
1348                                         /* Add an entry to the file table */
1349                                         /* FIXME: Avoid duplicates */
1350                                         file_index = emit_line_number_file_name (w, loc->source_file, 0, 0);
1351                                         g_free (prev_file_name);
1352                                         prev_file_name = g_strdup (loc->source_file);
1353
1354                                         emit_byte (w, DW_LNS_set_file);
1355                                         emit_uleb128 (w, file_index);
1356                                         emit_byte (w, DW_LNS_copy);
1357                                 }
1358
1359                                 //printf ("X: %p(+0x%x) %d %s:%d(+%d)\n", code + i, addr_diff, loc->il_offset, loc->source_file, loc->row, line_diff);
1360
1361                                 emit_advance_op (w, line_diff, addr_diff);
1362
1363                                 prev_line = loc->row;
1364                                 prev_native_offset = i;
1365                         }
1366
1367                         first = FALSE;
1368                         g_free (loc);
1369                 }
1370         }
1371
1372         g_free (prev_file_name);
1373
1374         if (!first) {
1375                 emit_byte (w, DW_LNS_advance_pc);
1376                 emit_sleb128 (w, code_size - prev_native_offset);
1377                 emit_byte (w, DW_LNS_copy);
1378
1379                 emit_byte (w, 0);
1380                 emit_byte (w, 1);
1381                 emit_byte (w, DW_LNE_end_sequence);
1382         } else if (code) {
1383                 /* No debug info, XDEBUG mode */
1384                 char *name, *dis;
1385                 const guint8 *ip = header->code;
1386                 int prev_line, prev_native_offset;
1387                 int *il_to_line;
1388
1389                 /*
1390                  * Emit the IL code into a temporary file and emit line number info
1391                  * referencing that file.
1392                  */
1393
1394                 name = mono_method_full_name (method, TRUE);
1395                 fprintf (w->il_file, "// %s\n", name);
1396                 w->il_file_line_index ++;
1397                 g_free (name);
1398
1399                 il_to_line = g_new0 (int, header->code_size);
1400
1401                 emit_section_change (w, ".debug_line", LINE_SUBSECTION_DATA);
1402                 emit_byte (w, 0);
1403                 emit_byte (w, sizeof (gpointer) + 1);
1404                 emit_byte (w, DW_LNE_set_address);
1405                 emit_pointer_value (w, code);
1406
1407                 // FIXME: Optimize this
1408                 while (ip < header->code + header->code_size) {
1409                         int il_offset = ip - header->code;
1410
1411                         /* Emit IL */
1412                         w->il_file_line_index ++;
1413
1414                         dis = disasm_ins (method, ip, &ip);
1415                         fprintf (w->il_file, "%s\n", dis);
1416                         g_free (dis);
1417
1418                         il_to_line [il_offset] = w->il_file_line_index;
1419                 }
1420
1421                 /* Emit line number info */
1422                 prev_line = 1;
1423                 prev_native_offset = 0;
1424                 for (i = 0; i < debug_info->num_line_numbers; ++i) {
1425                         MonoDebugLineNumberEntry *lne = &debug_info->line_numbers [i];
1426                         int line;
1427
1428                         if (lne->il_offset >= header->code_size)
1429                                 continue;
1430                         line = il_to_line [lne->il_offset];
1431                         if (!line) {
1432                                 /*
1433                                  * This seems to happen randomly, it looks like il_offset points
1434                                  * into the middle of an instruction.
1435                                  */
1436                                 continue;
1437                                 /*
1438                                 printf ("%s\n", mono_method_full_name (method, TRUE));
1439                                 printf ("%d %d\n", lne->il_offset, header->code_size);
1440                                 g_assert (line);
1441                                 */
1442                         }
1443
1444                         if (line - prev_line != 0) {
1445                                 emit_advance_op (w, line - prev_line, (gint32)lne->native_offset - prev_native_offset);
1446
1447                                 prev_line = line;
1448                                 prev_native_offset = lne->native_offset;
1449                         }
1450                 }
1451
1452                 emit_byte (w, DW_LNS_advance_pc);
1453                 emit_sleb128 (w, code_size - prev_native_offset);
1454                 emit_byte (w, DW_LNS_copy);
1455
1456                 emit_byte (w, 0);
1457                 emit_byte (w, 1);
1458                 emit_byte (w, DW_LNE_end_sequence);
1459
1460                 fflush (w->il_file);
1461                 g_free (il_to_line);
1462         }
1463 }
1464
1465 static MonoMethodVar*
1466 find_vmv (MonoCompile *cfg, MonoInst *ins)
1467 {
1468         int j;
1469
1470         if (cfg->varinfo) {
1471                 for (j = 0; j < cfg->num_varinfo; ++j) {
1472                         if (cfg->varinfo [j] == ins)
1473                                 break;
1474                 }
1475
1476                 if (j < cfg->num_varinfo) {
1477                         return MONO_VARINFO (cfg, j);
1478                 }
1479         }
1480
1481         return NULL;
1482 }
1483
1484 void
1485 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)
1486 {
1487         char *name;
1488         MonoMethodSignature *sig;
1489         MonoMethodHeader *header;
1490         char **names, **tdies, **local_tdies;
1491         char **local_names;
1492         int *local_indexes;
1493         int i, num_locals;
1494         guint8 buf [128];
1495         guint8 *p;
1496
1497         emit_section_change (w, ".debug_info", 0);
1498
1499         sig = mono_method_signature (method);
1500         header = mono_method_get_header (method);
1501
1502         /* Parameter types */
1503         tdies = g_new0 (char *, sig->param_count + sig->hasthis);
1504         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
1505                 MonoType *t;
1506
1507                 if (i == 0 && sig->hasthis) {
1508                         if (method->klass->valuetype)
1509                                 t = &method->klass->this_arg;
1510                         else
1511                                 t = &method->klass->byval_arg;
1512                 } else {
1513                         t = sig->params [i - sig->hasthis];
1514                 }
1515
1516                 emit_type (w, t);
1517         }
1518
1519         /* Local types */
1520         local_tdies = g_new0 (char *, header->num_locals);
1521         for (i = 0; i < header->num_locals; ++i) {
1522                 emit_type (w, header->locals [i]);
1523         }
1524
1525         /* Subprogram */
1526         names = g_new0 (char *, sig->param_count);
1527         mono_method_get_param_names (method, (const char **) names);
1528
1529         emit_uleb128 (w, ABBREV_SUBPROGRAM);
1530         name = mono_method_full_name (method, FALSE);
1531         emit_string (w, name);
1532         g_free (name);
1533         if (start_symbol) {
1534                 emit_pointer_unaligned (w, start_symbol);
1535                 emit_pointer_unaligned (w, end_symbol);
1536         } else {
1537                 emit_pointer_value (w, code);
1538                 emit_pointer_value (w, code + code_size);
1539         }
1540         /* frame_base */
1541         emit_byte (w, 2);
1542         emit_byte (w, DW_OP_breg6);
1543         emit_byte (w, 16);
1544
1545         /* Parameters */
1546         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
1547                 MonoInst *arg = args ? args [i] : NULL;
1548                 MonoType *t;
1549                 const char *pname;
1550                 char pname_buf [128];
1551                 MonoMethodVar *vmv = NULL;
1552                 gboolean need_loclist = FALSE;
1553
1554                 vmv = find_vmv (cfg, arg);
1555                 if (code && vmv && (vmv->live_range_start || vmv->live_range_end))
1556                         need_loclist = TRUE;
1557
1558                 if (i == 0 && sig->hasthis) {
1559                         if (method->klass->valuetype)
1560                                 t = &method->klass->this_arg;
1561                         else
1562                                 t = &method->klass->byval_arg;
1563                         pname = "this";
1564                 } else {
1565                         t = sig->params [i - sig->hasthis];
1566                         pname = names [i - sig->hasthis];
1567                 }
1568
1569                 emit_uleb128 (w, need_loclist ? ABBREV_PARAM_LOCLIST : ABBREV_PARAM);
1570                 /* name */
1571                 if (pname[0] == '\0') {
1572                         sprintf (pname_buf, "param%d", i - sig->hasthis);
1573                         pname = pname_buf;
1574                 }
1575                 emit_string (w, pname);
1576                 /* type */
1577                 if (!arg || arg->flags & MONO_INST_IS_DEAD)
1578                         emit_var_type (w, &mono_defaults.int32_class->byval_arg);
1579                 else
1580                         emit_var_type (w, t);
1581
1582                 p = buf;
1583                 encode_var_location (w, arg, p, &p);
1584                 if (need_loclist) {
1585                         vmv->live_range_start = 0;
1586                         if (vmv->live_range_end == 0)
1587                                 /* FIXME: Uses made in calls are not recorded */
1588                                 vmv->live_range_end = code_size;
1589                         emit_loclist (w, arg, code + vmv->live_range_start, code + vmv->live_range_end, buf, p - buf);
1590                 } else {
1591                         emit_byte (w, p - buf);
1592                         emit_bytes (w, buf, p - buf);
1593                 }
1594         }
1595         g_free (names);
1596
1597         /* Locals */
1598         num_locals = mono_debug_lookup_locals (method, &local_names, &local_indexes);
1599
1600         for (i = 0; i < header->num_locals; ++i) {
1601                 MonoInst *ins = locals [i];
1602                 char name_buf [128];
1603                 int j;
1604                 MonoMethodVar *vmv = NULL;
1605                 gboolean need_loclist = FALSE;
1606
1607                 /* ins->dreg no longer contains the original vreg */
1608                 vmv = find_vmv (cfg, ins);
1609                 if (code && vmv) {
1610                         if (vmv->live_range_start) {
1611                                 /* This variable has a precise live range */
1612                                 need_loclist = TRUE;
1613                         }
1614                 }
1615
1616                 emit_uleb128 (w, need_loclist ? ABBREV_VARIABLE_LOCLIST : ABBREV_VARIABLE);
1617                 /* name */
1618                 for (j = 0; j < num_locals; ++j)
1619                         if (local_indexes [j] == i)
1620                                 break;
1621                 if (j < num_locals) {
1622                         emit_string (w, local_names [j]);
1623                 } else {
1624                         sprintf (name_buf, "V_%d", i);
1625                         emit_string (w, name_buf);
1626                 }
1627                 /* type */
1628                 if (!ins || ins->flags & MONO_INST_IS_DEAD)
1629                         emit_var_type (w, &mono_defaults.int32_class->byval_arg);
1630                 else
1631                         emit_var_type (w, header->locals [i]);
1632
1633                 p = buf;
1634                 encode_var_location (w, ins, p, &p);
1635
1636                 if (need_loclist) {
1637                         if (vmv->live_range_end == 0)
1638                                 /* FIXME: Uses made in calls are not recorded */
1639                                 vmv->live_range_end = code_size;
1640                         emit_loclist (w, ins, code + vmv->live_range_start, code + vmv->live_range_end, buf, p - buf);
1641                 } else {
1642                         emit_byte (w, p - buf);
1643                         emit_bytes (w, buf, p - buf);
1644                 }
1645         }
1646
1647         g_free (local_names);
1648         g_free (local_indexes);
1649
1650         /* Subprogram end */
1651         emit_uleb128 (w, 0x0);
1652
1653         emit_line (w);
1654
1655         /* Emit unwind info */
1656         if (unwind_info) {
1657                 emit_fde (w, w->fde_index, start_symbol, end_symbol, code, code_size, unwind_info, TRUE);
1658                 w->fde_index ++;
1659         }
1660
1661         /* Emit line number info */
1662         if (code && debug_info)
1663                 /* != could happen when using --regression */
1664                 if (debug_info->code_start == code)
1665                         emit_line_number_info (w, method, code, code_size, debug_info);
1666
1667         emit_line (w);
1668 }
1669
1670 void
1671 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)
1672 {
1673         emit_section_change (w, ".debug_info", 0);
1674
1675         /* Subprogram */
1676         emit_uleb128 (w, ABBREV_SUBPROGRAM);
1677         emit_string (w, tramp_name);
1678         emit_pointer_value (w, code);
1679         emit_pointer_value (w, code + code_size);
1680         /* frame_base */
1681         emit_byte (w, 2);
1682         emit_byte (w, DW_OP_breg6);
1683         emit_byte (w, 16);
1684
1685         /* Subprogram end */
1686         emit_uleb128 (w, 0x0);
1687
1688         /* Emit unwind info */
1689         emit_fde (w, w->fde_index, start_symbol, end_symbol, code, code_size, unwind_info, FALSE);
1690         w->fde_index ++;
1691 }
1692 #endif /* End of: !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */