mono/mini/xdebug.c

   1 /**
   2  * \file
   3  * Support for emitting gdb debug info for JITted code.
   4  *
   5  * Author:
   6  *   Zoltan Varga (vargaz@gmail.com)
   7  *
   8  * (C) 2010 Novell, Inc.
   9  */
  10
  11 /*
  12  * This works as follows:
  13  * - the runtime writes out an xdb.s file containing DWARF debug info.
  14  * - the user calls a gdb macro
  15  * - the macro compiles and loads this shared library using add-symbol-file.
  16  *
  17  * This is based on the xdebug functionality in the Kaffe Java VM.
  18  *
  19  * We emit assembly code instead of using the ELF writer, so we can emit debug info
  20  * incrementally as each method is JITted, and the debugger doesn't have to call
  21  * into the runtime to emit the shared library, which would cause all kinds of
  22  * complications, like threading issues, and the fact that the ELF writer's
  23  * emit_writeout () function cannot be called more than once.
  24  * GDB 7.0 and later has a JIT interface.
  25  */
  26
  27 #include "config.h"
  28 #include <glib.h>
  29 #include "mini.h"
  30 #include "mini-runtime.h"
  31
  32 #include <sys/types.h>
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36 #ifdef HAVE_STDINT_H
  37 #include <stdint.h>
  38 #endif
  39 #include <fcntl.h>
  40 #include <ctype.h>
  41 #include <string.h>
  42 #ifndef HOST_WIN32
  43 #include <sys/time.h>
  44 #else
  45 #include <winsock2.h>
  46 #include <windows.h>
  47 #endif
  48
  49 #include <errno.h>
  50 #include <sys/stat.h>
  51
  52 #include "image-writer.h"
  53
  54 #if !defined(DISABLE_AOT) && !defined(DISABLE_JIT) && USE_BIN_WRITER
  55
  56 #include "dwarfwriter.h"
  57
  58 #include "mono/utils/mono-compiler.h"
  59
  60 #define USE_GDB_JIT_INTERFACE
  61
  62 /* The recommended gdb macro is: */
  63 /*
  64   define xdb
  65   shell rm -f xdb.so && as --64 -o xdb.o xdb.s && ld -shared -o xdb.so xdb.o
  66   add-symbol-file xdb.so 0
  67   end
  68 */
  69
  70 /*
  71  * GDB JIT interface definitions.
  72  *
  73  *      http://sources.redhat.com/gdb/onlinedocs/gdb_30.html
  74  */
  75 typedef enum
  76 {
  77   JIT_NOACTION = 0,
  78   JIT_REGISTER_FN,
  79   JIT_UNREGISTER_FN
  80 } jit_actions_t;
  81
  82 struct jit_code_entry;
  83 typedef struct jit_code_entry jit_code_entry;
  84
  85 struct jit_code_entry
  86 {
  87         jit_code_entry *next_entry;
  88         jit_code_entry *prev_entry;
  89         const char *symfile_addr;
  90         /*
  91          * The gdb code in gdb/jit.c which reads this structure ignores alignment
  92          * requirements, so use two 32 bit fields.
  93          */
  94         guint32 symfile_size1, symfile_size2;
  95 };
  96
  97 typedef struct jit_descriptor
  98 {
  99         guint32 version;
 100         /* This type should be jit_actions_t, but we use guint32
 101            to be explicit about the bitwidth.  */
 102         guint32 action_flag;
 103         jit_code_entry *relevant_entry;
 104         jit_code_entry *first_entry;
 105 } jit_descriptor;
 106
 107 G_BEGIN_DECLS
 108
 109 /* GDB puts a breakpoint in this function.  */
 110 void MONO_NEVER_INLINE __jit_debug_register_code(void);
 111
 112 #if !defined(MONO_LLVM_LOADED) && defined(ENABLE_LLVM) && !defined(MONO_CROSS_COMPILE)
 113
 114 /* LLVM already defines these */
 115
 116 extern jit_descriptor __jit_debug_descriptor;
 117
 118 #else
 119
 120 /* gcc seems to inline/eliminate calls to noinline functions, thus the asm () */
 121 void MONO_NEVER_INLINE __jit_debug_register_code(void) {
 122 #if defined(__GNUC__)
 123         asm ("");
 124 #endif
 125 }
 126
 127 /* Make sure to specify the version statically, because the
 128    debugger may check the version before we can set it.  */
 129 jit_descriptor __jit_debug_descriptor = { 1, 0, 0, 0 };
 130
 131 #endif
 132
 133 G_END_DECLS
 134
 135 static MonoImageWriter *xdebug_w;
 136 static MonoDwarfWriter *xdebug_writer;
 137 static FILE *xdebug_fp, *il_file;
 138 static gboolean use_gdb_interface, save_symfiles;
 139 static int il_file_line_index;
 140 static GHashTable *xdebug_syms;
 141
 142 void
 143 mono_xdebug_init (const char *options)
 144 {
 145         MonoImageWriter *w;
 146         char **args, **ptr;
 147
 148         args = g_strsplit (options, ",", -1);
 149         for (ptr = args; ptr && *ptr; ptr ++) {
 150                 char *arg = *ptr;
 151
 152                 if (!strcmp (arg, "gdb"))
 153                         use_gdb_interface = TRUE;
 154                 if (!strcmp (arg, "save-symfiles"))
 155                         save_symfiles = TRUE;
 156         }
 157
 158         /* This file will contain the IL code for methods which don't have debug info */
 159         il_file = fopen ("xdb.il", "w");
 160         if (il_file == NULL) {
 161                 use_gdb_interface = FALSE;
 162                 g_warning ("** Unable to create xdb.il. Managed symbol names won't be available.");
 163                 return;
 164         }
 165
 166         if (use_gdb_interface)
 167                 return;
 168
 169         unlink ("xdb.s");
 170         xdebug_fp = fopen ("xdb.s", "w");
 171
 172         w = mono_img_writer_create (xdebug_fp, FALSE);
 173
 174         mono_img_writer_emit_start (w);
 175
 176         xdebug_writer = mono_dwarf_writer_create (w, il_file, 0, TRUE);
 177
 178         /* Emit something so the file has a text segment */
 179         mono_img_writer_emit_section_change (w, ".text", 0);
 180         mono_img_writer_emit_string (w, "");
 181
 182         mono_dwarf_writer_emit_base_info (xdebug_writer, "JITted code", mono_unwind_get_cie_program ());
 183 }
 184
 185 static void
 186 xdebug_begin_emit (MonoImageWriter **out_w, MonoDwarfWriter **out_dw)
 187 {
 188         MonoImageWriter *w;
 189         MonoDwarfWriter *dw;
 190
 191         w = mono_img_writer_create (NULL, TRUE);
 192
 193         mono_img_writer_emit_start (w);
 194
 195         /* This file will contain the IL code for methods which don't have debug info */
 196         if (!il_file)
 197                 il_file = fopen ("xdb.il", "w");
 198
 199         dw = mono_dwarf_writer_create (w, il_file, il_file_line_index, TRUE);
 200
 201         mono_dwarf_writer_emit_base_info (dw, "JITted code", mono_unwind_get_cie_program ());
 202
 203         *out_w = w;
 204         *out_dw = dw;
 205 }
 206
 207 static void
 208 xdebug_end_emit (MonoImageWriter *w, MonoDwarfWriter *dw, MonoMethod *method)
 209 {
 210         guint8 *img;
 211         guint32 img_size;
 212         jit_code_entry *entry;
 213         guint64 *psize;
 214
 215         il_file_line_index = mono_dwarf_writer_get_il_file_line_index (dw);
 216         mono_dwarf_writer_close (dw);
 217
 218         mono_img_writer_emit_writeout (w);
 219
 220         img = mono_img_writer_get_output (w, &img_size);
 221
 222         mono_img_writer_destroy (w);
 223
 224         if (FALSE) {
 225                 /* Save the symbol files to help debugging */
 226                 FILE *fp;
 227                 char *file_name;
 228                 static int file_counter;
 229
 230                 file_counter ++;
 231                 file_name = g_strdup_printf ("xdb-%d.o", file_counter);
 232                 printf ("%s %p %d\n", file_name, img, img_size);
 233
 234                 fp = fopen (file_name, "w");
 235                 fwrite (img, img_size, 1, fp);
 236                 fclose (fp);
 237                 g_free (file_name);
 238         }
 239
 240         /* Register the image with GDB */
 241
 242         entry = g_malloc0 (sizeof (jit_code_entry));
 243
 244         entry->symfile_addr = (const char*)img;
 245         psize = (guint64*)&entry->symfile_size1;
 246         *psize = img_size;
 247
 248         entry->next_entry = __jit_debug_descriptor.first_entry;
 249         if (__jit_debug_descriptor.first_entry)
 250                 __jit_debug_descriptor.first_entry->prev_entry = entry;
 251         __jit_debug_descriptor.first_entry = entry;
 252
 253         __jit_debug_descriptor.relevant_entry = entry;
 254         __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
 255
 256         __jit_debug_register_code ();
 257 }
 258
 259 /*
 260  * mono_xdebug_flush:
 261  *
 262  *   This could be called from inside gdb to flush the debugging information not yet
 263  * registered with gdb.
 264  */
 265 void
 266 mono_xdebug_flush (void)
 267 {
 268         if (xdebug_w)
 269                 xdebug_end_emit (xdebug_w, xdebug_writer, NULL);
 270
 271         xdebug_begin_emit (&xdebug_w, &xdebug_writer);
 272 }
 273
 274 static int xdebug_method_count;
 275
 276 /*
 277  * mono_save_xdebug_info:
 278  *
 279  *   Emit debugging info for METHOD into an assembly file which can be assembled
 280  * and loaded into gdb to provide debugging info for JITted code.
 281  * LOCKING: Acquires the loader lock.
 282  */
 283 void
 284 mono_save_xdebug_info (MonoCompile *cfg)
 285 {
 286         MonoDebugMethodJitInfo *dmji;
 287
 288         if (use_gdb_interface) {
 289                 mono_loader_lock ();
 290
 291                 if (!xdebug_syms)
 292                         xdebug_syms = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 293
 294                 /*
 295                  * gdb is not designed to handle 1000s of symbol files (one per method). So we
 296                  * group them into groups of 100.
 297                  */
 298                 if ((xdebug_method_count % 100) == 0)
 299                         mono_xdebug_flush ();
 300
 301                 xdebug_method_count ++;
 302
 303                 dmji = mono_debug_find_method (jinfo_get_method (cfg->jit_info), mono_domain_get ());
 304                 mono_dwarf_writer_emit_method (xdebug_writer, cfg, jinfo_get_method (cfg->jit_info), NULL, NULL, NULL,
 305                                                                            (guint8*)cfg->jit_info->code_start, cfg->jit_info->code_size, cfg->args, cfg->locals, cfg->unwind_ops, dmji);
 306                 mono_debug_free_method_jit_info (dmji);
 307
 308 #if 0
 309                 /*
 310                  * Emit a symbol for the code by emitting it at the beginning of the text
 311                  * segment, and setting the text segment to have an absolute address.
 312                  * This symbol can be used to set breakpoints in gdb.
 313                  * FIXME: This doesn't work when multiple methods are emitted into the same file.
 314                  */
 315                 sym = get_debug_sym (cfg->jit_info->method, "", xdebug_syms);
 316                 mono_img_writer_emit_section_change (w, ".text", 0);
 317                 if (!xdebug_text_addr) {
 318                         xdebug_text_addr = cfg->jit_info->code_start;
 319                         mono_img_writer_set_section_addr (w, (gssize)xdebug_text_addr);
 320                 }
 321                 mono_img_writer_emit_global_with_size (w, sym, cfg->jit_info->code_size, TRUE);
 322                 mono_img_writer_emit_label (w, sym);
 323                 mono_img_writer_emit_bytes (w, cfg->jit_info->code_start, cfg->jit_info->code_size);
 324                 g_free (sym);
 325 #endif
 326
 327                 mono_loader_unlock ();
 328         } else {
 329                 if (!xdebug_writer)
 330                         return;
 331
 332                 mono_loader_lock ();
 333                 dmji = mono_debug_find_method (jinfo_get_method (cfg->jit_info), mono_domain_get ());
 334                 mono_dwarf_writer_emit_method (xdebug_writer, cfg, jinfo_get_method (cfg->jit_info), NULL, NULL, NULL,
 335                                                                            (guint8*)cfg->jit_info->code_start, cfg->jit_info->code_size, cfg->args, cfg->locals, cfg->unwind_ops, dmji);
 336                 mono_debug_free_method_jit_info (dmji);
 337                 fflush (xdebug_fp);
 338                 mono_loader_unlock ();
 339         }
 340
 341 }
 342
 343 /*
 344  * mono_save_trampoline_xdebug_info:
 345  *
 346  *   Same as mono_save_xdebug_info, but for trampolines.
 347  * LOCKING: Acquires the loader lock.
 348  */
 349 void
 350 mono_save_trampoline_xdebug_info (MonoTrampInfo *info)
 351 {
 352         const char *info_name = info->name;
 353         if (info_name == NULL)
 354                 info_name = "";
 355
 356         if (use_gdb_interface) {
 357                 MonoImageWriter *w;
 358                 MonoDwarfWriter *dw;
 359
 360                 /* This can be called before the loader lock is initialized */
 361                 mono_loader_lock_if_inited ();
 362
 363                 xdebug_begin_emit (&w, &dw);
 364
 365                 mono_dwarf_writer_emit_trampoline (dw, info_name, NULL, NULL, info->code, info->code_size, info->unwind_ops);
 366
 367                 xdebug_end_emit (w, dw, NULL);
 368
 369                 mono_loader_unlock_if_inited ();
 370         } else {
 371                 if (!xdebug_writer)
 372                         return;
 373
 374                 mono_loader_lock_if_inited ();
 375                 mono_dwarf_writer_emit_trampoline (xdebug_writer, info_name, NULL, NULL, info->code, info->code_size, info->unwind_ops);
 376                 fflush (xdebug_fp);
 377                 mono_loader_unlock_if_inited ();
 378         }
 379 }
 380
 381 #else /* !defined(DISABLE_AOT) && !defined(DISABLE_JIT) */
 382
 383 void
 384 mono_xdebug_init (const char *options)
 385 {
 386 }
 387
 388 void
 389 mono_save_xdebug_info (MonoCompile *cfg)
 390 {
 391 }
 392
 393 void
 394 mono_save_trampoline_xdebug_info (MonoTrampInfo *info)
 395 {
 396 }
 397
 398 #endif