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, const void *address)
 178 {
 179         fprintf (f, "\t.long 0x%lx\n", (long) 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, const 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     // Don't include any static fields, they aren't supported yet.
 411     // If a struct contains a static field which has the same type as
 412     // the struct itself, we'd get a recursion loop there.
 413     if (klass->fields [idx].type->attrs & FIELD_ATTRIBUTE_STATIC)
 414             return;
 415
 416     sprintf (start, "DSF1_%ld", ++label_index);
 417     sprintf (end, "DSF2_%ld", label_index);
 418
 419     // DW_TAG_member
 420     dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 421     dwarf2_write_string (debug->f, klass->fields [idx].name);
 422     if (!subclass->valuetype)
 423         dwarf2_write_type_ptr_ref (debug->f, type_index);
 424     else
 425         dwarf2_write_type_ref (debug->f, type_index);
 426
 427     if (klass->fields [idx].type->attrs & FIELD_ATTRIBUTE_PRIVATE)
 428         dwarf2_write_byte (debug->f, DW_ACCESS_private);
 429     else if (klass->fields [idx].type->attrs & FIELD_ATTRIBUTE_FAMILY)
 430         dwarf2_write_byte (debug->f, DW_ACCESS_protected);
 431     else
 432         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 433
 434     dwarf2_write_section_size (debug->f, start, end);
 435     dwarf2_write_label (debug->f, start);
 436     dwarf2_write_byte (debug->f, DW_OP_constu);
 437     dwarf2_write_uleb128 (debug->f, klass->fields [idx].offset - start_offset);
 438     dwarf2_write_label (debug->f, end);
 439
 440     dwarf2_write_long (debug->f, subclass->instance_size);
 441 }
 442
 443 static void
 444 dwarf2_write_class_method (MonoDebugHandle *debug, MonoClass *klass, MonoMethod *method)
 445 {
 446         MonoType *ret_type = NULL;
 447         gchar **names;
 448         int i;
 449
 450         if (method->signature->ret->type != MONO_TYPE_VOID)
 451                 ret_type = method->signature->ret;
 452
 453         // DW_TAG_subprogram
 454         if (ret_type)
 455                 dwarf2_write_byte (debug->f, ABBREV_CLASS_METHOD_RETVAL);
 456         else
 457                 dwarf2_write_byte (debug->f, ABBREV_CLASS_METHOD);
 458         dwarf2_write_string (debug->f, method->name);
 459
 460         if (method->flags & METHOD_ATTRIBUTE_PUBLIC)
 461                 dwarf2_write_byte (debug->f, DW_ACCESS_public);
 462         else if (method->flags & METHOD_ATTRIBUTE_PRIVATE)
 463                 dwarf2_write_byte (debug->f, DW_ACCESS_private);
 464         else
 465                 dwarf2_write_byte (debug->f, DW_ACCESS_protected);
 466
 467         if (method->flags & METHOD_ATTRIBUTE_VIRTUAL)
 468                 dwarf2_write_byte (debug->f, DW_VIRTUALITY_pure_virtual);
 469         else
 470                 dwarf2_write_byte (debug->f, DW_VIRTUALITY_none);
 471
 472         dwarf2_write_byte (debug->f, DW_CC_nocall);
 473
 474         if (ret_type) {
 475                 MonoClass *k = mono_class_from_mono_type (ret_type);
 476                 int type_index = mono_debug_get_type (debug, k);
 477                 dwarf2_write_type_ref (debug->f, type_index);
 478         }
 479
 480         if (method->signature->hasthis) {
 481                 int type_index = mono_debug_get_type (debug, klass);
 482
 483                 dwarf2_write_byte (debug->f, ABBREV_ARTIFICIAL_PARAMETER);
 484                 dwarf2_write_string (debug->f, "this");
 485                 dwarf2_write_type_ptr_ref (debug->f, type_index);
 486                 dwarf2_write_byte (debug->f, 1);
 487         }
 488
 489         names = g_new (char *, method->signature->param_count);
 490         mono_method_get_param_names (method, (const char **) names);
 491
 492         for (i = 0; i < method->signature->param_count; i++) {
 493                 MonoType *subtype = method->signature->params [i];
 494                 MonoClass *subklass = mono_class_from_mono_type (subtype);
 495                 int type_index = mono_debug_get_type (debug, subklass);
 496
 497                 // DW_TAG_formal_parameter
 498                 dwarf2_write_byte (debug->f, ABBREV_FORMAL_PARAMETER);
 499                 dwarf2_write_string (debug->f, names [i]);
 500                 if (subklass->valuetype)
 501                         dwarf2_write_type_ref (debug->f, type_index);
 502                 else
 503                         dwarf2_write_type_ptr_ref (debug->f, type_index);
 504         }
 505
 506         g_free (names);
 507
 508         dwarf2_write_byte (debug->f, 0);
 509         // DW_TAG_subprogram ends here
 510 }
 511
 512 static void
 513 dwarf2_write_struct_type (MonoDebugHandle *debug, MonoClass *klass)
 514 {
 515         guint32 *idxs;
 516         int i;
 517
 518         idxs = g_new0 (guint32, klass->field.last - klass->field.first + 1);
 519         for (i = 0; i < klass->field.count; i++) {
 520                 MonoClass *subclass = mono_class_from_mono_type (klass->fields [i].type);
 521                 idxs [i] = mono_debug_get_type (debug, subclass);
 522         }
 523
 524         // DW_TAG_structure_type
 525         dwarf2_write_byte (debug->f, ABBREV_STRUCT_TYPE);
 526         dwarf2_write_string (debug->f, klass->name);
 527         dwarf2_write_long (debug->f, klass->instance_size - sizeof (MonoObject));
 528
 529         for (i = 0; i < klass->field.count; i++)
 530                 dwarf2_write_class_field (debug, klass, i, idxs [i], sizeof (MonoObject));
 531
 532         dwarf2_write_byte (debug->f, 0);
 533         // DW_TAG_structure_type ends here
 534
 535         g_free (idxs);
 536 }
 537
 538 static void
 539 dwarf2_write_class_type (MonoDebugHandle *debug, MonoClass *klass)
 540 {
 541         guint32 *idxs;
 542         int i;
 543
 544         idxs = g_new0 (guint32, klass->field.last - klass->field.first + 1);
 545         for (i = 0; i < klass->field.count; i++) {
 546                 MonoClass *subclass = mono_class_from_mono_type (klass->fields [i].type);
 547                 idxs [i] = mono_debug_get_type (debug, subclass);
 548         }
 549
 550         // DW_TAG_structure_type
 551         dwarf2_write_byte (debug->f, ABBREV_CLASS_TYPE);
 552         dwarf2_write_string (debug->f, klass->name);
 553         dwarf2_write_long (debug->f, klass->instance_size);
 554         if (klass->flags & TYPE_ATTRIBUTE_PUBLIC)
 555                 dwarf2_write_byte (debug->f, DW_ACCESS_public);
 556         else
 557                 dwarf2_write_byte (debug->f, DW_ACCESS_private);
 558
 559         if (klass->parent && klass->parent->byval_arg.type == MONO_TYPE_CLASS) {
 560                 guint32 parent_index = mono_debug_get_type (debug, klass->parent);
 561
 562                 // DW_TAG_inheritance
 563                 dwarf2_write_byte (debug->f, ABBREV_CLASS_INHERITANCE);
 564                 dwarf2_write_type_ref (debug->f, parent_index);
 565                 if (klass->parent->flags & TYPE_ATTRIBUTE_PUBLIC)
 566                         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 567                 else
 568                         dwarf2_write_byte (debug->f, DW_ACCESS_private);
 569         }
 570
 571         for (i = 0; i < klass->field.count; i++)
 572                 dwarf2_write_class_field (debug, klass, i, idxs [i], 0);
 573
 574         for (i = 0; i < klass->method.count; i++) {
 575                 if (!strcmp (klass->methods [i]->name, ".ctor"))
 576                         continue;
 577
 578                 dwarf2_write_class_method (debug, klass, klass->methods [i]);
 579         }
 580
 581         dwarf2_write_byte (debug->f, 0);
 582         // DW_TAG_class_type ends here
 583
 584         g_free (idxs);
 585 }
 586
 587 static void
 588 dwarf2_write_array (MonoDebugHandle *debug, const gchar *name, MonoClass *element_class,
 589                     int rank, int idx)
 590 {
 591         unsigned long uint32_index = mono_debug_get_type (debug, mono_defaults.uint32_class);
 592         char buffer [BUFSIZ];
 593         MonoArray array;
 594
 595         dwarf2_write_byte (debug->f, ABBREV_STRUCT_TYPE);
 596         dwarf2_write_string (debug->f, name);
 597         dwarf2_write_long (debug->f, sizeof (MonoArray));
 598
 599         // DW_TAG_structure_type
 600         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 601         dwarf2_write_string (debug->f, "max_length");
 602         dwarf2_write_type_ref (debug->f, uint32_index);
 603         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 604         dwarf2_write_long (debug->f, 2);
 605         dwarf2_write_byte (debug->f, DW_OP_const1u);
 606         dwarf2_write_byte (debug->f, (guchar *) &array.max_length - (guchar *) &array);
 607         dwarf2_write_long (debug->f, 4);
 608
 609         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 610         dwarf2_write_string (debug->f, "bounds");
 611         dwarf2_write_relative_ref (debug->f, "ARRAY_BOUNDS_PTR", idx);
 612         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 613         dwarf2_write_long (debug->f, 2);
 614         dwarf2_write_byte (debug->f, DW_OP_const1u);
 615         dwarf2_write_byte (debug->f, (guchar *) &array.bounds - (guchar *) &array);
 616         dwarf2_write_long (debug->f, 4);
 617
 618         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 619         dwarf2_write_string (debug->f, "vector");
 620         dwarf2_write_relative_ref (debug->f, "ARRAY_PTR", idx);
 621         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 622         dwarf2_write_long (debug->f, 2);
 623         dwarf2_write_byte (debug->f, DW_OP_const1u);
 624         dwarf2_write_byte (debug->f, (guchar *) &array.vector - (guchar *) &array);
 625         dwarf2_write_long (debug->f, 4);
 626
 627         dwarf2_write_byte (debug->f, 0);
 628         // DW_TAG_structure_type ends here
 629
 630         sprintf (buffer, "ARRAY_BOUNDS_PTR_%u", idx);
 631         dwarf2_write_label (debug->f, buffer);
 632
 633         // DW_TAG_pointer_type
 634         dwarf2_write_byte (debug->f, ABBREV_POINTER_TYPE);
 635         dwarf2_write_relative_ref (debug->f, "ARRAY_BOUNDS", idx);
 636
 637         sprintf (buffer, "ARRAY_BOUNDS_%u", idx);
 638         dwarf2_write_label (debug->f, buffer);
 639
 640         // DW_TAG_array_type
 641         dwarf2_write_byte (debug->f, ABBREV_ARRAY);
 642         dwarf2_write_string (debug->f, name);
 643         dwarf2_write_type_ref (debug->f, uint32_index);
 644         dwarf2_write_long (debug->f, rank * 2);
 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, rank-1);
 650         dwarf2_write_long (debug->f, rank);
 651
 652         // DW_TAG_subrange_type
 653         dwarf2_write_byte (debug->f, ABBREV_SUBRANGE);
 654         dwarf2_write_long (debug->f, 0);
 655         dwarf2_write_long (debug->f, 1);
 656         dwarf2_write_long (debug->f, 2);
 657
 658         dwarf2_write_byte (debug->f, 0);
 659         // DW_TAG_array_type ends here
 660
 661         sprintf (buffer, "ARRAY_PTR_%u", idx);
 662         dwarf2_write_label (debug->f, buffer);
 663
 664         // DW_TAG_array_type
 665         dwarf2_write_byte (debug->f, ABBREV_SIMPLE_ARRAY);
 666         dwarf2_write_string (debug->f, name);
 667         if (element_class->valuetype)
 668                 dwarf2_write_type_ref (debug->f, mono_debug_get_type (debug, element_class));
 669         else
 670                 dwarf2_write_type_ptr_ref (debug->f, mono_debug_get_type (debug, element_class));
 671 }
 672
 673 static void
 674 dwarf2_write_array_type (MonoDebugHandle *debug, MonoClass *klass, int idx)
 675 {
 676         char buffer [BUFSIZ], *name;
 677         int i;
 678
 679         buffer[0] = '\0';
 680         for (i = 0; i < klass->rank; i++)
 681                 strcat (buffer, "[]");
 682
 683         name = g_strdup_printf ("%s%s", klass->element_class->name, buffer);
 684
 685         dwarf2_write_array (debug, name, klass->element_class, klass->rank, idx);
 686
 687         g_free (name);
 688 }
 689
 690 static void
 691 dwarf2_write_string_type (MonoDebugHandle *debug, MonoClass *klass, int idx)
 692 {
 693         unsigned long uint32_index = mono_debug_get_type (debug, mono_defaults.uint32_class);
 694         char buffer [BUFSIZ];
 695         MonoString string;
 696
 697         // DW_TAG_structure_type
 698         dwarf2_write_byte (debug->f, ABBREV_STRUCT_TYPE);
 699         dwarf2_write_string (debug->f, klass->name);
 700         dwarf2_write_long (debug->f, sizeof (MonoString));
 701
 702         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 703         dwarf2_write_string (debug->f, "length");
 704         dwarf2_write_type_ref (debug->f, uint32_index);
 705         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 706         dwarf2_write_long (debug->f, 2);
 707         dwarf2_write_byte (debug->f, DW_OP_const1u);
 708         dwarf2_write_byte (debug->f, (guchar *) &string.length - (guchar *) &string);
 709         dwarf2_write_long (debug->f, 4);
 710
 711         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
 712         dwarf2_write_string (debug->f, "chars");
 713         dwarf2_write_relative_ref (debug->f, "CHARS", idx);
 714         dwarf2_write_byte (debug->f, DW_ACCESS_public);
 715         dwarf2_write_long (debug->f, 2);
 716         dwarf2_write_byte (debug->f, DW_OP_const1u);
 717         dwarf2_write_byte (debug->f, (guchar *) &string.chars - (guchar *) &string);
 718         dwarf2_write_long (debug->f, 4);
 719
 720         dwarf2_write_byte (debug->f, 0);
 721         // DW_TAG_structure_type ends here
 722
 723         sprintf (buffer, "CHARS_%u", idx);
 724         dwarf2_write_label (debug->f, buffer);
 725
 726         dwarf2_write_byte (debug->f, ABBREV_SIMPLE_ARRAY);
 727         dwarf2_write_string (debug->f, "Char[]");
 728         dwarf2_write_type_ref (debug->f, mono_debug_get_type (debug, mono_defaults.char_class));
 729 }
 730
 731 static void
 732 dwarf2_write_class (MonoDebugHandle *debug, MonoClass *klass, int idx)
 733 {
 734         char buffer [BUFSIZ];
 735         int print = 0;
 736
 737         if (!strncmp (klass->name, "My", 2)) {
 738                 g_message (G_STRLOC ": %s - %s - %x", klass->name_space, klass->name, klass->flags);
 739                 print = 1;
 740                 // G_BREAKPOINT ();
 741         }
 742
 743         if (!klass->valuetype) {
 744                 sprintf (buffer, "TYPE_PTR_%u", idx);
 745                 dwarf2_write_label (debug->f, buffer);
 746
 747                 // DW_TAG_pointer_type
 748                 dwarf2_write_byte (debug->f, ABBREV_POINTER_TYPE);
 749                 dwarf2_write_type_ref (debug->f, idx);
 750         }
 751
 752         sprintf (buffer, "TYPE_%u", idx);
 753         dwarf2_write_label (debug->f, buffer);
 754
 755         if (klass->enumtype) {
 756                 dwarf2_write_enum_type (debug, klass);
 757                 return;
 758         }
 759
 760         switch (klass->byval_arg.type) {
 761         case MONO_TYPE_VALUETYPE:
 762                 dwarf2_write_struct_type (debug, klass);
 763                 break;
 764         case MONO_TYPE_CLASS:
 765                 dwarf2_write_class_type (debug, klass);
 766                 break;
 767         case MONO_TYPE_SZARRAY:
 768         case MONO_TYPE_ARRAY:
 769                 dwarf2_write_array_type (debug, klass, idx);
 770                 break;
 771         case MONO_TYPE_STRING:
 772                 dwarf2_write_string_type (debug, klass, idx);
 773                 break;
 774         default:
 775 #if 0
 776                 g_message (G_STRLOC ": %s.%s - 0x%x - 0x%x", klass->name_space, klass->name,
 777                            klass->byval_arg.type, klass->flags);
 778 #endif
 779
 780                 // DW_TAG_basic_type
 781                 dwarf2_write_byte (debug->f, ABBREV_BASE_TYPE);
 782                 dwarf2_write_string (debug->f, klass->name);
 783                 dwarf2_write_byte (debug->f, DW_ATE_address);
 784                 dwarf2_write_byte (debug->f, 0);
 785                 break;
 786         }
 787 }
 788
 789 static void
 790 dwarf2_write_variable_location (MonoDebugHandle *debug, MonoDebugVarInfo *var)
 791 {
 792         switch (var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS) {
 793         case MONO_DEBUG_VAR_ADDRESS_MODE_STACK:
 794                 /*
 795                  * Variable is on the stack.
 796                  *
 797                  * If `index' is zero, use the normal frame register.  Otherwise, bits
 798                  * 0..4 of `index' contain the frame register.
 799                  *
 800                  */
 801
 802                 if (!var->index)
 803                         /* Use the normal frame register (%ebp on the i386). */
 804                         dwarf2_write_byte (debug->f, DW_OP_fbreg);
 805                 else
 806                         /* Use a custom frame register. */
 807                         dwarf2_write_byte (debug->f, DW_OP_breg0 + (var->index & 0x001f));
 808                 dwarf2_write_sleb128 (debug->f, var->offset);
 809                 break;
 810
 811         case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
 812                 /*
 813                  * Variable is in the register whose number is contained in bits 0..4
 814                  * of `index'.
 815                  *
 816                  */
 817                 dwarf2_write_byte (debug->f, DW_OP_reg0 + (var->index & 0x001f));
 818                 if (var->offset) {
 819                         dwarf2_write_byte (debug->f, DW_OP_consts);
 820                         dwarf2_write_sleb128 (debug->f, var->offset);
 821                         dwarf2_write_byte (debug->f, DW_OP_plus);
 822                 }
 823                 break;
 824
 825         case MONO_DEBUG_VAR_ADDRESS_MODE_TWO_REGISTERS:
 826                 /*
 827                  * Variable is in two registers whose numbers are in bits 0..4 and 5..9 of
 828                  * the `index' field.
 829                  */
 830                 dwarf2_write_byte (debug->f, DW_OP_reg0 + (var->index & 0x001f));
 831                 dwarf2_write_byte (debug->f, DW_OP_piece);
 832                 dwarf2_write_byte (debug->f, sizeof (int));
 833
 834                 dwarf2_write_byte (debug->f, DW_OP_reg0 + ((var->index & 0x1f0) >> 5));
 835                 dwarf2_write_byte (debug->f, DW_OP_piece);
 836                 dwarf2_write_byte (debug->f, sizeof (int));
 837
 838                 break;
 839
 840         default:
 841                 g_assert_not_reached ();
 842         }
 843 }
 844
 845 static void
 846 dwarf2_write_parameter (MonoDebugHandle *debug, MonoDebugMethodInfo *minfo, const gchar *name,
 847                         MonoDebugVarInfo *var, MonoClass *klass)
 848 {
 849         static long label_index = 0;
 850         int type_index = mono_debug_get_type (debug, klass);
 851         char start [BUFSIZ], end [BUFSIZ];
 852
 853         sprintf (start, "DT1_%ld", ++label_index);
 854         sprintf (end, "DT2_%ld", label_index);
 855
 856         // DW_TAG_format_parameter
 857         dwarf2_write_byte (debug->f, ABBREV_PARAMETER);
 858         dwarf2_write_string (debug->f, name);
 859         if (klass->valuetype)
 860                 dwarf2_write_type_ref (debug->f, type_index);
 861         else
 862                 dwarf2_write_type_ptr_ref (debug->f, type_index);
 863         dwarf2_write_section_size (debug->f, start, end);
 864         dwarf2_write_label (debug->f, start);
 865         dwarf2_write_variable_location (debug, var);
 866         dwarf2_write_label (debug->f, end);
 867         dwarf2_write_long (debug->f, minfo->jit->prologue_end);
 868 }
 869
 870 static void
 871 dwarf2_write_variable (MonoDebugHandle *debug, MonoDebugMethodInfo *minfo, const gchar *name,
 872                        MonoDebugVarInfo *var, MonoClass *klass)
 873 {
 874         static long label_index = 0;
 875         int type_index = mono_debug_get_type (debug, klass);
 876         char start [BUFSIZ], end [BUFSIZ];
 877
 878         sprintf (start, "DT3_%ld", ++label_index);
 879         sprintf (end, "DT4_%ld", label_index);
 880
 881         // DW_TAG_formal_parameter
 882         dwarf2_write_byte (debug->f, ABBREV_LOCAL_VARIABLE);
 883         dwarf2_write_string (debug->f, name);
 884         if (klass->valuetype)
 885                 dwarf2_write_type_ref (debug->f, type_index);
 886         else
 887                 dwarf2_write_type_ptr_ref (debug->f, type_index);
 888         dwarf2_write_section_size (debug->f, start, end);
 889         dwarf2_write_label (debug->f, start);
 890         dwarf2_write_variable_location (debug, var);
 891         dwarf2_write_label (debug->f, end);
 892         dwarf2_write_address (debug->f, minfo->jit->code_start + var->begin_scope);
 893         dwarf2_write_address (debug->f, minfo->jit->code_start + var->end_scope);
 894 }
 895
 896 static void
 897 write_method_lines_dwarf2 (MonoDebugHandle *debug, MonoDebugMethodInfo *minfo)
 898 {
 899         guint32 st_line = 0;
 900         gconstpointer st_address = 0;
 901         DebugMethodInfo *priv = minfo->user_data;
 902         int i;
 903
 904         if (!minfo->jit || !minfo->jit->line_numbers)
 905                 return;
 906
 907         // Start of statement program
 908         dwarf2_write_dw_lns_set_file (debug->f, priv->source_file);
 909         dwarf2_write_dw_lns_advance_line (debug->f, priv->start_line - 1);
 910         dwarf2_write_dw_lne_set_address (debug->f, minfo->jit->code_start);
 911         dwarf2_write_dw_lns_negate_stmt (debug->f);
 912         dwarf2_write_dw_lns_copy (debug->f);
 913
 914         st_line = priv->start_line;
 915         st_address = 0;
 916
 917         for (i = 1; i < minfo->jit->line_numbers->len; i++) {
 918                 MonoDebugLineNumberEntry lne = g_array_index (
 919                         minfo->jit->line_numbers, MonoDebugLineNumberEntry, i);
 920                 gint32 line_inc, addr_inc, opcode;
 921                 int used_standard_opcode = 0;
 922
 923                 line_inc = lne.line - st_line;
 924                 addr_inc = (char *)lne.address - (char *)st_address;
 925
 926                 if (addr_inc < 0) {
 927                         dwarf2_write_dw_lne_set_address (debug->f, lne.address + minfo->jit->code_start);
 928                         used_standard_opcode = 1;
 929                 } else if (addr_inc && !line_inc) {
 930                         dwarf2_write_dw_lns_advance_pc (debug->f, addr_inc);
 931                         used_standard_opcode = 1;
 932                 }
 933
 934                 if ((line_inc < 0) || (line_inc >= line_range)) {
 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 if (line_inc > 0) {
 939                         opcode = (line_inc - 1) + (line_range * addr_inc) + opcode_base;
 940                         g_assert (opcode >= 0);
 941
 942                         if (opcode >= 256) {
 943                                 dwarf2_write_dw_lns_advance_pc (debug->f, addr_inc);
 944                                 dwarf2_write_dw_lns_advance_line (debug->f, line_inc);
 945                                 used_standard_opcode = 1;
 946                         } else
 947                                 dwarf2_write_byte (debug->f, opcode);
 948                 }
 949
 950                 if (used_standard_opcode)
 951                         dwarf2_write_dw_lns_copy (debug->f);
 952
 953                 st_line += line_inc;
 954                 st_address = (char *)st_address + addr_inc;
 955         }
 956
 957         dwarf2_write_dw_lne_set_address (debug->f,
 958                                          (char *)minfo->jit->code_start +
 959                                          minfo->jit->epilogue_begin);
 960         dwarf2_write_dw_lns_advance_line (debug->f, priv->last_line - st_line);
 961         dwarf2_write_dw_lns_copy (debug->f);
 962
 963         dwarf2_write_dw_lns_copy (debug->f);
 964         dwarf2_write_dw_lne_end_sequence (debug->f);
 965 }
 966
 967 static void
 968 write_method_lines_func (gpointer key, gpointer value, gpointer user_data)
 969 {
 970         write_method_lines_dwarf2 (user_data, value);
 971 }
 972
 973 static void
 974 write_method_lines_func_1 (gpointer key, gpointer value, gpointer user_data)
 975 {
 976         AssemblyDebugInfo *info = (AssemblyDebugInfo *) value;
 977
 978         g_hash_table_foreach (info->methods, write_method_lines_func, user_data);
 979 }
 980
 981 static void
 982 write_line_numbers (MonoDebugHandle *debug)
 983 {
 984         /* State machine registers. */
 985         int i;
 986
 987         // Line number information.
 988         dwarf2_write_section_start (debug->f, "debug_line");
 989         dwarf2_write_label (debug->f, "debug_line_b");
 990         dwarf2_write_section_size (debug->f, "DL1", "debug_line_e");
 991         dwarf2_write_label (debug->f, "DL1");
 992         dwarf2_write_2byte (debug->f, 2);
 993         dwarf2_write_section_size (debug->f, "DL2", "DL3");
 994         dwarf2_write_label (debug->f, "DL2");
 995         // minimum instruction length
 996         dwarf2_write_byte (debug->f, 1);
 997         // default is statement
 998         dwarf2_write_byte (debug->f, 1);
 999         // line base
1000         dwarf2_write_byte (debug->f, line_base);
1001         // line range
1002         dwarf2_write_byte (debug->f, line_range);
1003         // opcode base
1004         dwarf2_write_byte (debug->f, opcode_base);
1005         // standard opcode sizes
1006         for (i = 1; i < opcode_base; i++)
1007                 dwarf2_write_byte (debug->f, standard_opcode_sizes [i]);
1008         // include directories
1009         dwarf2_write_byte (debug->f, 0);
1010         // file names
1011         for (i = 0; i < debug->source_files->len; i++) {
1012                 gchar *source_file = g_ptr_array_index (debug->source_files, i);
1013                 dwarf2_write_string (debug->f, source_file);
1014                 dwarf2_write_uleb128 (debug->f, 0);
1015                 dwarf2_write_uleb128 (debug->f, 0);
1016                 dwarf2_write_uleb128 (debug->f, 0);
1017         }
1018         // end of list
1019         dwarf2_write_byte (debug->f, 0);
1020         dwarf2_write_label (debug->f, "DL3");
1021
1022         g_hash_table_foreach (debug->images, write_method_lines_func_1, debug);
1023
1024         dwarf2_write_label (debug->f, "debug_line_e");
1025 }
1026
1027 static void
1028 write_class_dwarf2 (MonoDebugHandle *debug, MonoClass *klass, guint idx)
1029 {
1030         switch (klass->byval_arg.type) {
1031         case MONO_TYPE_VOID:
1032                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 0, "Void");
1033                 break;
1034         case MONO_TYPE_BOOLEAN:
1035                 dwarf2_write_base_type (debug, idx, DW_ATE_boolean, 1, "Boolean");
1036                 break;
1037         case MONO_TYPE_CHAR:
1038                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned_char, 2, "Char");
1039                 break;
1040         case MONO_TYPE_I1:
1041                 dwarf2_write_base_type (debug, idx, DW_ATE_signed, 1, "SByte");
1042                 break;
1043         case MONO_TYPE_U1:
1044                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 1, "Byte");
1045                 break;
1046         case MONO_TYPE_I2:
1047                 dwarf2_write_base_type (debug, idx, DW_ATE_signed, 2, "Int16");
1048                 break;
1049         case MONO_TYPE_U2:
1050                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 2, "UInt16");
1051                 break;
1052         case MONO_TYPE_I4:
1053                 dwarf2_write_base_type (debug, idx, DW_ATE_signed, 4, "Int32");
1054                 break;
1055         case MONO_TYPE_U4:
1056                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 4, "UInt32");
1057                 break;
1058         case MONO_TYPE_I8:
1059                 dwarf2_write_base_type (debug, idx, DW_ATE_signed, 8, "Int64");
1060                 break;
1061         case MONO_TYPE_U8:
1062                 dwarf2_write_base_type (debug, idx, DW_ATE_unsigned, 8, "UInt64");
1063                 break;
1064         case MONO_TYPE_R4:
1065                 dwarf2_write_base_type (debug, idx, DW_ATE_float, 4, "Float");
1066                 break;
1067         case MONO_TYPE_R8:
1068                 dwarf2_write_base_type (debug, idx, DW_ATE_float, 8, "Double");
1069                 break;
1070         default:
1071                 dwarf2_write_class (debug, klass, idx);
1072                 break;
1073         }
1074 }
1075
1076 static void
1077 write_class (gpointer key, gpointer value, gpointer user_data)
1078 {
1079         write_class_dwarf2 (user_data, key, GPOINTER_TO_INT (value));
1080 }
1081
1082 static void
1083 write_method_dwarf2 (MonoDebugHandle *debug, MonoDebugMethodInfo *minfo)
1084 {
1085         int is_external = 0, i;
1086         MonoType *ret_type = NULL;
1087         DebugMethodInfo *priv = minfo->user_data;
1088         gchar **names;
1089
1090         if (!minfo->jit)
1091                 return;
1092
1093         if (minfo->method->signature->ret->type != MONO_TYPE_VOID)
1094                 ret_type = minfo->method->signature->ret;
1095
1096         // DW_TAG_subprogram
1097         if (ret_type)
1098                 dwarf2_write_byte (debug->f, ABBREV_SUBPROGRAM_RETVAL);
1099         else
1100                 dwarf2_write_byte (debug->f, ABBREV_SUBPROGRAM);
1101         dwarf2_write_string (debug->f, priv->name);
1102         dwarf2_write_byte (debug->f, is_external);
1103         dwarf2_write_address (debug->f, minfo->jit->code_start);
1104         dwarf2_write_address (debug->f, (char *)minfo->jit->code_start + minfo->jit->code_size);
1105         dwarf2_write_byte (debug->f, DW_CC_nocall);
1106         if (ret_type) {
1107                 MonoClass *klass = mono_class_from_mono_type (ret_type);
1108                 int type_index = mono_debug_get_type (debug, klass);
1109                 dwarf2_write_type_ref (debug->f, type_index);
1110         }
1111
1112         if (minfo->method->signature->hasthis)
1113                 dwarf2_write_parameter (debug, minfo, "this", minfo->jit->this_var,
1114                                         minfo->method->klass);
1115
1116         names = g_new (char *, minfo->method->signature->param_count);
1117         mono_method_get_param_names (minfo->method, (const char **) names);
1118
1119         for (i = 0; i < minfo->jit->num_params; i++) {
1120                 MonoType *type = minfo->method->signature->params [i];
1121                 MonoClass *klass = mono_class_from_mono_type (type);
1122
1123                 dwarf2_write_parameter (debug, minfo, names [i], &minfo->jit->params [i], klass);
1124         }
1125
1126         g_free (names);
1127
1128         for (i = 0; i < minfo->jit->num_locals; i++) {
1129                 MonoMethodHeader *header = ((MonoMethodNormal*) minfo->method)->header;
1130                 MonoClass *klass = mono_class_from_mono_type (header->locals [i]);
1131                 char name [BUFSIZ];
1132
1133                 sprintf (name, "V_%d", i);
1134                 dwarf2_write_variable (debug, minfo, name, &minfo->jit->locals [i], klass);
1135         }
1136
1137         dwarf2_write_byte (debug->f, 0);
1138         // DW_TAG_subprogram ends here
1139 }
1140
1141 static void
1142 write_method_func (gpointer key, gpointer value, gpointer user_data)
1143 {
1144         write_method_dwarf2 (user_data, value);
1145 }
1146
1147 static void
1148 write_method_func_1 (gpointer key, gpointer value, gpointer user_data)
1149 {
1150         AssemblyDebugInfo *info = (AssemblyDebugInfo *) value;
1151
1152         g_hash_table_foreach (info->methods, write_method_func, user_data);
1153 }
1154
1155 void
1156 mono_debug_write_dwarf2 (MonoDebugHandle *debug)
1157 {
1158         if (!(debug->f = fopen (debug->filename, "w"))) {
1159                 g_warning ("Can't create dwarf file `%s': %s", debug->filename, g_strerror (errno));
1160                 return;
1161         }
1162
1163         // Produce assembler code which is free of comments and extra whitespaces.
1164         fprintf (debug->f, "#NOAPP\n");
1165
1166         // DWARF 2 Abbreviation table.
1167         dwarf2_write_section_start (debug->f, "debug_abbrev");
1168         dwarf2_write_label (debug->f, "debug_abbrev");
1169
1170         dwarf2_write_byte (debug->f, ABBREV_COMPILE_UNIT);
1171         dwarf2_write_byte (debug->f, DW_TAG_compile_unit);
1172         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1173         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1174         dwarf2_write_pair (debug->f, DW_AT_language, DW_FORM_data2);
1175         dwarf2_write_pair (debug->f, DW_AT_producer, DW_FORM_string);
1176         dwarf2_write_pair (debug->f, DW_AT_stmt_list, DW_FORM_ref4);
1177         dwarf2_write_pair (debug->f, 0, 0);
1178
1179         dwarf2_write_byte (debug->f, ABBREV_SUBPROGRAM);
1180         dwarf2_write_byte (debug->f, DW_TAG_subprogram);
1181         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1182         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1183         dwarf2_write_pair (debug->f, DW_AT_external, DW_FORM_flag);
1184         dwarf2_write_pair (debug->f, DW_AT_low_pc, DW_FORM_addr);
1185         dwarf2_write_pair (debug->f, DW_AT_high_pc, DW_FORM_addr);
1186         dwarf2_write_pair (debug->f, DW_AT_calling_convention, DW_FORM_data1);
1187         dwarf2_write_pair (debug->f, 0, 0);
1188
1189         dwarf2_write_byte (debug->f, ABBREV_SUBPROGRAM_RETVAL);
1190         dwarf2_write_byte (debug->f, DW_TAG_subprogram);
1191         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1192         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1193         dwarf2_write_pair (debug->f, DW_AT_external, DW_FORM_flag);
1194         dwarf2_write_pair (debug->f, DW_AT_low_pc, DW_FORM_addr);
1195         dwarf2_write_pair (debug->f, DW_AT_high_pc, DW_FORM_addr);
1196         dwarf2_write_pair (debug->f, DW_AT_calling_convention, DW_FORM_data1);
1197         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1198         dwarf2_write_pair (debug->f, 0, 0);
1199
1200         dwarf2_write_byte (debug->f, ABBREV_BASE_TYPE);
1201         dwarf2_write_byte (debug->f, DW_TAG_base_type);
1202         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1203         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1204         dwarf2_write_pair (debug->f, DW_AT_encoding, DW_FORM_data1);
1205         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data1);
1206         dwarf2_write_pair (debug->f, 0, 0);
1207
1208         dwarf2_write_byte (debug->f, ABBREV_FORMAL_PARAMETER);
1209         dwarf2_write_byte (debug->f, DW_TAG_formal_parameter);
1210         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1211         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1212         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1213         dwarf2_write_pair (debug->f, 0, 0);
1214
1215         dwarf2_write_byte (debug->f, ABBREV_ARTIFICIAL_PARAMETER);
1216         dwarf2_write_byte (debug->f, DW_TAG_formal_parameter);
1217         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1218         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1219         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1220         dwarf2_write_pair (debug->f, DW_AT_artificial, DW_FORM_data1);
1221         dwarf2_write_pair (debug->f, 0, 0);
1222
1223         dwarf2_write_byte (debug->f, ABBREV_PARAMETER);
1224         dwarf2_write_byte (debug->f, DW_TAG_formal_parameter);
1225         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1226         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1227         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1228         dwarf2_write_pair (debug->f, DW_AT_location, DW_FORM_block4);
1229         dwarf2_write_pair (debug->f, DW_AT_start_scope, DW_FORM_data4);
1230         dwarf2_write_pair (debug->f, 0, 0);
1231
1232         dwarf2_write_byte (debug->f, ABBREV_LOCAL_VARIABLE);
1233         dwarf2_write_byte (debug->f, DW_TAG_variable);
1234         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1235         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1236         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1237         dwarf2_write_pair (debug->f, DW_AT_location, DW_FORM_block4);
1238         dwarf2_write_pair (debug->f, DW_AT_start_scope, DW_FORM_addr);
1239         dwarf2_write_pair (debug->f, DW_AT_end_scope, DW_FORM_addr);
1240         dwarf2_write_pair (debug->f, 0, 0);
1241
1242         dwarf2_write_byte (debug->f, ABBREV_STRUCT_TYPE);
1243         dwarf2_write_byte (debug->f, DW_TAG_structure_type);
1244         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1245         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1246         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data4);
1247         dwarf2_write_pair (debug->f, 0, 0);
1248
1249         dwarf2_write_byte (debug->f, ABBREV_STRUCT_MEMBER);
1250         dwarf2_write_byte (debug->f, DW_TAG_member);
1251         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1252         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1253         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1254         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1255         dwarf2_write_pair (debug->f, DW_AT_data_member_location, DW_FORM_block4);
1256         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data4);
1257         dwarf2_write_pair (debug->f, 0, 0);
1258
1259         dwarf2_write_byte (debug->f, ABBREV_STRUCT_ACCESS);
1260         dwarf2_write_byte (debug->f, DW_TAG_access_declaration);
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_accessibility, DW_FORM_data1);
1264         dwarf2_write_pair (debug->f, 0, 0);
1265
1266         dwarf2_write_byte (debug->f, ABBREV_ENUM_TYPE);
1267         dwarf2_write_byte (debug->f, DW_TAG_enumeration_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, 0, 0);
1272
1273         dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE);
1274         dwarf2_write_byte (debug->f, DW_TAG_enumerator);
1275         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1276         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1277         dwarf2_write_pair (debug->f, DW_AT_const_value, DW_FORM_data4);
1278         dwarf2_write_pair (debug->f, 0, 0);
1279
1280         dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_UNSIGNED);
1281         dwarf2_write_byte (debug->f, DW_TAG_enumerator);
1282         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1283         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1284         dwarf2_write_pair (debug->f, DW_AT_const_value, DW_FORM_udata);
1285         dwarf2_write_pair (debug->f, 0, 0);
1286
1287         dwarf2_write_byte (debug->f, ABBREV_ENUM_VALUE_SIGNED);
1288         dwarf2_write_byte (debug->f, DW_TAG_enumerator);
1289         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1290         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1291         dwarf2_write_pair (debug->f, DW_AT_const_value, DW_FORM_sdata);
1292         dwarf2_write_pair (debug->f, 0, 0);
1293
1294         dwarf2_write_byte (debug->f, ABBREV_CLASS_TYPE);
1295         dwarf2_write_byte (debug->f, DW_TAG_class_type);
1296         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1297         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1298         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data4);
1299         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1300         dwarf2_write_pair (debug->f, 0, 0);
1301
1302         dwarf2_write_byte (debug->f, ABBREV_CLASS_INHERITANCE);
1303         dwarf2_write_byte (debug->f, DW_TAG_inheritance);
1304         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1305         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1306         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1307         dwarf2_write_pair (debug->f, 0, 0);
1308
1309         dwarf2_write_byte (debug->f, ABBREV_POINTER_TYPE);
1310         dwarf2_write_byte (debug->f, DW_TAG_pointer_type);
1311         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1312         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1313         dwarf2_write_pair (debug->f, 0, 0);
1314
1315         dwarf2_write_byte (debug->f, ABBREV_CLASS_METHOD);
1316         dwarf2_write_byte (debug->f, DW_TAG_subprogram);
1317         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1318         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1319         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1320         dwarf2_write_pair (debug->f, DW_AT_virtuality, DW_FORM_data1);
1321         dwarf2_write_pair (debug->f, DW_AT_calling_convention, DW_FORM_data1);
1322         dwarf2_write_pair (debug->f, 0, 0);
1323
1324         dwarf2_write_byte (debug->f, ABBREV_CLASS_METHOD_RETVAL);
1325         dwarf2_write_byte (debug->f, DW_TAG_subprogram);
1326         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1327         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1328         dwarf2_write_pair (debug->f, DW_AT_accessibility, DW_FORM_data1);
1329         dwarf2_write_pair (debug->f, DW_AT_virtuality, DW_FORM_data1);
1330         dwarf2_write_pair (debug->f, DW_AT_calling_convention, DW_FORM_data1);
1331         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1332         dwarf2_write_pair (debug->f, 0, 0);
1333
1334         dwarf2_write_byte (debug->f, ABBREV_SIMPLE_ARRAY);
1335         dwarf2_write_byte (debug->f, DW_TAG_array_type);
1336         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1337         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1338         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1339         dwarf2_write_pair (debug->f, 0, 0);
1340
1341         dwarf2_write_byte (debug->f, ABBREV_ARRAY);
1342         dwarf2_write_byte (debug->f, DW_TAG_array_type);
1343         dwarf2_write_byte (debug->f, DW_CHILDREN_yes);
1344         dwarf2_write_pair (debug->f, DW_AT_name, DW_FORM_string);
1345         dwarf2_write_pair (debug->f, DW_AT_type, DW_FORM_ref4);
1346         dwarf2_write_pair (debug->f, DW_AT_byte_size, DW_FORM_data4);
1347         dwarf2_write_pair (debug->f, 0, 0);
1348
1349         dwarf2_write_byte (debug->f, ABBREV_SUBRANGE);
1350         dwarf2_write_byte (debug->f, DW_TAG_subrange_type);
1351         dwarf2_write_byte (debug->f, DW_CHILDREN_no);
1352         dwarf2_write_pair (debug->f, DW_AT_lower_bound, DW_FORM_data4);
1353         dwarf2_write_pair (debug->f, DW_AT_upper_bound, DW_FORM_data4);
1354         dwarf2_write_pair (debug->f, DW_AT_count, DW_FORM_data4);
1355         dwarf2_write_pair (debug->f, 0, 0);
1356
1357         dwarf2_write_label (debug->f, "debug_abbrev_e");
1358
1359         // Line numbers
1360         write_line_numbers (debug);
1361
1362         // Compile unit header
1363         dwarf2_write_section_start (debug->f, "debug_info");
1364         dwarf2_write_label (debug->f, "debug_info_b");
1365         dwarf2_write_section_size (debug->f, "DI1", "debug_info_e");
1366         dwarf2_write_label (debug->f, "DI1");
1367         dwarf2_write_2byte (debug->f, 2);
1368         dwarf2_write_ref4 (debug->f, "debug_abbrev_b");
1369         dwarf2_write_byte (debug->f, sizeof (gpointer));
1370
1371         // DW_TAG_compile_unit
1372         dwarf2_write_byte (debug->f, ABBREV_COMPILE_UNIT);
1373         dwarf2_write_string (debug->f, debug->name);
1374         dwarf2_write_2byte (debug->f, DW_LANG_C_sharp);
1375         dwarf2_write_string (debug->f, debug->producer_name);
1376         dwarf2_write_ref4 (debug->f, "debug_lines_b");
1377
1378         // Methods
1379         g_hash_table_foreach (debug->images, write_method_func_1, debug);
1380
1381         // Derived types
1382         g_hash_table_foreach (debug->type_hash, write_class, debug);
1383
1384         dwarf2_write_byte (debug->f, 0);
1385         // DW_TAG_compile_unit ends here
1386
1387         dwarf2_write_label (debug->f, "debug_info_e");
1388
1389         fclose (debug->f);
1390         debug->f = NULL;
1391
1392         if (!(debug->flags & MONO_DEBUG_FLAGS_DONT_ASSEMBLE)) {
1393                 char *buf;
1394
1395                 /* yes, it's completely unsafe */
1396                 buf = g_strdup_printf ("as %s -o %s", debug->filename, debug->objfile);
1397                 system (buf);
1398                 g_free (buf);
1399         }
1400 }