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


mono_xdebug_init (const char * options)
{
  int D.23080;
  int iftmp.0;
  int D.23079;
  const char[4] * D.23128;
  unsigned char D.23129;
  int D.23130;
  unsigned char D.23131;
  int D.23132;
  _Bool D.23133;
  _Bool D.23134;
  _Bool D.23135;
  const unsigned char * D.23138;
  unsigned char D.23139;
  int D.23140;
  const unsigned char * D.23141;
  unsigned char D.23142;
  int D.23143;
  _Bool D.23144;
  _Bool D.23145;
  const unsigned char * D.23148;
  unsigned char D.23149;
  int D.23150;
  const unsigned char * D.23151;
  unsigned char D.23152;
  int D.23153;
  _Bool D.23154;
  _Bool D.23155;
  const unsigned char * D.23158;
  unsigned char D.23159;
  int D.23160;
  const unsigned char * D.23161;
  unsigned char D.23162;
  int D.23163;
  int D.23089;
  int iftmp.1;
  int D.23088;
  const char[14] * D.23170;
  unsigned char D.23171;
  int D.23172;
  unsigned char D.23173;
  int D.23174;
  _Bool D.23175;
  _Bool D.23176;
  _Bool D.23177;
  const unsigned char * D.23180;
  unsigned char D.23181;
  int D.23182;
  const unsigned char * D.23183;
  unsigned char D.23184;
  int D.23185;
  _Bool D.23186;
  _Bool D.23187;
  const unsigned char * D.23190;
  unsigned char D.23191;
  int D.23192;
  const unsigned char * D.23193;
  unsigned char D.23194;
  int D.23195;
  _Bool D.23196;
  _Bool D.23197;
  const unsigned char * D.23200;
  unsigned char D.23201;
  int D.23202;
  const unsigned char * D.23203;
  unsigned char D.23204;
  int D.23205;
  char * D.23210;
  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.23221;
  struct MonoDwarfWriter * xdebug_writer.8;
  struct MonoImageWriter * w;
  char * * args;
  char * * ptr;

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

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

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

        __s2 = arg;
        D.23128 = "gdb";
        D.23129 = MEM[(const unsigned char *)D.23128];
        D.23130 = (int) D.23129;
        D.23131 = *__s2;
        D.23132 = (int) D.23131;
        __result = D.23130 - D.23132;
        {
          D.23133 = __s2_len != 0;
          D.23134 = __result == 0;
          D.23135 = D.23133 & D.23134;
          if (D.23135 != 0) goto <D.23136>; else goto <D.23137>;
          <D.23136>:
          D.23138 = &MEM[(void *)"gdb" + 1B];
          D.23139 = *D.23138;
          D.23140 = (int) D.23139;
          D.23141 = __s2 + 1;
          D.23142 = *D.23141;
          D.23143 = (int) D.23142;
          __result = D.23140 - D.23143;
          D.23144 = __s2_len > 1;
          D.23134 = __result == 0;
          D.23145 = D.23144 & D.23134;
          if (D.23145 != 0) goto <D.23146>; else goto <D.23147>;
          <D.23146>:
          D.23148 = &MEM[(void *)"gdb" + 2B];
          D.23149 = *D.23148;
          D.23150 = (int) D.23149;
          D.23151 = __s2 + 2;
          D.23152 = *D.23151;
          D.23153 = (int) D.23152;
          __result = D.23150 - D.23153;
          D.23154 = __s2_len > 2;
          D.23134 = __result == 0;
          D.23155 = D.23154 & D.23134;
          if (D.23155 != 0) goto <D.23156>; else goto <D.23157>;
          <D.23156>:
          D.23158 = &MEM[(void *)"gdb" + 3B];
          D.23159 = *D.23158;
          D.23160 = (int) D.23159;
          D.23161 = __s2 + 3;
          D.23162 = *D.23161;
          D.23163 = (int) D.23162;
          __result = D.23160 - D.23163;
          <D.23157>:
          <D.23147>:
          <D.23137>:
        }
        D.23079 = __result;
      }
      iftmp.0 = -D.23079;
      goto <D.23164>;
      <D.23127>:
      iftmp.0 = __builtin_strcmp (arg, "gdb");
      <D.23164>:
      D.23080 = iftmp.0;
    }
    if (D.23080 == 0) goto <D.23165>; else goto <D.23166>;
    <D.23165>:
    use_gdb_interface = 1;
    <D.23166>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.23170 = "save-symfiles";
        D.23171 = MEM[(const unsigned char *)D.23170];
        D.23172 = (int) D.23171;
        D.23173 = *__s2;
        D.23174 = (int) D.23173;
        __result = D.23172 - D.23174;
        {
          D.23175 = __s2_len != 0;
          D.23176 = __result == 0;
          D.23177 = D.23175 & D.23176;
          if (D.23177 != 0) goto <D.23178>; else goto <D.23179>;
          <D.23178>:
          D.23180 = &MEM[(void *)"save-symfiles" + 1B];
          D.23181 = *D.23180;
          D.23182 = (int) D.23181;
          D.23183 = __s2 + 1;
          D.23184 = *D.23183;
          D.23185 = (int) D.23184;
          __result = D.23182 - D.23185;
          D.23186 = __s2_len > 1;
          D.23176 = __result == 0;
          D.23187 = D.23186 & D.23176;
          if (D.23187 != 0) goto <D.23188>; else goto <D.23189>;
          <D.23188>:
          D.23190 = &MEM[(void *)"save-symfiles" + 2B];
          D.23191 = *D.23190;
          D.23192 = (int) D.23191;
          D.23193 = __s2 + 2;
          D.23194 = *D.23193;
          D.23195 = (int) D.23194;
          __result = D.23192 - D.23195;
          D.23196 = __s2_len > 2;
          D.23176 = __result == 0;
          D.23197 = D.23196 & D.23176;
          if (D.23197 != 0) goto <D.23198>; else goto <D.23199>;
          <D.23198>:
          D.23200 = &MEM[(void *)"save-symfiles" + 3B];
          D.23201 = *D.23200;
          D.23202 = (int) D.23201;
          D.23203 = __s2 + 3;
          D.23204 = *D.23203;
          D.23205 = (int) D.23204;
          __result = D.23202 - D.23205;
          <D.23199>:
          <D.23189>:
          <D.23179>:
        }
        D.23088 = __result;
      }
      iftmp.1 = -D.23088;
      goto <D.23206>;
      <D.23169>:
      iftmp.1 = __builtin_strcmp (arg, "save-symfiles");
      <D.23206>:
      D.23089 = iftmp.1;
    }
    if (D.23089 == 0) goto <D.23207>; else goto <D.23208>;
    <D.23207>:
    save_symfiles = 1;
    <D.23208>:
  }
  ptr = ptr + 8;
  <D.23091>:
  if (ptr != 0B) goto <D.23209>; else goto <D.23092>;
  <D.23209>:
  D.23210 = *ptr;
  if (D.23210 != 0B) goto <D.23090>; else goto <D.23092>;
  <D.23092>:
  il_file.2 = fopen ("xdb.il", "w");
  il_file = il_file.2;
  il_file.3 = il_file;
  if (il_file.3 == 0B) goto <D.23213>; else goto <D.23214>;
  <D.23213>:
  use_gdb_interface = 0;
  monoeg_g_log (0B, 16, "** Unable to create xdb.il. Managed symbol names won\'t be available.");
  return;
  <D.23214>:
  use_gdb_interface.4 = use_gdb_interface;
  if (use_gdb_interface.4 != 0) goto <D.23216>; else goto <D.23217>;
  <D.23216>:
  return;
  <D.23217>:
  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.23221 = mono_unwind_get_cie_program ();
  xdebug_writer.8 = xdebug_writer;
  mono_dwarf_writer_emit_base_info (xdebug_writer.8, "JITted code", D.23221);
}


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.23225>; else goto <D.23226>;
  <D.23225>:
  xdebug_writer.10 = xdebug_writer;
  xdebug_w.9 = xdebug_w;
  xdebug_end_emit (xdebug_w.9, xdebug_writer.10, 0B);
  <D.23226>:
  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 unsigned int D.23234;
  long unsigned int D.23235;
  struct jit_code_entry * D.23236;
  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.23229>; else goto <D.23230>;
      <D.23229>:
      {
        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;
        D.23234 = (long unsigned int) img_size.14;
        fwrite (img, D.23234, 1, fp);
        fclose (fp);
        monoeg_g_free (file_name);
      }
      <D.23230>:
      entry = monoeg_malloc0 (32);
      entry->symfile_addr = img;
      psize = &entry->symfile_size1;
      img_size.14 = img_size;
      D.23235 = (long unsigned int) img_size.14;
      *psize = D.23235;
      D.23236 = __jit_debug_descriptor.first_entry;
      entry->next_entry = D.23236;
      D.23236 = __jit_debug_descriptor.first_entry;
      if (D.23236 != 0B) goto <D.23237>; else goto <D.23238>;
      <D.23237>:
      D.23236 = __jit_debug_descriptor.first_entry;
      D.23236->prev_entry = entry;
      <D.23238>:
      __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.23244;
  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.23240>; else goto <D.23241>;
  <D.23240>:
  il_file.16 = fopen ("xdb.il", "w");
  il_file = il_file.16;
  <D.23241>:
  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.23244 = mono_unwind_get_cie_program ();
  mono_dwarf_writer_emit_base_info (dw, "JITted code", D.23244);
  *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.23253;
  int xdebug_method_count.22;
  struct MonoDomain * D.23257;
  struct MonoJitInfo * D.23258;
  struct MonoMethod * D.23259;
  struct GSList * D.23260;
  struct MonoInst * * D.23261;
  struct MonoInst * * D.23262;
  int D.23263;
  unsigned int D.23264;
  void * D.23265;
  struct MonoMethod * D.23266;
  struct MonoDwarfWriter * xdebug_writer.23;
  struct MonoDomain * D.23271;
  struct MonoMethod * D.23272;
  struct MonoMethod * D.23273;
  struct FILE * xdebug_fp.24;
  struct MonoDebugMethodJitInfo * dmji;

  use_gdb_interface.18 = use_gdb_interface;
  if (use_gdb_interface.18 != 0) goto <D.23246>; else goto <D.23247>;
  <D.23246>:
  mono_loader_lock ();
  xdebug_syms.19 = xdebug_syms;
  if (xdebug_syms.19 == 0B) goto <D.23249>; else goto <D.23250>;
  <D.23249>:
  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.23250>:
  xdebug_method_count.21 = xdebug_method_count;
  D.23253 = xdebug_method_count.21 % 100;
  if (D.23253 == 0) goto <D.23254>; else goto <D.23255>;
  <D.23254>:
  mono_xdebug_flush ();
  <D.23255>:
  xdebug_method_count.21 = xdebug_method_count;
  xdebug_method_count.22 = xdebug_method_count.21 + 1;
  xdebug_method_count = xdebug_method_count.22;
  D.23257 = mono_domain_get ();
  D.23258 = cfg->jit_info;
  D.23259 = jinfo_get_method (D.23258);
  dmji = mono_debug_find_method (D.23259, D.23257);
  D.23260 = cfg->unwind_ops;
  D.23261 = cfg->locals;
  D.23262 = cfg->args;
  D.23258 = cfg->jit_info;
  D.23263 = D.23258->code_size;
  D.23264 = (unsigned int) D.23263;
  D.23258 = cfg->jit_info;
  D.23265 = D.23258->code_start;
  D.23258 = cfg->jit_info;
  D.23266 = jinfo_get_method (D.23258);
  xdebug_writer.23 = xdebug_writer;
  mono_dwarf_writer_emit_method (xdebug_writer.23, cfg, D.23266, 0B, 0B, D.23265, D.23264, D.23262, D.23261, D.23260, dmji);
  mono_debug_free_method_jit_info (dmji);
  mono_loader_unlock ();
  goto <D.23268>;
  <D.23247>:
  xdebug_writer.23 = xdebug_writer;
  if (xdebug_writer.23 == 0B) goto <D.23269>; else goto <D.23270>;
  <D.23269>:
  return;
  <D.23270>:
  mono_loader_lock ();
  D.23271 = mono_domain_get ();
  D.23258 = cfg->jit_info;
  D.23272 = jinfo_get_method (D.23258);
  dmji = mono_debug_find_method (D.23272, D.23271);
  D.23260 = cfg->unwind_ops;
  D.23261 = cfg->locals;
  D.23262 = cfg->args;
  D.23258 = cfg->jit_info;
  D.23263 = D.23258->code_size;
  D.23264 = (unsigned int) D.23263;
  D.23258 = cfg->jit_info;
  D.23265 = D.23258->code_start;
  D.23258 = cfg->jit_info;
  D.23273 = jinfo_get_method (D.23258);
  xdebug_writer.23 = xdebug_writer;
  mono_dwarf_writer_emit_method (xdebug_writer.23, cfg, D.23273, 0B, 0B, D.23265, D.23264, D.23262, D.23261, D.23260, dmji);
  mono_debug_free_method_jit_info (dmji);
  xdebug_fp.24 = xdebug_fp;
  fflush (xdebug_fp.24);
  mono_loader_unlock ();
  <D.23268>:
}


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

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


