__jit_debug_register_code ()
{
  __asm__ __volatile__("");
}


mono_xdebug_init (const char * options)
{
  int D.22326;
  int iftmp.0;
  int D.22325;
  const char[4] * D.22374;
  unsigned char D.22375;
  int D.22376;
  unsigned char D.22377;
  int D.22378;
  const unsigned char * D.22383;
  unsigned char D.22384;
  int D.22385;
  const unsigned char * D.22386;
  unsigned char D.22387;
  int D.22388;
  const unsigned char * D.22393;
  unsigned char D.22394;
  int D.22395;
  const unsigned char * D.22396;
  unsigned char D.22397;
  int D.22398;
  const unsigned char * D.22403;
  unsigned char D.22404;
  int D.22405;
  const unsigned char * D.22406;
  unsigned char D.22407;
  int D.22408;
  int D.22335;
  int iftmp.1;
  int D.22334;
  const char[14] * D.22415;
  unsigned char D.22416;
  int D.22417;
  unsigned char D.22418;
  int D.22419;
  const unsigned char * D.22424;
  unsigned char D.22425;
  int D.22426;
  const unsigned char * D.22427;
  unsigned char D.22428;
  int D.22429;
  const unsigned char * D.22434;
  unsigned char D.22435;
  int D.22436;
  const unsigned char * D.22437;
  unsigned char D.22438;
  int D.22439;
  const unsigned char * D.22444;
  unsigned char D.22445;
  int D.22446;
  const unsigned char * D.22447;
  unsigned char D.22448;
  int D.22449;
  char * D.22454;
  struct FILE * il_file.2;
  struct FILE * il_file.3;
  int use_gdb_interface.4;
  struct FILE * xdebug_fp.5;
  struct FILE * xdebug_fp.6;
  struct MonoDwarfWriter * xdebug_writer.7;
  struct MonoDwarfWriter * xdebug_writer.8;
  struct GSList * D.22466;
  struct MonoImageWriter * w;
  char * * args;
  char * * ptr;

  args = monoeg_g_strsplit (options, ",", -1);
  ptr = args;
  goto <D.22337>;
  <D.22336>:
  {
    char * arg;

    arg = *ptr;
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 3;
      if (__s2_len <= 3) goto <D.22372>; else goto <D.22373>;
      <D.22372>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.22374 = "gdb";
        D.22375 = MEM[(const unsigned char *)D.22374];
        D.22376 = (int) D.22375;
        D.22377 = *__s2;
        D.22378 = (int) D.22377;
        __result = D.22376 - D.22378;
        {
          if (__s2_len != 0) goto <D.22379>; else goto <D.22380>;
          <D.22379>:
          if (__result == 0) goto <D.22381>; else goto <D.22382>;
          <D.22381>:
          D.22383 = &MEM[(void *)"gdb" + 1B];
          D.22384 = *D.22383;
          D.22385 = (int) D.22384;
          D.22386 = __s2 + 1;
          D.22387 = *D.22386;
          D.22388 = (int) D.22387;
          __result = D.22385 - D.22388;
          if (__s2_len > 1) goto <D.22389>; else goto <D.22390>;
          <D.22389>:
          if (__result == 0) goto <D.22391>; else goto <D.22392>;
          <D.22391>:
          D.22393 = &MEM[(void *)"gdb" + 2B];
          D.22394 = *D.22393;
          D.22395 = (int) D.22394;
          D.22396 = __s2 + 2;
          D.22397 = *D.22396;
          D.22398 = (int) D.22397;
          __result = D.22395 - D.22398;
          if (__s2_len > 2) goto <D.22399>; else goto <D.22400>;
          <D.22399>:
          if (__result == 0) goto <D.22401>; else goto <D.22402>;
          <D.22401>:
          D.22403 = &MEM[(void *)"gdb" + 3B];
          D.22404 = *D.22403;
          D.22405 = (int) D.22404;
          D.22406 = __s2 + 3;
          D.22407 = *D.22406;
          D.22408 = (int) D.22407;
          __result = D.22405 - D.22408;
          <D.22402>:
          <D.22400>:
          <D.22392>:
          <D.22390>:
          <D.22382>:
          <D.22380>:
        }
        D.22325 = __result;
      }
      iftmp.0 = -D.22325;
      goto <D.22409>;
      <D.22373>:
      iftmp.0 = __builtin_strcmp (arg, "gdb");
      <D.22409>:
      D.22326 = iftmp.0;
    }
    if (D.22326 == 0) goto <D.22410>; else goto <D.22411>;
    <D.22410>:
    use_gdb_interface = 1;
    <D.22411>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 13;
      if (__s2_len <= 3) goto <D.22413>; else goto <D.22414>;
      <D.22413>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = arg;
        D.22415 = "save-symfiles";
        D.22416 = MEM[(const unsigned char *)D.22415];
        D.22417 = (int) D.22416;
        D.22418 = *__s2;
        D.22419 = (int) D.22418;
        __result = D.22417 - D.22419;
        {
          if (__s2_len != 0) goto <D.22420>; else goto <D.22421>;
          <D.22420>:
          if (__result == 0) goto <D.22422>; else goto <D.22423>;
          <D.22422>:
          D.22424 = &MEM[(void *)"save-symfiles" + 1B];
          D.22425 = *D.22424;
          D.22426 = (int) D.22425;
          D.22427 = __s2 + 1;
          D.22428 = *D.22427;
          D.22429 = (int) D.22428;
          __result = D.22426 - D.22429;
          if (__s2_len > 1) goto <D.22430>; else goto <D.22431>;
          <D.22430>:
          if (__result == 0) goto <D.22432>; else goto <D.22433>;
          <D.22432>:
          D.22434 = &MEM[(void *)"save-symfiles" + 2B];
          D.22435 = *D.22434;
          D.22436 = (int) D.22435;
          D.22437 = __s2 + 2;
          D.22438 = *D.22437;
          D.22439 = (int) D.22438;
          __result = D.22436 - D.22439;
          if (__s2_len > 2) goto <D.22440>; else goto <D.22441>;
          <D.22440>:
          if (__result == 0) goto <D.22442>; else goto <D.22443>;
          <D.22442>:
          D.22444 = &MEM[(void *)"save-symfiles" + 3B];
          D.22445 = *D.22444;
          D.22446 = (int) D.22445;
          D.22447 = __s2 + 3;
          D.22448 = *D.22447;
          D.22449 = (int) D.22448;
          __result = D.22446 - D.22449;
          <D.22443>:
          <D.22441>:
          <D.22433>:
          <D.22431>:
          <D.22423>:
          <D.22421>:
        }
        D.22334 = __result;
      }
      iftmp.1 = -D.22334;
      goto <D.22450>;
      <D.22414>:
      iftmp.1 = __builtin_strcmp (arg, "save-symfiles");
      <D.22450>:
      D.22335 = iftmp.1;
    }
    if (D.22335 == 0) goto <D.22451>; else goto <D.22452>;
    <D.22451>:
    save_symfiles = 1;
    <D.22452>:
  }
  ptr = ptr + 4;
  <D.22337>:
  if (ptr != 0B) goto <D.22453>; else goto <D.22338>;
  <D.22453>:
  D.22454 = *ptr;
  if (D.22454 != 0B) goto <D.22336>; else goto <D.22338>;
  <D.22338>:
  il_file.2 = fopen ("xdb.il", "w");
  il_file = il_file.2;
  il_file.3 = il_file;
  if (il_file.3 == 0B) goto <D.22457>; else goto <D.22458>;
  <D.22457>:
  use_gdb_interface = 0;
  monoeg_g_log (0B, 16, "** Unable to create xdb.il. Managed symbol names won\'t be available.");
  return;
  <D.22458>:
  use_gdb_interface.4 = use_gdb_interface;
  if (use_gdb_interface.4 != 0) goto <D.22460>; else goto <D.22461>;
  <D.22460>:
  return;
  <D.22461>:
  unlink ("xdb.s");
  xdebug_fp.5 = fopen ("xdb.s", "w");
  xdebug_fp = xdebug_fp.5;
  xdebug_fp.6 = xdebug_fp;
  w = img_writer_create (xdebug_fp.6, 0);
  img_writer_emit_start (w);
  il_file.3 = il_file;
  xdebug_writer.7 = mono_dwarf_writer_create (w, il_file.3, 0, 1, 1);
  xdebug_writer = xdebug_writer.7;
  img_writer_emit_section_change (w, ".text", 0);
  img_writer_emit_string (w, "");
  xdebug_writer.8 = xdebug_writer;
  D.22466 = mono_unwind_get_cie_program ();
  mono_dwarf_writer_emit_base_info (xdebug_writer.8, "JITted code", D.22466);
}


