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


mono_xdebug_init (const char * options)
{
  int D.22644;
  int iftmp.0;
  int D.22643;
  const char[4] * D.22692;
  unsigned char D.22693;
  int D.22694;
  unsigned char D.22695;
  int D.22696;
  _Bool D.22697;
  _Bool D.22698;
  _Bool D.22699;
  const unsigned char * D.22702;
  unsigned char D.22703;
  int D.22704;
  const unsigned char * D.22705;
  unsigned char D.22706;
  int D.22707;
  _Bool D.22708;
  _Bool D.22709;
  const unsigned char * D.22712;
  unsigned char D.22713;
  int D.22714;
  const unsigned char * D.22715;
  unsigned char D.22716;
  int D.22717;
  _Bool D.22718;
  _Bool D.22719;
  const unsigned char * D.22722;
  unsigned char D.22723;
  int D.22724;
  const unsigned char * D.22725;
  unsigned char D.22726;
  int D.22727;
  int D.22653;
  int iftmp.1;
  int D.22652;
  const char[14] * D.22734;
  unsigned char D.22735;
  int D.22736;
  unsigned char D.22737;
  int D.22738;
  _Bool D.22739;
  _Bool D.22740;
  _Bool D.22741;
  const unsigned char * D.22744;
  unsigned char D.22745;
  int D.22746;
  const unsigned char * D.22747;
  unsigned char D.22748;
  int D.22749;
  _Bool D.22750;
  _Bool D.22751;
  const unsigned char * D.22754;
  unsigned char D.22755;
  int D.22756;
  const unsigned char * D.22757;
  unsigned char D.22758;
  int D.22759;
  _Bool D.22760;
  _Bool D.22761;
  const unsigned char * D.22764;
  unsigned char D.22765;
  int D.22766;
  const unsigned char * D.22767;
  unsigned char D.22768;
  int D.22769;
  char * D.22774;
  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 GSList * D.22785;
  struct MonoDwarfWriter * xdebug_writer.8;
  struct MonoImageWriter * w;
  char * * args;
  char * * ptr;

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

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

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

        __s2 = arg;
        D.22692 = "gdb";
        D.22693 = MEM[(const unsigned char *)D.22692];
        D.22694 = (int) D.22693;
        D.22695 = *__s2;
        D.22696 = (int) D.22695;
        __result = D.22694 - D.22696;
        {
          D.22697 = __s2_len != 0;
          D.22698 = __result == 0;
          D.22699 = D.22697 & D.22698;
          if (D.22699 != 0) goto <D.22700>; else goto <D.22701>;
          <D.22700>:
          D.22702 = &MEM[(void *)"gdb" + 1B];
          D.22703 = *D.22702;
          D.22704 = (int) D.22703;
          D.22705 = __s2 + 1;
          D.22706 = *D.22705;
          D.22707 = (int) D.22706;
          __result = D.22704 - D.22707;
          D.22708 = __s2_len > 1;
          D.22698 = __result == 0;
          D.22709 = D.22708 & D.22698;
          if (D.22709 != 0) goto <D.22710>; else goto <D.22711>;
          <D.22710>:
          D.22712 = &MEM[(void *)"gdb" + 2B];
          D.22713 = *D.22712;
          D.22714 = (int) D.22713;
          D.22715 = __s2 + 2;
          D.22716 = *D.22715;
          D.22717 = (int) D.22716;
          __result = D.22714 - D.22717;
          D.22718 = __s2_len > 2;
          D.22698 = __result == 0;
          D.22719 = D.22718 & D.22698;
          if (D.22719 != 0) goto <D.22720>; else goto <D.22721>;
          <D.22720>:
          D.22722 = &MEM[(void *)"gdb" + 3B];
          D.22723 = *D.22722;
          D.22724 = (int) D.22723;
          D.22725 = __s2 + 3;
          D.22726 = *D.22725;
          D.22727 = (int) D.22726;
          __result = D.22724 - D.22727;
          <D.22721>:
          <D.22711>:
          <D.22701>:
        }
        D.22643 = __result;
      }
      iftmp.0 = -D.22643;
      goto <D.22728>;
      <D.22691>:
      iftmp.0 = __builtin_strcmp (arg, "gdb");
      <D.22728>:
      D.22644 = iftmp.0;
    }
    if (D.22644 == 0) goto <D.22729>; else goto <D.22730>;
    <D.22729>:
    use_gdb_interface = 1;
    <D.22730>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.22734 = "save-symfiles";
        D.22735 = MEM[(const unsigned char *)D.22734];
        D.22736 = (int) D.22735;
        D.22737 = *__s2;
        D.22738 = (int) D.22737;
        __result = D.22736 - D.22738;
        {
          D.22739 = __s2_len != 0;
          D.22740 = __result == 0;
          D.22741 = D.22739 & D.22740;
          if (D.22741 != 0) goto <D.22742>; else goto <D.22743>;
          <D.22742>:
          D.22744 = &MEM[(void *)"save-symfiles" + 1B];
          D.22745 = *D.22744;
          D.22746 = (int) D.22745;
          D.22747 = __s2 + 1;
          D.22748 = *D.22747;
          D.22749 = (int) D.22748;
          __result = D.22746 - D.22749;
          D.22750 = __s2_len > 1;
          D.22740 = __result == 0;
          D.22751 = D.22750 & D.22740;
          if (D.22751 != 0) goto <D.22752>; else goto <D.22753>;
          <D.22752>:
          D.22754 = &MEM[(void *)"save-symfiles" + 2B];
          D.22755 = *D.22754;
          D.22756 = (int) D.22755;
          D.22757 = __s2 + 2;
          D.22758 = *D.22757;
          D.22759 = (int) D.22758;
          __result = D.22756 - D.22759;
          D.22760 = __s2_len > 2;
          D.22740 = __result == 0;
          D.22761 = D.22760 & D.22740;
          if (D.22761 != 0) goto <D.22762>; else goto <D.22763>;
          <D.22762>:
          D.22764 = &MEM[(void *)"save-symfiles" + 3B];
          D.22765 = *D.22764;
          D.22766 = (int) D.22765;
          D.22767 = __s2 + 3;
          D.22768 = *D.22767;
          D.22769 = (int) D.22768;
          __result = D.22766 - D.22769;
          <D.22763>:
          <D.22753>:
          <D.22743>:
        }
        D.22652 = __result;
      }
      iftmp.1 = -D.22652;
      goto <D.22770>;
      <D.22733>:
      iftmp.1 = __builtin_strcmp (arg, "save-symfiles");
      <D.22770>:
      D.22653 = iftmp.1;
    }
    if (D.22653 == 0) goto <D.22771>; else goto <D.22772>;
    <D.22771>:
    save_symfiles = 1;
    <D.22772>:
  }
  ptr = ptr + 4;
  <D.22655>:
  if (ptr != 0B) goto <D.22773>; else goto <D.22656>;
  <D.22773>:
  D.22774 = *ptr;
  if (D.22774 != 0B) goto <D.22654>; else goto <D.22656>;
  <D.22656>:
  il_file.2 = fopen ("xdb.il", "w");
  il_file = il_file.2;
  il_file.3 = il_file;
  if (il_file.3 == 0B) goto <D.22777>; else goto <D.22778>;
  <D.22777>:
  use_gdb_interface = 0;
  monoeg_g_log (0B, 16, "** Unable to create xdb.il. Managed symbol names won\'t be available.");
  return;
  <D.22778>:
  use_gdb_interface.4 = use_gdb_interface;
  if (use_gdb_interface.4 != 0) goto <D.22780>; else goto <D.22781>;
  <D.22780>:
  return;
  <D.22781>:
  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, "");
  D.22785 = mono_unwind_get_cie_program ();
  xdebug_writer.8 = xdebug_writer;
  mono_dwarf_writer_emit_base_info (xdebug_writer.8, "JITted code", D.22785);
}


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.22789>; else goto <D.22790>;
  <D.22789>:
  xdebug_writer.10 = xdebug_writer;
  xdebug_w.9 = xdebug_w;
  xdebug_end_emit (xdebug_w.9, xdebug_writer.10, 0B);
  <D.22790>:
  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.22798;
  struct jit_code_entry * D.22799;
  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.22793>; else goto <D.22794>;
      <D.22793>:
      {
        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.22794>:
      entry = monoeg_malloc0 (20);
      entry->symfile_addr = img;
      psize = &entry->symfile_size1;
      img_size.14 = img_size;
      D.22798 = (long long unsigned int) img_size.14;
      *psize = D.22798;
      D.22799 = __jit_debug_descriptor.first_entry;
      entry->next_entry = D.22799;
      D.22799 = __jit_debug_descriptor.first_entry;
      if (D.22799 != 0B) goto <D.22800>; else goto <D.22801>;
      <D.22800>:
      D.22799 = __jit_debug_descriptor.first_entry;
      D.22799->prev_entry = entry;
      <D.22801>:
      __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.22807;
  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.22803>; else goto <D.22804>;
  <D.22803>:
  il_file.16 = fopen ("xdb.il", "w");
  il_file = il_file.16;
  <D.22804>:
  il_file_line_index.17 = il_file_line_index;
  il_file.15 = il_file;
  dw = mono_dwarf_writer_create (w, il_file.15, il_file_line_index.17, 0, 1);
  D.22807 = mono_unwind_get_cie_program ();
  mono_dwarf_writer_emit_base_info (dw, "JITted code", D.22807);
  *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.22816;
  int xdebug_method_count.22;
  struct MonoDomain * D.22820;
  struct MonoJitInfo * D.22821;
  struct MonoMethod * D.22822;
  struct GSList * D.22823;
  struct MonoInst * * D.22824;
  struct MonoInst * * D.22825;
  int D.22826;
  unsigned int D.22827;
  void * D.22828;
  struct MonoMethod * D.22829;
  struct MonoDwarfWriter * xdebug_writer.23;
  struct MonoDomain * D.22834;
  struct MonoMethod * D.22835;
  struct MonoMethod * D.22836;
  struct FILE * xdebug_fp.24;
  struct MonoDebugMethodJitInfo * dmji;

  use_gdb_interface.18 = use_gdb_interface;
  if (use_gdb_interface.18 != 0) goto <D.22809>; else goto <D.22810>;
  <D.22809>:
  mono_loader_lock ();
  xdebug_syms.19 = xdebug_syms;
  if (xdebug_syms.19 == 0B) goto <D.22812>; else goto <D.22813>;
  <D.22812>:
  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.22813>:
  xdebug_method_count.21 = xdebug_method_count;
  D.22816 = xdebug_method_count.21 % 100;
  if (D.22816 == 0) goto <D.22817>; else goto <D.22818>;
  <D.22817>:
  mono_xdebug_flush ();
  <D.22818>:
  xdebug_method_count.21 = xdebug_method_count;
  xdebug_method_count.22 = xdebug_method_count.21 + 1;
  xdebug_method_count = xdebug_method_count.22;
  D.22820 = mono_domain_get ();
  D.22821 = cfg->jit_info;
  D.22822 = jinfo_get_method (D.22821);
  dmji = mono_debug_find_method (D.22822, D.22820);
  D.22823 = cfg->unwind_ops;
  D.22824 = cfg->locals;
  D.22825 = cfg->args;
  D.22821 = cfg->jit_info;
  D.22826 = D.22821->code_size;
  D.22827 = (unsigned int) D.22826;
  D.22821 = cfg->jit_info;
  D.22828 = D.22821->code_start;
  D.22821 = cfg->jit_info;
  D.22829 = jinfo_get_method (D.22821);
  xdebug_writer.23 = xdebug_writer;
  mono_dwarf_writer_emit_method (xdebug_writer.23, cfg, D.22829, 0B, 0B, D.22828, D.22827, D.22825, D.22824, D.22823, dmji);
  mono_debug_free_method_jit_info (dmji);
  mono_loader_unlock ();
  goto <D.22831>;
  <D.22810>:
  xdebug_writer.23 = xdebug_writer;
  if (xdebug_writer.23 == 0B) goto <D.22832>; else goto <D.22833>;
  <D.22832>:
  return;
  <D.22833>:
  mono_loader_lock ();
  D.22834 = mono_domain_get ();
  D.22821 = cfg->jit_info;
  D.22835 = jinfo_get_method (D.22821);
  dmji = mono_debug_find_method (D.22835, D.22834);
  D.22823 = cfg->unwind_ops;
  D.22824 = cfg->locals;
  D.22825 = cfg->args;
  D.22821 = cfg->jit_info;
  D.22826 = D.22821->code_size;
  D.22827 = (unsigned int) D.22826;
  D.22821 = cfg->jit_info;
  D.22828 = D.22821->code_start;
  D.22821 = cfg->jit_info;
  D.22836 = jinfo_get_method (D.22821);
  xdebug_writer.23 = xdebug_writer;
  mono_dwarf_writer_emit_method (xdebug_writer.23, cfg, D.22836, 0B, 0B, D.22828, D.22827, D.22825, D.22824, D.22823, dmji);
  mono_debug_free_method_jit_info (dmji);
  xdebug_fp.24 = xdebug_fp;
  fflush (xdebug_fp.24);
  mono_loader_unlock ();
  <D.22831>:
}


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

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


