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