mono_xdebug_flush ()
{
  struct MonoImageWriter * xdebug_w.9;
  struct MonoDwarfWriter * xdebug_writer.10;

  xdebug_w.9 = xdebug_w;
  if (xdebug_w.9 != 0B) goto <D.22469>; else goto <D.22470>;
  <D.22469>:
  xdebug_w.9 = xdebug_w;
  xdebug_writer.10 = xdebug_writer;
  xdebug_end_emit (xdebug_w.9, xdebug_writer.10, 0B);
  <D.22470>:
  xdebug_begin_emit (&xdebug_w, &xdebug_writer);
}


xdebug_end_emit (struct MonoImageWriter * w, struct MonoDwarfWriter * dw, struct MonoMethod * method)
{
  int il_file_line_index.11;
  int file_counter.12;
  int file_counter.13;
  unsigned int img_size.14;
  long long unsigned int D.22478;
  struct jit_code_entry * D.22479;
  guint8 * img;
  guint32 img_size;
  struct jit_code_entry * entry;
  guint64 * psize;

  try
    {
      il_file_line_index.11 = mono_dwarf_writer_get_il_file_line_index (dw);
      il_file_line_index = il_file_line_index.11;
      mono_dwarf_writer_close (dw);
      img_writer_emit_writeout (w);
      img = img_writer_get_output (w, &img_size);
      img_writer_destroy (w);
      if (0 != 0) goto <D.22473>; else goto <D.22474>;
      <D.22473>:
      {
        struct FILE * fp;
        char * file_name;
        static int file_counter;

        file_counter.12 = file_counter;
        file_counter.13 = file_counter.12 + 1;
        file_counter = file_counter.13;
        file_counter.12 = file_counter;
        file_name = monoeg_g_strdup_printf ("xdb-%d.o", file_counter.12);
        img_size.14 = img_size;
        printf ("%s %p %d\n", file_name, img, img_size.14);
        fp = fopen (file_name, "w");
        img_size.14 = img_size;
        fwrite (img, img_size.14, 1, fp);
        fclose (fp);
        monoeg_g_free (file_name);
      }
      <D.22474>:
      entry = monoeg_malloc0 (20);
      entry->symfile_addr = img;
      psize = &entry->symfile_size1;
      img_size.14 = img_size;
      D.22478 = (long long unsigned int) img_size.14;
      *psize = D.22478;
      D.22479 = __jit_debug_descriptor.first_entry;
      entry->next_entry = D.22479;
      D.22479 = __jit_debug_descriptor.first_entry;
      if (D.22479 != 0B) goto <D.22480>; else goto <D.22481>;
      <D.22480>:
      D.22479 = __jit_debug_descriptor.first_entry;
      D.22479->prev_entry = entry;
      <D.22481>:
      __jit_debug_descriptor.first_entry = entry;
      __jit_debug_descriptor.relevant_entry = entry;
      __jit_debug_descriptor.action_flag = 1;
      __jit_debug_register_code ();
    }
  finally
    {
      img_size = {CLOBBER};
    }
}