mono_save_trampoline_xdebug_info (struct MonoTrampInfo * info)
{
  int use_gdb_interface.25;
  struct GSList * D.22844;
  unsigned int D.22845;
  guint8 * D.22846;
  char * D.22847;
  struct MonoDwarfWriter * dw.26;
  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.22842>; else goto <D.22843>;
  <D.22842>:
  {
    struct MonoImageWriter * w;
    struct MonoDwarfWriter * dw;

    try
      {
        mono_loader_lock_if_inited ();
        xdebug_begin_emit (&w, &dw);
        D.22844 = info->unwind_ops;
        D.22845 = info->code_size;
        D.22846 = info->code;
        D.22847 = info->name;
        dw.26 = dw;
        mono_dwarf_writer_emit_trampoline (dw.26, D.22847, 0B, 0B, D.22846, D.22845, D.22844);
        dw.26 = dw;
        w.27 = w;
        xdebug_end_emit (w.27, dw.26, 0B);
        mono_loader_unlock_if_inited ();
      }
    finally
      {
        w = {CLOBBER};
        dw = {CLOBBER};
      }
  }
  goto <D.22850>;
  <D.22843>:
  xdebug_writer.28 = xdebug_writer;
  if (xdebug_writer.28 == 0B) goto <D.22852>; else goto <D.22853>;
  <D.22852>:
  return;
  <D.22853>:
  mono_loader_lock_if_inited ();
  D.22844 = info->unwind_ops;
  D.22845 = info->code_size;
  D.22846 = info->code;
  D.22847 = info->name;
  xdebug_writer.28 = xdebug_writer;
  mono_dwarf_writer_emit_trampoline (xdebug_writer.28, D.22847, 0B, 0B, D.22846, D.22845, D.22844);
  xdebug_fp.29 = xdebug_fp;
  fflush (xdebug_fp.29);
  mono_loader_unlock_if_inited ();
  <D.22850>:
}