mono/jit/debug-dwarf2.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include <errno.h>
   4 #include <mono/metadata/class.h>
   5 #include <mono/metadata/tabledefs.h>
   6 #include <mono/metadata/tokentype.h>
   7 #include <mono/jit/codegen.h>
   8 #include <mono/jit/debug.h>
   9
  10 #include "debug-private.h"
  11
  12 #define ABBREV_COMPILE_UNIT             1
  13 #define ABBREV_SUBPROGRAM               2
  14 #define ABBREV_SUBPROGRAM_RETVAL        3
  15 #define ABBREV_BASE_TYPE                4
  16 #define ABBREV_FORMAL_PARAMETER         5
  17 #define ABBREV_PARAMETER                6
  18 #define ABBREV_LOCAL_VARIABLE           7
  19 #define ABBREV_STRUCT_TYPE              8
  20 #define ABBREV_STRUCT_MEMBER            9
  21 #define ABBREV_STRUCT_ACCESS            10
  22 #define ABBREV_ENUM_TYPE                11
  23 #define ABBREV_ENUM_VALUE               12
  24 #define ABBREV_ENUM_VALUE_UNSIGNED      13
  25 #define ABBREV_ENUM_VALUE_SIGNED        14
  26 #define ABBREV_CLASS_TYPE               15
  27 #define ABBREV_CLASS_INHERITANCE        16
  28 #define ABBREV_POINTER_TYPE             17
  29 #define ABBREV_CLASS_METHOD             18
  30 #define ABBREV_CLASS_METHOD_RETVAL      19
  31 #define ABBREV_ARTIFICIAL_PARAMETER     20
  32 #define ABBREV_SIMPLE_ARRAY             21
  33 #define ABBREV_ARRAY                    22
  34 #define ABBREV_SUBRANGE                 23
  35
  36 // The following constants are defined in the DWARF 2 specification
  37 #define DW_TAG_array_type               0x01
  38 #define DW_TAG_class_type               0x02
  39 #define DW_TAG_enumeration_type         0x04
  40 #define DW_TAG_formal_parameter         0x05
  41 #define DW_TAG_member                   0x0d
  42 #define DW_TAG_pointer_type             0x0f
  43 #define DW_TAG_compile_unit             0x11
  44 #define DW_TAG_structure_type           0x13
  45 #define DW_TAG_inheritance              0x1c
  46 #define DW_TAG_subrange_type            0x21
  47 #define DW_TAG_access_declaration       0x23
  48 #define DW_TAG_base_type                0x24
  49 #define DW_TAG_enumerator               0x28
  50 #define DW_TAG_subprogram               0x2e
  51 #define DW_TAG_variable                 0x34
  52
  53 #define DW_CHILDREN_no                  0
  54 #define DW_CHILDREN_yes                 1
  55
  56 #define DW_AT_location                  0x02
  57 #define DW_AT_name                      0x03
  58 #define DW_AT_byte_size                 0x0b
  59 #define DW_AT_stmt_list                 0x10
  60 #define DW_AT_low_pc                    0x11
  61 #define DW_AT_high_pc                   0x12
  62 #define DW_AT_language                  0x13
  63 #define DW_AT_const_value               0x1c
  64 #define DW_AT_lower_bound               0x22
  65 #define DW_AT_producer                  0x25
  66 #define DW_AT_start_scope               0x2c
  67 #define DW_AT_upper_bound               0x2f
  68 #define DW_AT_accessibility             0x32
  69 #define DW_AT_artificial                0x34
  70 #define DW_AT_calling_convention        0x36
  71 #define DW_AT_count                     0x37
  72 #define DW_AT_data_member_location      0x38
  73 #define DW_AT_encoding                  0x3e
  74 #define DW_AT_external                  0x3f
  75 #define DW_AT_type                      0x49
  76 #define DW_AT_virtuality                0x4c
  77 #define DW_AT_vtable_elem_location      0x4d
  78
  79 /* Martin Baulig's extensions. */
  80 #define DW_AT_end_scope                 0x2121
  81
  82 #define DW_FORM_addr                    0x01
  83 #define DW_FORM_block4                  0x04
  84 #define DW_FORM_data2                   0x05
  85 #define DW_FORM_data4                   0x06
  86 #define DW_FORM_data8                   0x07
  87 #define DW_FORM_string                  0x08
  88 #define DW_FORM_data1                   0x0b
  89 #define DW_FORM_flag                    0x0c
  90 #define DW_FORM_sdata                   0x0d
  91 #define DW_FORM_udata                   0x0f
  92 #define DW_FORM_ref4                    0x13
  93
  94 #define DW_ATE_void                     0x00
  95 #define DW_ATE_address                  0x01
  96 #define DW_ATE_boolean                  0x02
  97 #define DW_ATE_complex_float            0x03
  98 #define DW_ATE_float                    0x04
  99 #define DW_ATE_signed                   0x05
 100 #define DW_ATE_signed_char              0x06
 101 #define DW_ATE_unsigned                 0x07
 102 #define DW_ATE_unsigned_char            0x08
 103
 104 #define DW_OP_const1u                   0x08
 105 #define DW_OP_const1s                   0x09
 106 #define DW_OP_constu                    0x10
 107 #define DW_OP_consts                    0x11
 108 #define DW_OP_plus                      0x22
 109 #define DW_OP_reg0                      0x50
 110 #define DW_OP_breg0                     0x70
 111 #define DW_OP_fbreg                     0x91
 112 #define DW_OP_piece                     0x93
 113
 114 #define DW_CC_normal                    1
 115 #define DW_CC_program                   2
 116 #define DW_CC_nocall                    3
 117
 118 #define DW_ACCESS_public                1
 119 #define DW_ACCESS_protected             2
 120 #define DW_ACCESS_private               3
 121
 122 #define DW_VIRTUALITY_none              0
 123 #define DW_VIRTUALITY_virtual           1
 124 #define DW_VIRTUALITY_pure_virtual      2
 125
 126 #define DW_LANG_C_plus_plus             0x04
 127 #define DW_LANG_Java                    0x0b
 128 // This is NOT in the standard, we're using Java for the moment. */
 129 #define DW_LANG_C_sharp                 DW_LANG_C_plus_plus
 130
 131 #define DW_LNS_extended_op              0
 132 #define DW_LNS_copy                     1
 133 #define DW_LNS_advance_pc               2
 134 #define DW_LNS_advance_line             3
 135 #define DW_LNS_set_file                 4
 136 #define DW_LNS_set_column               5
 137 #define DW_LNS_negate_stmt              6
 138 #define DW_LNS_set_basic_block          7
 139 #define DW_LNS_const_add_pc             8
 140 #define DW_LNS_fixed_advance_pc         9
 141
 142 #define DW_LNE_end_sequence             1
 143 #define DW_LNE_set_address              2
 144 #define DW_LNE_define_file              3
 145
 146
 147 static const int line_base = 1, line_range = 8, opcode_base = 10;
 148 static const int standard_opcode_sizes [10] = {
 149     0, 0, 1, 1, 1, 1, 0, 0, 0, 0
 150 };
 151
 152 static void
 153 dwarf2_write_byte (FILE *f, int byte)
 154 {
 155         fprintf (f, "\t.byte %d\n", byte);
 156 }
 157
 158 static void
 159 dwarf2_write_2byte (FILE *f, int word)
 160 {
 161         fprintf (f, "\t.word %d\n", word);
 162 }
 163
 164 static void
 165 dwarf2_write_pair (FILE *f, int a, int b)
 166 {
 167         fprintf (f, "\t.uleb128 %d, %d\n", a, b);
 168 }
 169
 170 static void
 171 dwarf2_write_long (FILE *f, unsigned long value)
 172 {
 173         fprintf (f, "\t.long %lu\n", value);
 174 }
 175
 176 static void
 177 dwarf2_write_address (FILE *f, void *address)
 178 {
 179         fprintf (f, "\t.long %p\n", address);
 180 }
 181
 182 static void
 183 dwarf2_write_string (FILE *f, const char *string)
 184 {
 185         fprintf (f, "\t.string \"%s\"\n", string);
 186 }
 187
 188 static void
 189 dwarf2_write_sleb128 (FILE *f, long value)
 190 {
 191         fprintf (f, "\t.sleb128 %ld\n", value);
 192 }
 193
 194 static void
 195 dwarf2_write_uleb128 (FILE *f, unsigned long value)
 196 {
 197         fprintf (f, "\t.uleb128 %lu\n", value);
 198 }
 199
 200 static void
 201 dwarf2_write_section_start (FILE *f, const char *section)
 202 {
 203         fprintf (f, "\t.section .%s\n", section);
 204 }
 205
 206 static void
 207 dwarf2_write_label (FILE *f, const char *label)
 208 {
 209         fprintf (f, ".L_%s:\n", label);
 210 }
 211
 212 static void
 213 dwarf2_write_section_size (FILE *f, const char *start_label, const char *end_label)
 214 {
 215         fprintf (f, "\t.long .L_%s - .L_%s\n", end_label, start_label);
 216 }
 217
 218 static void
 219 dwarf2_write_ref4 (FILE *f, const char *target_label)
 220 {
 221         fprintf (f, "\t.long .L_%s\n", target_label);
 222 }
 223
 224 static void
 225 dwarf2_write_type_ref (FILE *f, unsigned long type_index)
 226 {
 227         fprintf (f, "\t.long .L_TYPE_%lu - .L_debug_info_b\n", type_index);
 228 }
 229
 230 static void
 231 dwarf2_write_type_ptr_ref (FILE *f, unsigned long idx)
 232 {
 233         fprintf (f, "\t.long .L_TYPE_PTR_%lu - .L_debug_info_b\n", idx);
 234 }
 235
 236 static void
 237 dwarf2_write_relative_ref (FILE *f, const gchar *name, unsigned long idx)
 238 {
 239         fprintf (f, "\t.long .L_%s_%lu - .L_debug_info_b\n", name, idx);
 240 }
 241
 242 static void
 243 dwarf2_write_dw_lns_copy (FILE *f)
 244 {
 245         dwarf2_write_byte (f, DW_LNS_copy);
 246 }
 247
 248 static void
 249 dwarf2_write_dw_lns_advance_pc (FILE *f, unsigned value)
 250 {
 251         dwarf2_write_byte (f, DW_LNS_advance_pc);
 252         dwarf2_write_uleb128 (f, value);
 253 }
 254
 255 static void
 256 dwarf2_write_dw_lns_advance_line (FILE *f, int value)
 257 {
 258         dwarf2_write_byte (f, DW_LNS_advance_line);
 259         dwarf2_write_sleb128 (f, value);
 260 }
 261
 262 static void
 263 dwarf2_write_dw_lns_set_file (FILE *f, unsigned value)
 264 {
 265         dwarf2_write_byte (f, DW_LNS_set_file);
 266         dwarf2_write_uleb128 (f, value + 1);
 267 }
 268
 269 static void
 270 dwarf2_write_dw_lns_negate_stmt (FILE *f)
 271 {
 272         dwarf2_write_byte (f, DW_LNS_negate_stmt);
 273 }
 274
 275 #if 0 /* never used */
 276 static void
 277 dwarf2_write_dw_lns_set_basic_block (FILE *f)
 278 {
 279         dwarf2_write_byte (f, DW_LNS_set_basic_block);
 280 }
 281 #endif
 282
 283 static void
 284 dwarf2_write_dw_lne_end_sequence (FILE *f)
 285 {
 286         dwarf2_write_byte (f, 0);
 287         dwarf2_write_byte (f, 1);
 288         dwarf2_write_byte (f, DW_LNE_end_sequence);
 289 }
 290
 291 static void
 292 dwarf2_write_dw_lne_set_address (FILE *f, void *address)
 293 {
 294         dwarf2_write_byte (f, 0);
 295         dwarf2_write_byte (f, sizeof (address) + 1);
 296         dwarf2_write_byte (f, DW_LNE_set_address);
 297         dwarf2_write_address (f, address);
 298 }
 299
 300 static void
 301 dwarf2_write_base_type (MonoDebugHandle *debug, int idx,
 302                         int type, int size, const gchar *name)
 303 {
 304         char buffer [BUFSIZ];
 305
 306         sprintf (buffer, "TYPE_%d", idx);
 307         dwarf2_write_label (debug->f, buffer);
 308         // DW_TAG_basic_type
 309         dwarf2_write_byte (debug->f, ABBREV_BASE_TYPE);
 310         dwarf2_write_string (debug->f, name);
 311         dwarf2_write_byte (debug->f, type);
 312         dwarf2_write_byte (debug->f, size);
 313 }
 314
 315 static void
 316 dwarf2_write_enum_value (MonoDebugHandle *debug, MonoClass *klass, int idx)
 317 {
 318         const void *ptr;
 319         guint32 field_index = idx + klass->field.first;
 320         guint32 crow;
 321
 322         crow = mono_metadata_get_constant_index (klass->image, MONO_TOKEN_FIELD_DEF | (field_index + 1));
 323         if (!crow) {
 324                 dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE);
 325                 dwarf2_write_string (debug->f, klass->fields [idx].name);
 326                 dwarf2_write_long (debug->f, 0);
 327                 return;
 328         }
 329
 330         crow = mono_metadata_decode_row_col (&klass->image->tables [MONO_TABLE_CONSTANT], crow-1,
 331                                              MONO_CONSTANT_VALUE);
 332
 333         ptr = 1 + mono_metadata_blob_heap (klass->image, crow);
 334
 335         switch (klass->enum_basetype->type) {
 336         case MONO_TYPE_BOOLEAN:
 337         case MONO_TYPE_U1:
 338                 dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_UNSIGNED);
 339                 dwarf2_write_string (debug->f, klass->fields [idx].name);
 340                 dwarf2_write_uleb128 (debug->f, *(guint8 *) ptr);
 341                 break;
 342         case MONO_TYPE_I1:
 343                 dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_SIGNED);
 344                 dwarf2_write_string (debug->f, klass->fields [idx].name);
 345                 dwarf2_write_sleb128 (debug->f, *(gint8 *) ptr);
 346                 break;
 347         case MONO_TYPE_CHAR:
 348         case MONO_TYPE_U2:
 349                 dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_UNSIGNED);
 350                 dwarf2_write_string (debug->f, klass->fields [idx].name);
 351                 dwarf2_write_uleb128 (debug->f, *(guint16 *) ptr);
 352                 break;
 353         case MONO_TYPE_I2:
 354                 dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_SIGNED);
 355                 dwarf2_write_string (debug->f, klass->fields [idx].name);
 356                 dwarf2_write_sleb128 (debug->f, *(gint16 *) ptr);
 357                 break;
 358         case MONO_TYPE_U4:
 359                 dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_UNSIGNED);
 360                 dwarf2_write_string (debug->f, klass->fields [idx].name);
 361                 dwarf2_write_uleb128 (debug->f, *(guint32 *) ptr);
 362                 break;
 363         case MONO_TYPE_I4:
 364                 dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_SIGNED);
 365                 dwarf2_write_string (debug->f, klass->fields [idx].name);
 366                 dwarf2_write_sleb128 (debug->f, *(gint32 *) ptr);
 367                 break;
 368         case MONO_TYPE_U8:
 369                 dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_UNSIGNED);
 370                 dwarf2_write_string (debug->f, klass->fields [idx].name);
 371                 dwarf2_write_uleb128 (debug->f, *(guint64 *) ptr);
 372                 break;
 373         case MONO_TYPE_I8:
 374                 dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_SIGNED);
 375                 dwarf2_write_string (debug->f, klass->fields [idx].name);
 376                 dwarf2_write_sleb128 (debug->f, *(gint64 *) ptr);
 377                 break;
 378         default:
 379                 g_assert_not_reached ();
 380         }
 381 }
 382
 383 static void
 384 dwarf2_write_enum_type (MonoDebugHandle *debug, MonoClass *klass)
 385 {
 386         int i;
 387
 388         // DW_TAG_enumeration_type
 389         dwarf2_write_byte (debug->f, ABBREV_ENUM_TYPE);
 390         dwarf2_write_string (debug->f, klass->name);
 391         dwarf2_write_long (debug->f, klass->instance_size - sizeof (MonoObject));
 392
 393         for (i = 0; i < klass->field.count; i++) {
 394                 if (klass->fields [i].type->attrs & FIELD_ATTRIBUTE_LITERAL)
 395                         dwarf2_write_enum_value (debug, klass, i);
 396         }
 397
 398         dwarf2_write_byte (debug->f, 0);
 399         // DW_TAG_enumeration_type ends here
 400 }
 401
 402 static void
 403 dwarf2_write_class_field (MonoDebugHandle *debug, MonoClass *klass, int idx,
 404                           int type_index, int start_offset)
 405 {
 406     MonoClass *subclass = mono_class_from_mono_type (klass->fields [idx].type);
 407     char start [BUFSIZ], end [BUFSIZ];
 408     static long label_index = 0;
 409
 410     sprintf (start, "DSF1_%ld", ++label_index);
 411     sprintf (end, "DSF2_%ld", label_index);
 412
 413     // DW_TAG_member
 414     dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 415     dwarf2_write_string (debug->f, klass->fields [idx].name);
 416     if (!subclass->valuetype)
 417         dwarf2_write_type_ptr_ref (debug->f, type_index);
 418     else
 419         dwarf2_write_type_ref (debug->f, type_index);
 420
 421     if (klass->fields [idx].type->attrs & FIELD_ATTRIBUTE_PRIVATE)
 422         dwarf2_write_byte (debug->f, DW_ACCESS_private);
 423     else if (klass->fields [idx].type->attrs & FIELD_ATTRIBUTE_FAMILY)
 424         dwarf2_write_byte (debug->f, DW_ACCESS_protected);
 425     else
 426         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 427
 428     dwarf2_write_section_size (debug->f, start, end);
 429     dwarf2_write_label (debug->f, start);
 430     dwarf2_write_byte (debug->f, DW_OP_constu);
 431     dwarf2_write_uleb128 (debug->f, klass->fields [idx].offset - start_offset);
 432     dwarf2_write_label (debug->f, end);
 433
 434     dwarf2_write_long (debug->f, subclass->instance_size);
 435 }
 436
 437 static void
 438 dwarf2_write_class_method (MonoDebugHandle *debug, MonoClass *klass, MonoMethod *method)
 439 {
 440         MonoType *ret_type = NULL;
 441         gchar **names;
 442         int i;
 443
 444         if (method->signature->ret->type != MONO_TYPE_VOID)
 445                 ret_type = method->signature->ret;
 446
 447         // DW_TAG_subprogram
 448         if (ret_type)
 449                 dwarf2_write_byte (debug->f, ABBREV_CLASS_METHOD_RETVAL);
 450         else
 451                 dwarf2_write_byte (debug->f, ABBREV_CLASS_METHOD);
 452         dwarf2_write_string (debug->f, method->name);
 453
 454         if (method->flags & METHOD_ATTRIBUTE_PUBLIC)
 455                 dwarf2_write_byte (debug->f, DW_ACCESS_public);
 456         else if (method->flags & METHOD_ATTRIBUTE_PRIVATE)
 457                 dwarf2_write_byte (debug->f, DW_ACCESS_private);
 458         else
 459                 dwarf2_write_byte (debug->f, DW_ACCESS_protected);
 460
 461         if (method->flags & METHOD_ATTRIBUTE_VIRTUAL)
 462                 dwarf2_write_byte (debug->f, DW_VIRTUALITY_pure_virtual);
 463         else
 464                 dwarf2_write_byte (debug->f, DW_VIRTUALITY_none);
 465
 466         dwarf2_write_byte (debug->f, DW_CC_nocall);
 467
 468         if (ret_type) {
 469                 MonoClass *k = mono_class_from_mono_type (ret_type);
 470                 int type_index = mono_debug_get_type (debug, k);
 471                 dwarf2_write_type_ref (debug->f, type_index);
 472         }
 473
 474         if (method->signature->hasthis) {
 475                 int type_index = mono_debug_get_type (debug, klass);
 476
 477                 dwarf2_write_byte (debug->f, ABBREV_ARTIFICIAL_PARAMETER);
 478                 dwarf2_write_string (debug->f, "this");
 479                 dwarf2_write_type_ptr_ref (debug->f, type_index);
 480                 dwarf2_write_byte (debug->f, 1);
 481         }
 482
 483         names = g_new (char *, method->signature->param_count);
 484         mono_method_get_param_names (method, (const char **) names);
 485
 486         for (i = 0; i < method->signature->param_count; i++) {
 487                 MonoType *subtype = method->signature->params [i];
 488                 MonoClass *subklass = mono_class_from_mono_type (subtype);
 489                 int type_index = mono_debug_get_type (debug, subklass);
 490
 491                 // DW_TAG_formal_parameter
 492                 dwarf2_write_byte (debug->f, ABBREV_FORMAL_PARAMETER);
 493                 dwarf2_write_string (debug->f, names [i]);
 494                 if (subklass->valuetype)
 495                         dwarf2_write_type_ref (debug->f, type_index);
 496                 else
 497                         dwarf2_write_type_ptr_ref (debug->f, type_index);
 498         }
 499
 500         g_free (names);
 501
 502         dwarf2_write_byte (debug->f, 0);
 503         // DW_TAG_subprogram ends here
 504 }
 505
 506 static void
 507 dwarf2_write_struct_type (MonoDebugHandle *debug, MonoClass *klass)
 508 {
 509         guint32 *idxs;
 510         int i;
 511
 512         idxs = g_new0 (guint32, klass->field.last - klass->field.first + 1);
 513         for (i = 0; i < klass->field.count; i++) {
 514                 MonoClass *subclass = mono_class_from_mono_type (klass->fields [i].type);
 515                 idxs [i] = mono_debug_get_type (debug, subclass);
 516         }
 517
 518         // DW_TAG_structure_type
 519         dwarf2_write_byte (debug->f, ABBREV_STRUCT_TYPE);
 520         dwarf2_write_string (debug->f, klass->name);
 521         dwarf2_write_long (debug->f, klass->instance_size - sizeof (MonoObject));
 522
 523         for (i = 0; i < klass->field.count; i++)
 524                 dwarf2_write_class_field (debug, klass, i, idxs [i], sizeof (MonoObject));
 525
 526         dwarf2_write_byte (debug->f, 0);
 527         // DW_TAG_structure_type ends here
 528
 529         g_free (idxs);
 530 }
 531
 532 static void
 533 dwarf2_write_class_type (MonoDebugHandle *debug, MonoClass *klass)
 534 {
 535         guint32 *idxs;
 536         int i;
 537
 538         idxs = g_new0 (guint32, klass->field.last - klass->field.first + 1);
 539         for (i = 0; i < klass->field.count; i++) {
 540                 MonoClass *subclass = mono_class_from_mono_type (klass->fields [i].type);
 541                 idxs [i] = mono_debug_get_type (debug, subclass);
 542         }
 543
 544         // DW_TAG_structure_type
 545         dwarf2_write_byte (debug->f, ABBREV_CLASS_TYPE);
 546         dwarf2_write_string (debug->f, klass->name);
 547         dwarf2_write_long (debug->f, klass->instance_size);
 548         if (klass->flags & TYPE_ATTRIBUTE_PUBLIC)
 549                 dwarf2_write_byte (debug->f, DW_ACCESS_public);
 550         else
 551                 dwarf2_write_byte (debug->f, DW_ACCESS_private);
 552
 553         if (klass->parent && klass->parent->byval_arg.type == MONO_TYPE_CLASS) {
 554                 guint32 parent_index = mono_debug_get_type (debug, klass->parent);
 555
 556                 // DW_TAG_inheritance
 557                 dwarf2_write_byte (debug->f, ABBREV_CLASS_INHERITANCE);
 558                 dwarf2_write_type_ref (debug->f, parent_index);
 559                 if (klass->parent->flags & TYPE_ATTRIBUTE_PUBLIC)
 560                         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 561                 else
 562                         dwarf2_write_byte (debug->f, DW_ACCESS_private);
 563         }
 564
 565         for (i = 0; i < klass->field.count; i++)
 566                 dwarf2_write_class_field (debug, klass, i, idxs [i], 0);
 567
 568         for (i = 0; i < klass->method.count; i++) {
 569                 if (!strcmp (klass->methods [i]->name, ".ctor"))
 570                         continue;
 571
 572                 dwarf2_write_class_method (debug, klass, klass->methods [i]);
 573         }
 574
 575         dwarf2_write_byte (debug->f, 0);
 576         // DW_TAG_class_type ends here
 577
 578         g_free (idxs);
 579 }
 580
 581 static void
 582 dwarf2_write_array (MonoDebugHandle *debug, const gchar *name, MonoClass *element_class,
 583                     int rank, int idx)
 584 {
 585         unsigned long uint32_index = mono_debug_get_type (debug, mono_defaults.uint32_class);
 586         char buffer [BUFSIZ];
 587         MonoArray array;
 588
 589         dwarf2_write_byte (debug->f, ABBREV_STRUCT_TYPE);
 590         dwarf2_write_string (debug->f, name);
 591         dwarf2_write_long (debug->f, sizeof (MonoArray));
 592
 593         // DW_TAG_structure_type
 594         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 595         dwarf2_write_string (debug->f, "max_length");
 596         dwarf2_write_type_ref (debug->f, uint32_index);
 597         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 598         dwarf2_write_long (debug->f, 2);
 599         dwarf2_write_byte (debug->f, DW_OP_const1u);
 600         dwarf2_write_byte (debug->f, (guchar *) &array.max_length - (guchar *) &array);
 601         dwarf2_write_long (debug->f, 4);
 602
 603         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 604         dwarf2_write_string (debug->f, "bounds");
 605         dwarf2_write_relative_ref (debug->f, "ARRAY_BOUNDS_PTR", idx);
 606         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 607         dwarf2_write_long (debug->f, 2);
 608         dwarf2_write_byte (debug->f, DW_OP_const1u);
 609         dwarf2_write_byte (debug->f, (guchar *) &array.bounds - (guchar *) &array);
 610         dwarf2_write_long (debug->f, 4);
 611
 612         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 613         dwarf2_write_string (debug->f, "vector");
 614         dwarf2_write_relative_ref (debug->f, "ARRAY_PTR", idx);
 615         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 616         dwarf2_write_long (debug->f, 2);
 617         dwarf2_write_byte (debug->f, DW_OP_const1u);
 618         dwarf2_write_byte (debug->f, (guchar *) &array.vector - (guchar *) &array);
 619         dwarf2_write_long (debug->f, 4);
 620
 621         dwarf2_write_byte (debug->f, 0);
 622         // DW_TAG_structure_type ends here
 623
 624         sprintf (buffer, "ARRAY_BOUNDS_PTR_%u", idx);
 625         dwarf2_write_label (debug->f, buffer);
 626
 627         // DW_TAG_pointer_type
 628         dwarf2_write_byte (debug->f, ABBREV_POINTER_TYPE);
 629         dwarf2_write_relative_ref (debug->f, "ARRAY_BOUNDS", idx);
 630
 631         sprintf (buffer, "ARRAY_BOUNDS_%u", idx);
 632         dwarf2_write_label (debug->f, buffer);
 633
 634         // DW_TAG_array_type
 635         dwarf2_write_byte (debug->f, ABBREV_ARRAY);
 636         dwarf2_write_string (debug->f, name);
 637         dwarf2_write_type_ref (debug->f, uint32_index);
 638         dwarf2_write_long (debug->f, rank * 2);
 639
 640         // DW_TAG_subrange_type
 641         dwarf2_write_byte (debug->f, ABBREV_SUBRANGE);
 642         dwarf2_write_long (debug->f, 0);
 643         dwarf2_write_long (debug->f, rank-1);
 644         dwarf2_write_long (debug->f, rank);
 645
 646         // DW_TAG_subrange_type
 647         dwarf2_write_byte (debug->f, ABBREV_SUBRANGE);
 648         dwarf2_write_long (debug->f, 0);
 649         dwarf2_write_long (debug->f, 1);
 650         dwarf2_write_long (debug->f, 2);
 651
 652         dwarf2_write_byte (debug->f, 0);
 653         // DW_TAG_array_type ends here
 654
 655         sprintf (buffer, "ARRAY_PTR_%u", idx);
 656         dwarf2_write_label (debug->f, buffer);
 657
 658         // DW_TAG_array_type
 659         dwarf2_write_byte (debug->f, ABBREV_SIMPLE_ARRAY);
 660         dwarf2_write_string (debug->f, name);
 661         if (element_class->valuetype)
 662                 dwarf2_write_type_ref (debug->f, mono_debug_get_type (debug, element_class));
 663         else
 664                 dwarf2_write_type_ptr_ref (debug->f, mono_debug_get_type (debug, element_class));
 665 }
 666
 667 static void
 668 dwarf2_write_array_type (MonoDebugHandle *debug, MonoClass *klass, int idx)
 669 {
 670         char buffer [BUFSIZ], *name;
 671         int i;
 672
 673         buffer[0] = '\0';
 674         for (i = 0; i < klass->rank; i++)
 675                 strcat (buffer, "[]");
 676
 677         name = g_strdup_printf ("%s%s", klass->element_class->name, buffer);
 678
 679         dwarf2_write_array (debug, name, klass->element_class, klass->rank, idx);
 680
 681         g_free (name);
 682 }
 683
 684 static void
 685 dwarf2_write_string_type (MonoDebugHandle *debug, MonoClass *klass, int idx)
 686 {
 687         unsigned long uint32_index = mono_debug_get_type (debug, mono_defaults.uint32_class);
 688         char buffer [BUFSIZ];
 689         MonoString string;
 690
 691         // DW_TAG_structure_type
 692         dwarf2_write_byte (debug->f, ABBREV_STRUCT_TYPE);
 693         dwarf2_write_string (debug->f, klass->name);
 694         dwarf2_write_long (debug->f, sizeof (MonoString));
 695
 696         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 697         dwarf2_write_string (debug->f, "length");
 698         dwarf2_write_type_ref (debug->f, uint32_index);
 699         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 700         dwarf2_write_long (debug->f, 2);
 701         dwarf2_write_byte (debug->f, DW_OP_const1u);
 702         dwarf2_write_byte (debug->f, (guchar *) &string.length - (guchar *) &string);
 703         dwarf2_write_long (debug->f, 4);
 704
 705         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 706         dwarf2_write_string (debug->f, "chars");
 707         dwarf2_write_relative_ref (debug->f, "CHARS", idx);
 708         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 709         dwarf2_write_long (debug->f, 2);
 710         dwarf2_write_byte (debug->f, DW_OP_const1u);
 711         dwarf2_write_byte (debug->f, (guchar *) &string.chars - (guchar *) &string);
 712         dwarf2_write_long (debug->f, 4);
 713
 714         dwarf2_write_byte (debug->f, 0);
 715         // DW_TAG_structure_type ends here
 716
 717         sprintf (buffer, "CHARS_%u", idx);
 718         dwarf2_write_label (debug->f, buffer);
 719
 720         dwarf2_write_byte (debug->f, ABBREV_SIMPLE_ARRAY);
 721         dwarf2_write_string (debug->f, "Char[]");
 722         dwarf2_write_type_ref (debug->f, mono_debug_get_type (debug, mono_defaults.char_class));
 723 }
 724
 725 static void
 726 dwarf2_write_class (MonoDebugHandle *debug, MonoClass *klass, int idx)
 727 {
 728         char buffer [BUFSIZ];
 729         int print = 0;
 730
 731         if (!strncmp (klass->name, "My", 2)) {
 732                 g_message (G_STRLOC ": %s - %s - %x", klass->name_space, klass->name, klass->flags);
 733                 print = 1;
 734                 // G_BREAKPOINT ();
 735         }
 736
 737         if (!klass->valuetype) {
 738                 sprintf (buffer, "TYPE_PTR_%u", idx);
 739                 dwarf2_write_label (debug->f, buffer);
 740
 741                 // DW_TAG_pointer_type
 742                 dwarf2_write_byte (debug->f, ABBREV_POINTER_TYPE);
 743                 dwarf2_write_type_ref (debug->f, idx);
 744         }
 745
 746         sprintf (buffer, "TYPE_%u", idx);
 747         dwarf2_write_label (debug->f, buffer);
 748
 749         if (klass->enumtype) {
 750                 dwarf2_write_enum_type (debug, klass);
 751                 return;
 752         }
 753
 754         switch (klass->byval_arg.type) {
 755         case MONO_TYPE_VALUETYPE:
 756                 dwarf2_write_struct_type (debug, klass);
 757                 break;
 758         case MONO_TYPE_CLASS:
 759                 dwarf2_write_class_type (debug, klass);
 760                 break;
 761         case MONO_TYPE_SZARRAY:
 762         case MONO_TYPE_ARRAY:
 763                 dwarf2_write_array_type (debug, klass, idx);
 764                 break;
 765         case MONO_TYPE_STRING:
 766                 dwarf2_write_string_type (debug, klass, idx);
 767                 break;
 768         default:
 769 #if 0
 770                 g_message (G_STRLOC ": %s.%s - 0x%x - 0x%x", klass->name_space, klass->name,
 771                            klass->byval_arg.type, klass->flags);
 772 #endif
 773
 774                 // DW_TAG_basic_type
 775                 dwarf2_write_byte (debug->f, ABBREV_BASE_TYPE);
 776                 dwarf2_write_string (debug->f, klass->name);
 777                 dwarf2_write_byte (debug->f, DW_ATE_address);
 778                 dwarf2_write_byte (debug->f, 0);
 779                 break;
 780         }
 781 }
 782
 783 static void
 784 dwarf2_write_variable_location (MonoDebugHandle *debug, MonoDebugVarInfo *var)
 785 {
 786         switch (var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS) {
 787         case MONO_DEBUG_VAR_ADDRESS_MODE_STACK:
 788                 /*
 789                  * Variable is on the stack.
 790                  *
 791                  * If `index' is zero, use the normal frame register.  Otherwise, bits
 792                  * 0..4 of `index' contain the frame register.
 793                  *
 794                  */
 795
 796                 if (!var->index)
 797                         /* Use the normal frame register (%ebp on the i386). */
 798                         dwarf2_write_byte (debug->f, DW_OP_fbreg);
 799                 else
 800                         /* Use a custom frame register. */
 801                         dwarf2_write_byte (debug->f, DW_OP_breg0 + (var->index & 0x001f));
 802                 dwarf2_write_sleb128 (debug->f, var->offset);
 803                 break;
 804
 805         case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
 806                 /*
 807                  * Variable is in the register whose number is contained in bits 0..4
 808                  * of `index'.
 809                  *
 810                  */
 811                 dwarf2_write_byte (debug->f, DW_OP_reg0 + (var->index & 0x001f));
 812                 if (var->offset) {
 813                         dwarf2_write_byte (debug->f, DW_OP_consts);
 814                         dwarf2_write_sleb128 (debug->f, var->offset);
 815                         dwarf2_write_byte (debug->f, DW_OP_plus);
 816                 }
 817                 break;
 818
 819         case MONO_DEBUG_VAR_ADDRESS_MODE_TWO_REGISTERS:
 820                 /*
 821                  * Variable is in two registers whose numbers are in bits 0..4 and 5..9 of
 822                  * the `index' field.
 823                  */
 824                 dwarf2_write_byte (debug->f, DW_OP_reg0 + (var->index & 0x001f));
 825                 dwarf2_write_byte (debug->f, DW_OP_piece);
 826                 dwarf2_write_byte (debug->f, sizeof (int));
 827
 828                 dwarf2_write_byte (debug->f, DW_OP_reg0 + ((var->index & 0x1f0) >> 5));
 829                 dwarf2_write_byte (debug->f, DW_OP_piece);
 830                 dwarf2_write_byte (debug->f, sizeof (int));
 831
 832                 break;
 833
 834         default:
 835                 g_assert_not_reached ();
 836         }
 837 }
 838
 839 static void
 840 dwarf2_write_parameter (MonoDebugHandle *debug, DebugMethodInfo *minfo, const gchar *name,
 841                         MonoDebugVarInfo *var, MonoClass *klass)
 842 {
 843         static long label_index = 0;
 844         int type_index = mono_debug_get_type (debug, klass);
 845         char start [BUFSIZ], end [BUFSIZ];
 846
 847         sprintf (start, "DT1_%ld", ++label_index);
 848         sprintf (end, "DT2_%ld", label_index);
 849
 850         // DW_TAG_format_parameter
 851         dwarf2_write_byte (debug->f, ABBREV_PARAMETER);
 852         dwarf2_write_string (debug->f, name);
 853         if (klass->valuetype)
 854                 dwarf2_write_type_ref (debug->f, type_index);
 855         else
 856                 dwarf2_write_type_ptr_ref (debug->f, type_index);
 857         dwarf2_write_section_size (debug->f, start, end);
 858         dwarf2_write_label (debug->f, start);
 859         dwarf2_write_variable_location (debug, var);
 860         dwarf2_write_label (debug->f, end);
 861         dwarf2_write_long (debug->f, minfo->method_info.prologue_end);
 862 }
 863
 864 static void
 865 dwarf2_write_variable (MonoDebugHandle *debug, DebugMethodInfo *minfo, const gchar *name,
 866                        MonoDebugVarInfo *var, MonoClass *klass)
 867 {
 868         static long label_index = 0;
 869         int type_index = mono_debug_get_type (debug, klass);
 870         char start [BUFSIZ], end [BUFSIZ];
 871
 872         sprintf (start, "DT3_%ld", ++label_index);
 873         sprintf (end, "DT4_%ld", label_index);
 874
 875         // DW_TAG_formal_parameter
 876         dwarf2_write_byte (debug->f, ABBREV_LOCAL_VARIABLE);
 877         dwarf2_write_string (debug->f, name);
 878         if (klass->valuetype)
 879                 dwarf2_write_type_ref (debug->f, type_index);
 880         else
 881                 dwarf2_write_type_ptr_ref (debug->f, type_index);
 882         dwarf2_write_section_size (debug->f, start, end);
 883         dwarf2_write_label (debug->f, start);
 884         dwarf2_write_variable_location (debug, var);
 885         dwarf2_write_label (debug->f, end);
 886         dwarf2_write_address (debug->f, minfo->method_info.code_start + var->begin_scope);
 887         dwarf2_write_address (debug->f, minfo->method_info.code_start + var->end_scope);
 888 }
 889
 890 static void
 891 write_method_lines_dwarf2 (MonoDebugHandle *debug, DebugMethodInfo *minfo)
 892 {
 893         guint32 st_line = 0;
 894         gpointer st_address = 0;
 895         int i;
 896
 897         if (!minfo->line_numbers)
 898                 return;
 899
 900         // Start of statement program
 901         dwarf2_write_dw_lns_set_file (debug->f, minfo->source_file);
 902         dwarf2_write_dw_lns_advance_line (debug->f, minfo->start_line - 1);
 903         dwarf2_write_dw_lne_set_address (debug->f, minfo->method_info.code_start);
 904         dwarf2_write_dw_lns_negate_stmt (debug->f);
 905         dwarf2_write_dw_lns_copy (debug->f);
 906
 907         st_line = minfo->start_line;
 908         st_address = minfo->method_info.code_start;
 909
 910         for (i = 1; i < minfo->line_numbers->len; i++) {
 911                 DebugLineNumberInfo *lni = g_ptr_array_index (minfo->line_numbers, i);
 912                 gint32 line_inc, addr_inc, opcode;
 913                 int used_standard_opcode = 0;
 914
 915                 line_inc = lni->line - st_line;
 916                 addr_inc = (char *)lni->address - (char *)st_address;
 917
 918                 if (addr_inc < 0) {
 919                         dwarf2_write_dw_lne_set_address (debug->f, lni->address);
 920                         used_standard_opcode = 1;
 921                 } else if (addr_inc && !line_inc) {
 922                         dwarf2_write_dw_lns_advance_pc (debug->f, addr_inc);
 923                         used_standard_opcode = 1;
 924                 }
 925
 926                 if ((line_inc < 0) || (line_inc >= line_range)) {
 927                         dwarf2_write_dw_lns_advance_pc (debug->f, addr_inc);
 928                         dwarf2_write_dw_lns_advance_line (debug->f, line_inc);
 929                         used_standard_opcode = 1;
 930                 } else if (line_inc > 0) {
 931                         opcode = (line_inc - 1) + (line_range * addr_inc) + opcode_base;
 932                         g_assert (opcode >= 0);
 933
 934                         if (opcode >= 256) {
 935                                 dwarf2_write_dw_lns_advance_pc (debug->f, addr_inc);
 936                                 dwarf2_write_dw_lns_advance_line (debug->f, line_inc);
 937                                 used_standard_opcode = 1;
 938                         } else
 939                                 dwarf2_write_byte (debug->f, opcode);
 940                 }
 941
 942                 if (used_standard_opcode)
 943                         dwarf2_write_dw_lns_copy (debug->f);
 944
 945                 st_line += line_inc;
 946                 st_address = (char *)st_address + addr_inc;
 947         }
 948
 949         dwarf2_write_dw_lne_set_address (debug->f,
 950                                          (char *)minfo->method_info.code_start +
 951                                          minfo->method_info.epilogue_begin);
 952         dwarf2_write_dw_lns_advance_line (debug->f, minfo->last_line - st_line);
 953         dwarf2_write_dw_lns_copy (debug->f);
 954
 955         dwarf2_write_dw_lns_copy (debug->f);
 956         dwarf2_write_dw_lne_end_sequence (debug->f);
 957 }
 958
 959 static void
 960 write_method_lines_func (gpointer key, gpointer value, gpointer user_data)
 961 {
 962         write_method_lines_dwarf2 (user_data, value);
 963 }
 964
 965 static void
 966 write_line_numbers (MonoDebugHandle *debug)
 967 {
 968         /* State machine registers. */
 969         int i;
 970
 971         // Line number information.
 972         dwarf2_write_section_start (debug->f, "debug_line");
 973         dwarf2_write_label (debug->f, "debug_line_b");
 974         dwarf2_write_section_size (debug->f, "DL1", "debug_line_e");
 975         dwarf2_write_label (debug->f, "DL1");
 976         dwarf2_write_2byte (debug->f, 2);
 977         dwarf2_write_section_size (debug->f, "DL2", "DL3");
 978         dwarf2_write_label (debug->f, "DL2");
 979         // minimum instruction length
 980         dwarf2_write_byte (debug->f, 1);
 981         // default is statement
 982         dwarf2_write_byte (debug->f, 1);
 983         // line base
 984         dwarf2_write_byte (debug->f, line_base);
 985         // line range
 986         dwarf2_write_byte (debug->f, line_range);
 987         // opcode base
 988         dwarf2_write_byte (debug->f, opcode_base);
 989         // standard opcode sizes
 990         for (i = 1; i < opcode_base; i++)
 991                 dwarf2_write_byte (debug->f, standard_opcode_sizes [i]);
 992         // include directories
 993         dwarf2_write_byte (debug->f, 0);
 994         // file names
 995         for (i = 0; i < debug->source_files->len; i++) {
 996                 gchar *source_file = g_ptr_array_index (debug->source_files, i);
 997                 dwarf2_write_string (debug->f, source_file);
 998                 dwarf2_write_uleb128 (debug->f, 0);
 999                 dwarf2_write_uleb128 (debug->f, 0);
1000                 dwarf2_write_uleb128 (debug->f, 0);
1001         }
1002         // end of list
1003         dwarf2_write_byte (debug->f, 0);
1004         dwarf2_write_label (debug->f, "DL3");
1005
1006         g_hash_table_foreach (debug->methods, write_method_lines_func, debug);
1007
1008         dwarf2_write_label (debug->f, "debug_line_e");
1009 }
1010
1011 static void
1012 write_class_dwarf2 (MonoDebugHandle *debug, MonoClass *klass, guint idx)
1013 {
1014         switch (klass->byval_arg.type) {
1015         case MONO_TYPE_VOID:
1016                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 0, "Void");
1017                 break;
1018         case MONO_TYPE_BOOLEAN:
1019                 dwarf2_write_base_type (debug, idx, DW_ATE_boolean, 1, "Boolean");
1020                 break;
1021         case MONO_TYPE_CHAR:
1022                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned_char, 2, "Char");
1023                 break;
1024         case MONO_TYPE_I1:
1025                 dwarf2_write_base_type (debug, idx, DW_ATE_signed, 1, "SByte");
1026                 break;
1027         case MONO_TYPE_U1:
1028                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 1, "Byte");
1029                 break;
1030         case MONO_TYPE_I2:
1031                 dwarf2_write_base_type (debug, idx, DW_ATE_signed, 2, "Int16");
1032                 break;
1033         case MONO_TYPE_U2:
1034                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 2, "UInt16");
1035                 break;
1036         case MONO_TYPE_I4:
1037                 dwarf2_write_base_type (debug, idx, DW_ATE_signed, 4, "Int32");
1038                 break;
1039         case MONO_TYPE_U4:
1040                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 4, "UInt32");
1041                 break;
1042         case MONO_TYPE_I8:
1043                 dwarf2_write_base_type (debug, idx, DW_ATE_signed, 8, "Int64");
1044                 break;
1045         case MONO_TYPE_U8:
1046                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 8, "UInt64");
1047                 break;
1048         case MONO_TYPE_R4:
1049                 dwarf2_write_base_type (debug, idx, DW_ATE_float, 4, "Float");
1050                 break;
1051         case MONO_TYPE_R8:
1052                 dwarf2_write_base_type (debug, idx, DW_ATE_float, 8, "Double");
1053                 break;
1054         default:
1055                 dwarf2_write_class (debug, klass, idx);
1056                 break;
1057         }
1058 }
1059
1060 static void
1061 write_class (gpointer key, gpointer value, gpointer user_data)
1062 {
1063         write_class_dwarf2 (user_data, key, GPOINTER_TO_INT (value));
1064 }
1065
1066 static void
1067 write_method_dwarf2 (MonoDebugHandle *debug, DebugMethodInfo *minfo)
1068 {
1069         int is_external = 0, i;
1070         MonoType *ret_type = NULL;
1071         gchar **names;
1072
1073         if (minfo->method_info.method->signature->ret->type != MONO_TYPE_VOID)
1074                 ret_type = minfo->method_info.method->signature->ret;
1075
1076         // DW_TAG_subprogram
1077         if (ret_type)
1078                 dwarf2_write_byte (debug->f, ABBREV_SUBPROGRAM_RETVAL);
1079         else
1080                 dwarf2_write_byte (debug->f, ABBREV_SUBPROGRAM);
1081         dwarf2_write_string (debug->f, minfo->name);
1082         dwarf2_write_byte (debug->f, is_external);
1083         dwarf2_write_address (debug->f, minfo->method_info.code_start);
1084         dwarf2_write_address (debug->f, (char *)minfo->method_info.code_start + minfo->method_info.code_size);
1085         dwarf2_write_byte (debug->f, DW_CC_nocall);
1086         if (ret_type) {
1087                 MonoClass *klass = mono_class_from_mono_type (ret_type);
1088                 int type_index = mono_debug_get_type (debug, klass);
1089                 dwarf2_write_type_ref (debug->f, type_index);
1090         }
1091
1092         if (minfo->method_info.method->signature->hasthis)
1093                 dwarf2_write_parameter (debug, minfo, "this", minfo->method_info.this_var,
1094                                         minfo->method_info.method->klass);
1095
1096         names = g_new (char *, minfo->method_info.method->signature->param_count);
1097         mono_method_get_param_names (minfo->method_info.method, (const char **) names);
1098
1099         for (i = 0; i < minfo->method_info.num_params; i++) {
1100                 MonoType *type = minfo->method_info.method->signature->params [i];
1101                 MonoClass *klass = mono_class_from_mono_type (type);
1102
1103                 dwarf2_write_parameter (debug, minfo, names [i], &minfo->method_info.params [i], klass);
1104         }
1105
1106         g_free (names);
1107
1108         for (i = 0; i < minfo->method_info.num_locals; i++) {
1109                 MonoMethodHeader *header = ((MonoMethodNormal*) minfo->method_info.method)->header;
1110                 MonoClass *klass = mono_class_from_mono_type (header->locals [i]);
1111                 char name [BUFSIZ];
1112
1113                 sprintf (name, "V_%d", i);
1114                 dwarf2_write_variable (debug, minfo, name, &minfo->method_info.locals [i], klass);
1115         }
1116
1117         dwarf2_write_byte (debug->f, 0);
1118         // DW_TAG_subprogram ends here
1119 }
1120
1121 static void
1122 write_method_func (gpointer key, gpointer value, gpointer user_data)
1123 {
1124         write_method_dwarf2 (user_data, value);
1125 }
1126
1127 void
1128 mono_debug_write_dwarf2 (MonoDebugHandle *debug)
1129 {
1130         if (!(debug->f = fopen (debug->filename, "w"))) {
1131                 g_warning ("Can't create dwarf file `%s': %s", debug->filename, g_strerror (errno));
1132                 return;
1133         }
1134
1135         // Produce assembler code which is free of comments and extra whitespaces.
1136         fprintf (debug->f, "#NOAPP\n");
1137
1138         // DWARF 2 Abbreviation table.
1139         dwarf2_write_section_start (debug->f, "debug_abbrev");
1140         dwarf2_write_label (debug->f, "debug_abbrev");
1141
1142         dwarf2_write_byte (debug->f, ABBREV_COMPILE_UNIT);
1143         dwarf2_write_byte (debug->f, DW_TAG_compile_unit);
1144         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1145         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1146         dwarf2_write_pair (debug->f, DW_AT_language, DW_FORM_data2);
1147         dwarf2_write_pair (debug->f, DW_AT_producer, DW_FORM_string);
1148         dwarf2_write_pair (debug->f, DW_AT_stmt_list, DW_FORM_ref4);
1149         dwarf2_write_pair (debug->f, 0, 0);
1150
1151         dwarf2_write_byte (debug->f, ABBREV_SUBPROGRAM);
1152         dwarf2_write_byte (debug->f, DW_TAG_subprogram);
1153         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1154         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1155         dwarf2_write_pair (debug->f, DW_AT_external, DW_FORM_flag);
1156         dwarf2_write_pair (debug->f, DW_AT_low_pc, DW_FORM_addr);
1157         dwarf2_write_pair (debug->f, DW_AT_high_pc, DW_FORM_addr);
1158         dwarf2_write_pair (debug->f, DW_AT_calling_convention, DW_FORM_data1);
1159         dwarf2_write_pair (debug->f, 0, 0);
1160
1161         dwarf2_write_byte (debug->f, ABBREV_SUBPROGRAM_RETVAL);
1162         dwarf2_write_byte (debug->f, DW_TAG_subprogram);
1163         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1164         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1165         dwarf2_write_pair (debug->f, DW_AT_external, DW_FORM_flag);
1166         dwarf2_write_pair (debug->f, DW_AT_low_pc, DW_FORM_addr);
1167         dwarf2_write_pair (debug->f, DW_AT_high_pc, DW_FORM_addr);
1168         dwarf2_write_pair (debug->f, DW_AT_calling_convention, DW_FORM_data1);
1169         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1170         dwarf2_write_pair (debug->f, 0, 0);
1171
1172         dwarf2_write_byte (debug->f, ABBREV_BASE_TYPE);
1173         dwarf2_write_byte (debug->f, DW_TAG_base_type);
1174         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1175         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1176         dwarf2_write_pair (debug->f, DW_AT_encoding, DW_FORM_data1);
1177         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data1);
1178         dwarf2_write_pair (debug->f, 0, 0);
1179
1180         dwarf2_write_byte (debug->f, ABBREV_FORMAL_PARAMETER);
1181         dwarf2_write_byte (debug->f, DW_TAG_formal_parameter);
1182         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1183         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1184         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1185         dwarf2_write_pair (debug->f, 0, 0);
1186
1187         dwarf2_write_byte (debug->f, ABBREV_ARTIFICIAL_PARAMETER);
1188         dwarf2_write_byte (debug->f, DW_TAG_formal_parameter);
1189         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1190         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1191         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1192         dwarf2_write_pair (debug->f, DW_AT_artificial, DW_FORM_data1);
1193         dwarf2_write_pair (debug->f, 0, 0);
1194
1195         dwarf2_write_byte (debug->f, ABBREV_PARAMETER);
1196         dwarf2_write_byte (debug->f, DW_TAG_formal_parameter);
1197         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1198         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1199         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1200         dwarf2_write_pair (debug->f, DW_AT_location, DW_FORM_block4);
1201         dwarf2_write_pair (debug->f, DW_AT_start_scope, DW_FORM_data4);
1202         dwarf2_write_pair (debug->f, 0, 0);
1203
1204         dwarf2_write_byte (debug->f, ABBREV_LOCAL_VARIABLE);
1205         dwarf2_write_byte (debug->f, DW_TAG_variable);
1206         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1207         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1208         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1209         dwarf2_write_pair (debug->f, DW_AT_location, DW_FORM_block4);
1210         dwarf2_write_pair (debug->f, DW_AT_start_scope, DW_FORM_addr);
1211         dwarf2_write_pair (debug->f, DW_AT_end_scope, DW_FORM_addr);
1212         dwarf2_write_pair (debug->f, 0, 0);
1213
1214         dwarf2_write_byte (debug->f, ABBREV_STRUCT_TYPE);
1215         dwarf2_write_byte (debug->f, DW_TAG_structure_type);
1216         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1217         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1218         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data4);
1219         dwarf2_write_pair (debug->f, 0, 0);
1220
1221         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
1222         dwarf2_write_byte (debug->f, DW_TAG_member);
1223         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1224         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1225         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1226         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1227         dwarf2_write_pair (debug->f, DW_AT_data_member_location, DW_FORM_block4);
1228         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data4);
1229         dwarf2_write_pair (debug->f, 0, 0);
1230
1231         dwarf2_write_byte (debug->f, ABBREV_STRUCT_ACCESS);
1232         dwarf2_write_byte (debug->f, DW_TAG_access_declaration);
1233         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1234         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1235         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1236         dwarf2_write_pair (debug->f, 0, 0);
1237
1238         dwarf2_write_byte (debug->f, ABBREV_ENUM_TYPE);
1239         dwarf2_write_byte (debug->f, DW_TAG_enumeration_type);
1240         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1241         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1242         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data4);
1243         dwarf2_write_pair (debug->f, 0, 0);
1244
1245         dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE);
1246         dwarf2_write_byte (debug->f, DW_TAG_enumerator);
1247         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1248         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1249         dwarf2_write_pair (debug->f, DW_AT_const_value, DW_FORM_data4);
1250         dwarf2_write_pair (debug->f, 0, 0);
1251
1252         dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_UNSIGNED);
1253         dwarf2_write_byte (debug->f, DW_TAG_enumerator);
1254         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1255         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1256         dwarf2_write_pair (debug->f, DW_AT_const_value, DW_FORM_udata);
1257         dwarf2_write_pair (debug->f, 0, 0);
1258
1259         dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_SIGNED);
1260         dwarf2_write_byte (debug->f, DW_TAG_enumerator);
1261         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1262         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1263         dwarf2_write_pair (debug->f, DW_AT_const_value, DW_FORM_sdata);
1264         dwarf2_write_pair (debug->f, 0, 0);
1265
1266         dwarf2_write_byte (debug->f, ABBREV_CLASS_TYPE);
1267         dwarf2_write_byte (debug->f, DW_TAG_class_type);
1268         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1269         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1270         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data4);
1271         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1272         dwarf2_write_pair (debug->f, 0, 0);
1273
1274         dwarf2_write_byte (debug->f, ABBREV_CLASS_INHERITANCE);
1275         dwarf2_write_byte (debug->f, DW_TAG_inheritance);
1276         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1277         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1278         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1279         dwarf2_write_pair (debug->f, 0, 0);
1280
1281         dwarf2_write_byte (debug->f, ABBREV_POINTER_TYPE);
1282         dwarf2_write_byte (debug->f, DW_TAG_pointer_type);
1283         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1284         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1285         dwarf2_write_pair (debug->f, 0, 0);
1286
1287         dwarf2_write_byte (debug->f, ABBREV_CLASS_METHOD);
1288         dwarf2_write_byte (debug->f, DW_TAG_subprogram);
1289         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1290         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1291         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1292         dwarf2_write_pair (debug->f, DW_AT_virtuality, DW_FORM_data1);
1293         dwarf2_write_pair (debug->f, DW_AT_calling_convention, DW_FORM_data1);
1294         dwarf2_write_pair (debug->f, 0, 0);
1295
1296         dwarf2_write_byte (debug->f, ABBREV_CLASS_METHOD_RETVAL);
1297         dwarf2_write_byte (debug->f, DW_TAG_subprogram);
1298         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1299         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1300         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1301         dwarf2_write_pair (debug->f, DW_AT_virtuality, DW_FORM_data1);
1302         dwarf2_write_pair (debug->f, DW_AT_calling_convention, DW_FORM_data1);
1303         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1304         dwarf2_write_pair (debug->f, 0, 0);
1305
1306         dwarf2_write_byte (debug->f, ABBREV_SIMPLE_ARRAY);
1307         dwarf2_write_byte (debug->f, DW_TAG_array_type);
1308         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1309         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1310         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1311         dwarf2_write_pair (debug->f, 0, 0);
1312
1313         dwarf2_write_byte (debug->f, ABBREV_ARRAY);
1314         dwarf2_write_byte (debug->f, DW_TAG_array_type);
1315         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1316         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1317         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1318         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data4);
1319         dwarf2_write_pair (debug->f, 0, 0);
1320
1321         dwarf2_write_byte (debug->f, ABBREV_SUBRANGE);
1322         dwarf2_write_byte (debug->f, DW_TAG_subrange_type);
1323         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1324         dwarf2_write_pair (debug->f, DW_AT_lower_bound, DW_FORM_data4);
1325         dwarf2_write_pair (debug->f, DW_AT_upper_bound, DW_FORM_data4);
1326         dwarf2_write_pair (debug->f, DW_AT_count, DW_FORM_data4);
1327         dwarf2_write_pair (debug->f, 0, 0);
1328
1329         dwarf2_write_label (debug->f, "debug_abbrev_e");
1330
1331         // Line numbers
1332         write_line_numbers (debug);
1333
1334         // Compile unit header
1335         dwarf2_write_section_start (debug->f, "debug_info");
1336         dwarf2_write_label (debug->f, "debug_info_b");
1337         dwarf2_write_section_size (debug->f, "DI1", "debug_info_e");
1338         dwarf2_write_label (debug->f, "DI1");
1339         dwarf2_write_2byte (debug->f, 2);
1340         dwarf2_write_ref4 (debug->f, "debug_abbrev_b");
1341         dwarf2_write_byte (debug->f, sizeof (gpointer));
1342
1343         // DW_TAG_compile_unit
1344         dwarf2_write_byte (debug->f, ABBREV_COMPILE_UNIT);
1345         dwarf2_write_string (debug->f, debug->name);
1346         dwarf2_write_2byte (debug->f, DW_LANG_C_sharp);
1347         dwarf2_write_string (debug->f, debug->producer_name);
1348         dwarf2_write_ref4 (debug->f, "debug_lines_b");
1349
1350         // Methods
1351         g_hash_table_foreach (debug->methods, write_method_func, debug);
1352
1353         // Derived types
1354         g_hash_table_foreach (debug->type_hash, write_class, debug);
1355
1356         dwarf2_write_byte (debug->f, 0);
1357         // DW_TAG_compile_unit ends here
1358
1359         dwarf2_write_label (debug->f, "debug_info_e");
1360
1361         fclose (debug->f);
1362         debug->f = NULL;
1363
1364         if (!(debug->flags & MONO_DEBUG_FLAGS_DONT_ASSEMBLE)) {
1365                 char *buf;
1366
1367                 /* yes, it's completely unsafe */
1368                 buf = g_strdup_printf ("as %s -o %s", debug->filename, debug->objfile);
1369                 system (buf);
1370                 g_free (buf);
1371         }
1372 }