xdebug_begin_emit (struct MonoImageWriter * * out_w, struct MonoDwarfWriter * * out_dw)
{
  struct FILE * il_file.15;
  struct FILE * il_file.16;
  int il_file_line_index.17;
  struct GSList * D.22487;
  struct MonoImageWriter * w;
  struct MonoDwarfWriter * dw;

  w = img_writer_create (0B, 1);
  img_writer_emit_start (w);
  il_file.15 = il_file;
  if (il_file.15 == 0B) goto <D.22483>; else goto <D.22484>;
  <D.22483>:
  il_file.16 = fopen ("xdb.il", "w");
  il_file = il_file.16;
  <D.22484>:
  il_file.15 = il_file;
  il_file_line_index.17 = il_file_line_index;
  dw = mono_dwarf_writer_create (w, il_file.15, il_file_line_index.17, 0, 1);
  D.22487 = mono_unwind_get_cie_program ();
  mono_dwarf_writer_emit_base_info (dw, "JITted code", D.22487);
  *out_w = w;
  *out_dw = dw;
}


mono_save_xdebug_info (struct MonoCompile * cfg)
{
  int use_gdb_interface.18;
  struct GHashTable * xdebug_syms.19;
  struct GHashTable * xdebug_syms.20;
  int xdebug_method_count.21;
  int D.22496;
  int xdebug_method_count.22;
  struct MonoJitInfo * D.22500;
  struct MonoMethod * D.22501;
  struct MonoDomain * D.22502;
  struct MonoDwarfWriter * xdebug_writer.23;
  struct MonoMethod * D.22504;
  void * D.22505;
  int D.22506;
  unsigned int D.22507;
  struct MonoInst * * D.22508;
  struct MonoInst * * D.22509;
  struct GSList * D.22510;
  struct MonoMethod * D.22514;
  struct MonoDomain * D.22515;
  struct MonoMethod * D.22516;
  struct FILE * xdebug_fp.24;
  struct MonoDebugMethodJitInfo * dmji;

  use_gdb_interface.18 = use_gdb_interface;
  if (use_gdb_interface.18 != 0) goto <D.22489>; else goto <D.22490>;
  <D.22489>:
  mono_loader_lock ();
  xdebug_syms.19 = xdebug_syms;
  if (xdebug_syms.19 == 0B) goto <D.22492>; else goto <D.22493>;
  <D.22492>:
  xdebug_syms.20 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  xdebug_syms = xdebug_syms.20;
  <D.22493>:
  xdebug_method_count.21 = xdebug_method_count;
  D.22496 = xdebug_method_count.21 % 100;
  if (D.22496 == 0) goto <D.22497>; else goto <D.22498>;
  <D.22497>:
  mono_xdebug_flush ();
  <D.22498>:
  xdebug_method_count.21 = xdebug_method_count;
  xdebug_method_count.22 = xdebug_method_count.21 + 1;
  xdebug_method_count = xdebug_method_count.22;
  D.22500 = cfg->jit_info;
  D.22501 = jinfo_get_method (D.22500);
  D.22502 = mono_domain_get ();
  dmji = mono_debug_find_method (D.22501, D.22502);
  xdebug_writer.23 = xdebug_writer;
  D.22500 = cfg->jit_info;
  D.22504 = jinfo_get_method (D.22500);
  D.22500 = cfg->jit_info;
  D.22505 = D.22500->code_start;
  D.22500 = cfg->jit_info;
  D.22506 = D.22500->code_size;
  D.22507 = (unsigned int) D.22506;
  D.22508 = cfg->args;
  D.22509 = cfg->locals;
  D.22510 = cfg->unwind_ops;
  mono_dwarf_writer_emit_method (xdebug_writer.23, cfg, D.22504, 0B, 0B, D.22505, D.22507, D.22508, D.22509, D.22510, dmji);
  mono_debug_free_method_jit_info (dmji);
  mono_loader_unlock ();
  goto <D.22511>;
  <D.22490>:
  xdebug_writer.23 = xdebug_writer;
  if (xdebug_writer.23 == 0B) goto <D.22512>; else goto <D.22513>;
  <D.22512>:
  return;
  <D.22513>:
  mono_loader_lock ();
  D.22500 = cfg->jit_info;
  D.22514 = jinfo_get_method (D.22500);
  D.22515 = mono_domain_get ();
  dmji = mono_debug_find_method (D.22514, D.22515);
  xdebug_writer.23 = xdebug_writer;
  D.22500 = cfg->jit_info;
  D.22516 = jinfo_get_method (D.22500);
  D.22500 = cfg->jit_info;
  D.22505 = D.22500->code_start;
  D.22500 = cfg->jit_info;
  D.22506 = D.22500->code_size;
  D.22507 = (unsigned int) D.22506;
  D.22508 = cfg->args;
  D.22509 = cfg->locals;
  D.22510 = cfg->unwind_ops;
  mono_dwarf_writer_emit_method (xdebug_writer.23, cfg, D.22516, 0B, 0B, D.22505, D.22507, D.22508, D.22509, D.22510, dmji);
  mono_debug_free_method_jit_info (dmji);
  xdebug_fp.24 = xdebug_fp;
  fflush (xdebug_fp.24);
  mono_loader_unlock ();
  <D.22511>:
}


