mono/mini/debug-mini.c

   1 /*
   2  * debug-mini.c: Mini-specific debugging stuff.
   3  *
   4  * Author:
   5  *   Martin Baulig (martin@ximian.com)
   6  *
   7  * (C) 2003 Ximian, Inc.
   8  */
   9
  10 #include "mini.h"
  11 #include "jit.h"
  12 #include <mono/metadata/verify.h>
  13 #include <mono/metadata/mono-config.h>
  14 #include <mono/metadata/mono-debug.h>
  15 #include <mono/metadata/appdomain.h>
  16 /* mono-debug-debugger.h needs config.h to work... */
  17 #include "config.h"
  18 #include <mono/metadata/mono-debug-debugger.h>
  19
  20 #ifdef HAVE_VALGRIND_H
  21 #include <valgrind/valgrind.h>
  22 #endif
  23
  24 static inline void
  25 record_line_number (MonoDebugMethodJitInfo *jit, guint32 address, guint32 offset)
  26 {
  27         MonoDebugLineNumberEntry lne;
  28
  29         lne.native_offset = address;
  30         lne.il_offset = offset;
  31
  32         g_array_append_val (jit->line_numbers, lne);
  33 }
  34
  35 typedef struct
  36 {
  37         MonoDebugMethodJitInfo *jit;
  38         guint32 has_line_numbers;
  39         guint32 breakpoint_id;
  40 } MiniDebugMethodInfo;
  41
  42 void
  43 mono_debug_init_method (MonoCompile *cfg, MonoBasicBlock *start_block, guint32 breakpoint_id)
  44 {
  45         MonoMethod *method = cfg->method;
  46         MiniDebugMethodInfo *info;
  47
  48         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
  49                 return;
  50
  51         if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
  52             (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
  53             (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
  54             (method->flags & METHOD_ATTRIBUTE_ABSTRACT))
  55                 return;
  56         if ((method->wrapper_type != MONO_WRAPPER_NONE) &&
  57             (method->wrapper_type != MONO_WRAPPER_MANAGED_TO_NATIVE))
  58                 return;
  59
  60         info = g_new0 (MiniDebugMethodInfo, 1);
  61         info->breakpoint_id = breakpoint_id;
  62
  63         cfg->debug_info = info;
  64 }
  65
  66 void
  67 mono_debug_open_method (MonoCompile *cfg)
  68 {
  69         MiniDebugMethodInfo *info;
  70         MonoDebugMethodJitInfo *jit;
  71         MonoMethodHeader *header;
  72
  73         info = (MiniDebugMethodInfo *) cfg->debug_info;
  74         if (!info)
  75                 return;
  76
  77         mono_class_init (cfg->method->klass);
  78
  79         header = mono_method_get_header (cfg->method);
  80         g_assert (header);
  81
  82         info->jit = jit = g_new0 (MonoDebugMethodJitInfo, 1);
  83         jit->line_numbers = g_array_new (FALSE, TRUE, sizeof (MonoDebugLineNumberEntry));
  84         jit->num_locals = header->num_locals;
  85         jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals);
  86 }
  87
  88 static void
  89 write_variable (MonoInst *inst, MonoDebugVarInfo *var)
  90 {
  91         if (inst->opcode == OP_REGVAR)
  92                 var->index = inst->dreg | MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER;
  93         else {
  94                 /* the debug interface needs fixing to allow 0(%base) address */
  95                 var->index = inst->inst_basereg | MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET;
  96                 var->offset = inst->inst_offset;
  97         }
  98 }
  99
 100 /*
 101  * mono_debug_add_vg_method:
 102  *
 103  *  Register symbol information for the method with valgrind
 104  */
 105 static void
 106 mono_debug_add_vg_method (MonoMethod *method, MonoDebugMethodJitInfo *jit)
 107 {
 108 #ifdef VALGRIND_ADD_LINE_INFO
 109         MonoMethodHeader *header;
 110         int i;
 111         char *filename = NULL;
 112         guint32 address, line_number;
 113         const char *full_name;
 114         guint32 *addresses;
 115         guint32 *lines;
 116
 117         if (!RUNNING_ON_VALGRIND)
 118                 return;
 119
 120         header = mono_method_get_header (method);
 121
 122         full_name = mono_method_full_name (method, TRUE);
 123
 124         addresses = g_new0 (guint32, header->code_size + 1);
 125         lines = g_new0 (guint32, header->code_size + 1);
 126
 127         /*
 128          * Very simple code to convert the addr->offset mappings that mono has
 129          * into [addr-addr] ->line number mappings.
 130          */
 131
 132         /* Create offset->line number mapping */
 133         for (i = 0; i < header->code_size; ++i) {
 134                 char *fname;
 135
 136                 fname = mono_debug_source_location_from_il_offset (method, i, &lines [i]);
 137                 if (!filename)
 138                         filename = fname;
 139         }
 140
 141         /* Create address->offset mapping */
 142         for (i = 0; i < jit->line_numbers->len; ++i) {
 143                 MonoDebugLineNumberEntry *lne = &g_array_index (jit->line_numbers, MonoDebugLineNumberEntry, i);
 144
 145                 g_assert (lne->offset <= header->code_size);
 146
 147                 if ((addresses [lne->offset] == 0) || (lne->address < addresses [lne->offset]))
 148                         addresses [lne->offset] = lne->address;
 149         }
 150         /* Fill out missing addresses */
 151         address = 0;
 152         for (i = 0; i < header->code_size; ++i) {
 153                 if (addresses [i] == 0)
 154                         addresses [i] = address;
 155                 else
 156                         address = addresses [i];
 157         }
 158
 159         address = 0;
 160         line_number = 0;
 161         i = 0;
 162         while (i < header->code_size) {
 163                 if (lines [i] == line_number)
 164                         i ++;
 165                 else {
 166                         if (line_number > 0) {
 167                                 //g_assert (addresses [i] - 1 >= address);
 168
 169                                 if (addresses [i] - 1 >= address) {
 170                                         VALGRIND_ADD_LINE_INFO (jit->code_start + address, jit->code_start + addresses [i] - 1, filename, line_number);
 171                                         //printf ("[%d-%d] -> %d.\n", address, addresses [i] - 1, line_number);
 172                                 }
 173                         }
 174                         address = addresses [i];
 175                         line_number = lines [i];
 176                 }
 177         }
 178
 179         if (line_number > 0) {
 180                 VALGRIND_ADD_LINE_INFO (jit->code_start + address, jit->code_start + jit->code_size - 1, filename, line_number);
 181                 //printf ("[%d-%d] -> %d.\n", address, jit->code_size - 1, line_number);
 182         }
 183
 184         VALGRIND_ADD_SYMBOL (jit->code_start, jit->code_size, full_name);
 185
 186         g_free (addresses);
 187         g_free (lines);
 188 #endif /* VALGRIND_ADD_LINE_INFO */
 189 }
 190
 191 void
 192 mono_debug_close_method (MonoCompile *cfg)
 193 {
 194         MiniDebugMethodInfo *info;
 195         MonoDebugMethodJitInfo *jit;
 196         MonoMethodHeader *header;
 197         MonoMethod *method;
 198         int i;
 199
 200         info = (MiniDebugMethodInfo *) cfg->debug_info;
 201         if (!info || !info->jit)
 202                 return;
 203
 204         method = cfg->method;
 205         header = mono_method_get_header (method);
 206
 207         jit = info->jit;
 208         jit->code_start = cfg->native_code;
 209         jit->epilogue_begin = cfg->epilog_begin;
 210         jit->code_size = cfg->code_len;
 211
 212         record_line_number (jit, jit->epilogue_begin, header->code_size);
 213
 214         jit->num_params = method->signature->param_count;
 215         jit->params = g_new0 (MonoDebugVarInfo, jit->num_params);
 216
 217         for (i = 0; i < jit->num_locals; i++)
 218                 write_variable (cfg->varinfo [cfg->locals_start + i], &jit->locals [i]);
 219
 220         if (method->signature->hasthis) {
 221                 jit->this_var = g_new0 (MonoDebugVarInfo, 1);
 222                 write_variable (cfg->varinfo [0], jit->this_var);
 223         }
 224
 225         for (i = 0; i < jit->num_params; i++)
 226                 write_variable (cfg->varinfo [i + method->signature->hasthis], &jit->params [i]);
 227
 228         mono_debug_add_method (method, jit, cfg->domain);
 229
 230         mono_debug_add_vg_method (method, jit);
 231
 232         if (info->breakpoint_id)
 233                 mono_debugger_breakpoint_callback (method, info->breakpoint_id);
 234 }
 235
 236 void
 237 mono_debug_record_line_number (MonoCompile *cfg, MonoInst *ins, guint32 address)
 238 {
 239         MiniDebugMethodInfo *info;
 240         MonoMethodHeader *header;
 241         guint32 offset;
 242
 243         info = (MiniDebugMethodInfo *) cfg->debug_info;
 244         if (!info || !info->jit || !ins->cil_code)
 245                 return;
 246
 247         header = mono_method_get_header (cfg->method);
 248         g_assert (header);
 249
 250         if ((ins->cil_code < header->code) ||
 251             (ins->cil_code > header->code + header->code_size))
 252                 return;
 253
 254         offset = ins->cil_code - header->code;
 255         if (!info->has_line_numbers) {
 256                 info->jit->prologue_end = address;
 257                 info->has_line_numbers = TRUE;
 258         }
 259
 260         record_line_number (info->jit, address, offset);
 261 }
 262
 263 static inline void
 264 encode_value (gint32 value, char *buf, char **endbuf)
 265 {
 266         char *p = buf;
 267
 268         //printf ("ENCODE: %d 0x%x.\n", value, value);
 269
 270         /*
 271          * Same encoding as the one used in the metadata, extended to handle values
 272          * greater than 0x1fffffff.
 273          */
 274         if ((value >= 0) && (value <= 127))
 275                 *p++ = value;
 276         else if ((value >= 0) && (value <= 16383)) {
 277                 p [0] = 0x80 | (value >> 8);
 278                 p [1] = value & 0xff;
 279                 p += 2;
 280         } else if ((value >= 0) && (value <= 0x1fffffff)) {
 281                 p [0] = (value >> 24) | 0xc0;
 282                 p [1] = (value >> 16) & 0xff;
 283                 p [2] = (value >> 8) & 0xff;
 284                 p [3] = value & 0xff;
 285                 p += 4;
 286         }
 287         else {
 288                 p [0] = 0xff;
 289                 p [1] = (value >> 24) & 0xff;
 290                 p [2] = (value >> 16) & 0xff;
 291                 p [3] = (value >> 8) & 0xff;
 292                 p [4] = value & 0xff;
 293                 p += 5;
 294         }
 295         if (endbuf)
 296                 *endbuf = p;
 297 }
 298
 299 static inline gint32
 300 decode_value (char *_ptr, char **rptr)
 301 {
 302         unsigned char *ptr = (unsigned char *) _ptr;
 303         unsigned char b = *ptr;
 304         gint32 len;
 305
 306         if ((b & 0x80) == 0){
 307                 len = b;
 308                 ++ptr;
 309         } else if ((b & 0x40) == 0){
 310                 len = ((b & 0x3f) << 8 | ptr [1]);
 311                 ptr += 2;
 312         } else if (b != 0xff) {
 313                 len = ((b & 0x1f) << 24) |
 314                         (ptr [1] << 16) |
 315                         (ptr [2] << 8) |
 316                         ptr [3];
 317                 ptr += 4;
 318         }
 319         else {
 320                 len = (ptr [1] << 24) | (ptr [2] << 16) | (ptr [3] << 8) | ptr [4];
 321                 ptr += 5;
 322         }
 323         if (rptr)
 324                 *rptr = ptr;
 325
 326         //printf ("DECODE: %d.\n", len);
 327         return len;
 328 }
 329
 330 static void
 331 serialize_variable (MonoDebugVarInfo *var, char *p, char **endbuf)
 332 {
 333         guint32 flags = var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
 334
 335         switch (flags) {
 336         case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
 337                 encode_value (var->index, p, &p);
 338                 break;
 339         case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
 340                 encode_value (var->index, p, &p);
 341                 encode_value (var->offset, p, &p);
 342                 break;
 343         default:
 344                 g_assert_not_reached ();
 345         }
 346         *endbuf = p;
 347 }
 348
 349 void
 350 mono_debug_serialize_debug_info (MonoCompile *cfg,
 351                                                                  guint8 **out_buf, guint32 *buf_len)
 352 {
 353         MiniDebugMethodInfo *info;
 354         MonoDebugMethodJitInfo *jit;
 355         guint32 size, prev_offset, prev_native_offset;
 356         char *buf;
 357         char *p;
 358         int i;
 359
 360         info = (MiniDebugMethodInfo *) cfg->debug_info;
 361         if (!info || !info->jit) {
 362                 *buf_len = 0;
 363                 return;
 364         }
 365         jit = info->jit;
 366
 367         size = ((jit->num_params + jit->num_locals + 1) * 10) + (jit->line_numbers->len * 10) + 64;
 368         p = buf = g_malloc (size);
 369         encode_value (jit->epilogue_begin, p, &p);
 370     encode_value (jit->prologue_end, p, &p);
 371         encode_value (jit->code_size, p, &p);
 372
 373         for (i = 0; i < jit->num_params; ++i)
 374                 serialize_variable (&jit->params [i], p, &p);
 375
 376         if (cfg->method->signature->hasthis)
 377                 serialize_variable (jit->this_var, p, &p);
 378
 379         for (i = 0; i < jit->num_locals; i++)
 380                 serialize_variable (&jit->locals [i], p, &p);
 381
 382         encode_value (jit->line_numbers->len, p, &p);
 383
 384         prev_offset = 0;
 385         prev_native_offset = 0;
 386         for (i = 0; i < jit->line_numbers->len; ++i) {
 387                 /* Sometimes, the offset values are not in increasing order */
 388                 MonoDebugLineNumberEntry *lne = &g_array_index (jit->line_numbers,
 389                                                                                                                 MonoDebugLineNumberEntry,
 390                                                                                                                 i);
 391                 encode_value (lne->il_offset - prev_offset, p, &p);
 392                 encode_value (lne->native_offset - prev_native_offset, p, &p);
 393                 prev_offset = lne->il_offset;
 394                 prev_native_offset = lne->native_offset;
 395         }
 396
 397         g_assert (p - buf < size);
 398
 399         *out_buf = buf;
 400         *buf_len = p - buf;
 401 }
 402
 403 static void
 404 deserialize_variable (MonoDebugVarInfo *var, char *p, char **endbuf)
 405 {
 406         guint32 flags;
 407
 408         var->index = decode_value (p, &p);
 409
 410         flags = var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
 411
 412         switch (flags) {
 413         case MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER:
 414                 break;
 415         case MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET:
 416                 var->offset = decode_value (p, &p);
 417                 break;
 418         default:
 419                 g_assert_not_reached ();
 420         }
 421         *endbuf = p;
 422 }
 423
 424 static MonoDebugMethodJitInfo *
 425 deserialize_debug_info (MonoMethod *method,
 426                                                 guint8 *code_start,
 427                                                 guint8 *buf, guint32 buf_len)
 428 {
 429         MonoMethodHeader *header;
 430         MonoDebugMethodJitInfo *jit;
 431         gint32 offset, native_offset, prev_offset, prev_native_offset, len;
 432         char *p;
 433         int i;
 434
 435         header = mono_method_get_header (method);
 436         g_assert (header);
 437
 438         jit = g_new0 (MonoDebugMethodJitInfo, 1);
 439         jit->code_start = code_start;
 440         jit->line_numbers = g_array_new (FALSE, TRUE, sizeof (MonoDebugLineNumberEntry));
 441         jit->num_locals = header->num_locals;
 442         jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals);
 443         jit->num_params = method->signature->param_count;
 444         jit->params = g_new0 (MonoDebugVarInfo, jit->num_params);
 445
 446         p = buf;
 447         jit->epilogue_begin = decode_value (p, &p);
 448         jit->prologue_end = decode_value (p, &p);
 449         jit->code_size = decode_value (p, &p);
 450
 451         for (i = 0; i < jit->num_params; ++i)
 452                 deserialize_variable (&jit->params [i], p, &p);
 453
 454         if (method->signature->hasthis) {
 455                 jit->this_var = g_new0 (MonoDebugVarInfo, 1);
 456                 deserialize_variable (jit->this_var, p, &p);
 457         }
 458
 459         for (i = 0; i < jit->num_locals; i++)
 460                 deserialize_variable (&jit->locals [i], p, &p);
 461
 462         len = decode_value (p, &p);
 463
 464         prev_offset = 0;
 465         prev_native_offset = 0;
 466         for (i = 0; i < len; ++i) {
 467                 offset = prev_offset + decode_value (p, &p);
 468                 native_offset = prev_native_offset + decode_value (p, &p);
 469                 record_line_number (jit, native_offset, offset);
 470                 prev_offset = offset;
 471                 prev_native_offset = native_offset;
 472         }
 473
 474         return jit;
 475 }
 476
 477 void
 478 mono_debug_add_aot_method (MonoDomain *domain,
 479                                                    MonoMethod *method, guint8 *code_start,
 480                                                    guint8 *debug_info, guint32 debug_info_len)
 481 {
 482         MonoDebugMethodJitInfo *jit;
 483
 484         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 485                 return;
 486
 487         if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
 488             (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
 489             (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
 490             (method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
 491             (method->wrapper_type != MONO_WRAPPER_NONE))
 492                 return;
 493
 494         if (debug_info_len == 0)
 495                 return;
 496
 497         jit = deserialize_debug_info (method, code_start,
 498                                                                   debug_info,
 499                                                                   debug_info_len);
 500
 501         mono_debug_add_method (method, jit, domain);
 502
 503         mono_debug_add_vg_method (method, jit);
 504 }
 505
 506 MonoDomain *
 507 mono_init_debugger (const char *file, const char *opt_flags)
 508 {
 509         MonoDomain *domain;
 510         const guchar *error;
 511         int opt;
 512
 513         g_set_prgname (file);
 514
 515         opt = mono_parse_default_optimizations (opt_flags);
 516         opt |= MONO_OPT_SHARED;
 517
 518         mono_set_defaults (0, opt);
 519
 520         domain = mono_jit_init (file);
 521
 522         mono_config_parse (NULL);
 523
 524         error = mono_check_corlib_version ();
 525         if (error) {
 526                 fprintf (stderr, "Corlib not in sync with this runtime: %s\n", error);
 527                 fprintf (stderr, "Download a newer corlib or a newer runtime at http://www.go-mono.com/daily.\n");
 528                 exit (1);
 529         }
 530
 531         return domain;
 532 }
 533
 534 void
 535 mono_debug_add_icall_wrapper (MonoMethod *method, MonoJitICallInfo* callinfo)
 536 {
 537         if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
 538                 return;
 539
 540         mono_debug_add_wrapper (method, callinfo->func, mono_get_root_domain ());
 541 }