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