jinfo_get_method (struct MonoJitInfo * ji)
{
  struct MonoMethod * D.22519;

  D.22519 = mono_jit_info_get_method (ji);
  return D.22519;
}


mono_save_trampoline_xdebug_info (struct MonoTrampInfo * info)
{
  int use_gdb_interface.25;
  struct MonoDwarfWriter * dw.26;
  char * D.22525;
  guint8 * D.22526;
  unsigned int D.22527;
  struct GSList * D.22528;
  struct MonoImageWriter * w.27;
  struct MonoDwarfWriter * xdebug_writer.28;
  struct FILE * xdebug_fp.29;

  use_gdb_interface.25 = use_gdb_interface;
  if (use_gdb_interface.25 != 0) goto <D.22522>; else goto <D.22523>;
  <D.22522>:
  {
    struct MonoImageWriter * w;
    struct MonoDwarfWriter * dw;

    try
      {
        mono_loader_lock_if_inited ();
        xdebug_begin_emit (&w, &dw);
        dw.26 = dw;
        D.22525 = info->name;
        D.22526 = info->code;
        D.22527 = info->code_size;
        D.22528 = info->unwind_ops;
        mono_dwarf_writer_emit_trampoline (dw.26, D.22525, 0B, 0B, D.22526, D.22527, D.22528);
        w.27 = w;
        dw.26 = dw;
        xdebug_end_emit (w.27, dw.26, 0B);
        mono_loader_unlock_if_inited ();
      }
    finally
      {
        w = {CLOBBER};
        dw = {CLOBBER};
      }
  }
  goto <D.22530>;
  <D.22523>:
  xdebug_writer.28 = xdebug_writer;
  if (xdebug_writer.28 == 0B) goto <D.22532>; else goto <D.22533>;
  <D.22532>:
  return;
  <D.22533>:
  mono_loader_lock_if_inited ();
  xdebug_writer.28 = xdebug_writer;
  D.22525 = info->name;
  D.22526 = info->code;
  D.22527 = info->code_size;
  D.22528 = info->unwind_ops;
  mono_dwarf_writer_emit_trampoline (xdebug_writer.28, D.22525, 0B, 0B, D.22526, D.22527, D.22528);
  xdebug_fp.29 = xdebug_fp;
  fflush (xdebug_fp.29);
  mono_loader_unlock_if_inited ();
  <D.22530>:
}