mono_save_trampoline_xdebug_info (struct MonoTrampInfo * info)
{
  int use_gdb_interface.25;
  struct GSList * D.23281;
  unsigned int D.23282;
  guint8 * D.23283;
  char * D.23284;
  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.23279>; else goto <D.23280>;
  <D.23279>:
  {
    struct MonoImageWriter * w;
    struct MonoDwarfWriter * dw;

    try
      {
        mono_loader_lock_if_inited ();
        xdebug_begin_emit (&w, &dw);
        D.23281 = info->unwind_ops;
        D.23282 = info->code_size;
        D.23283 = info->code;
        D.23284 = info->name;
        dw.26 = dw;
        mono_dwarf_writer_emit_trampoline (dw.26, D.23284, 0B, 0B, D.23283, D.23282, D.23281);
        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.23287>;
  <D.23280>:
  xdebug_writer.28 = xdebug_writer;
  if (xdebug_writer.28 == 0B) goto <D.23289>; else goto <D.23290>;
  <D.23289>:
  return;
  <D.23290>:
  mono_loader_lock_if_inited ();
  D.23281 = info->unwind_ops;
  D.23282 = info->code_size;
  D.23283 = info->code;
  D.23284 = info->name;
  xdebug_writer.28 = xdebug_writer;
  mono_dwarf_writer_emit_trampoline (xdebug_writer.28, D.23284, 0B, 0B, D.23283, D.23282, D.23281);
  xdebug_fp.29 = xdebug_fp;
  fflush (xdebug_fp.29);
  mono_loader_unlock_if_inited ();
  <D.23287>:
}