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


mono_xdebug_init (const char * options)
{
  int D.23174;
  int iftmp.0;
  int D.23173;
  const char[4] * D.23222;
  unsigned char D.23223;
  int D.23224;
  unsigned char D.23225;
  int D.23226;
  const unsigned char * D.23231;
  unsigned char D.23232;
  int D.23233;
  const unsigned char * D.23234;
  unsigned char D.23235;
  int D.23236;
  const unsigned char * D.23241;
  unsigned char D.23242;
  int D.23243;
  const unsigned char * D.23244;
  unsigned char D.23245;
  int D.23246;
  const unsigned char * D.23251;
  unsigned char D.23252;
  int D.23253;
  const unsigned char * D.23254;
  unsigned char D.23255;
  int D.23256;
  int D.23183;
  int iftmp.1;
  int D.23182;
  const char[14] * D.23263;
  unsigned char D.23264;
  int D.23265;
  unsigned char D.23266;
  int D.23267;
  const unsigned char * D.23272;
  unsigned char D.23273;
  int D.23274;
  const unsigned char * D.23275;
  unsigned char D.23276;
  int D.23277;
  const unsigned char * D.23282;
  unsigned char D.23283;
  int D.23284;
  const unsigned char * D.23285;
  unsigned char D.23286;
  int D.23287;
  const unsigned char * D.23292;
  unsigned char D.23293;
  int D.23294;
  const unsigned char * D.23295;
  unsigned char D.23296;
  int D.23297;
  char * D.23302;
  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.23314;
  struct MonoImageWriter * w;
  char * * args;
  char * * ptr;

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

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

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

        __s2 = arg;
        D.23222 = "gdb";
        D.23223 = MEM[(const unsigned char *)D.23222];
        D.23224 = (int) D.23223;
        D.23225 = *__s2;
        D.23226 = (int) D.23225;
        __result = D.23224 - D.23226;
        {
          if (__s2_len != 0) goto <D.23227>; else goto <D.23228>;
          <D.23227>:
          if (__result == 0) goto <D.23229>; else goto <D.23230>;
          <D.23229>:
          D.23231 = &MEM[(void *)"gdb" + 1B];
          D.23232 = *D.23231;
          D.23233 = (int) D.23232;
          D.23234 = __s2 + 1;
          D.23235 = *D.23234;
          D.23236 = (int) D.23235;
          __result = D.23233 - D.23236;
          if (__s2_len > 1) goto <D.23237>; else goto <D.23238>;
          <D.23237>:
          if (__result == 0) goto <D.23239>; else goto <D.23240>;
          <D.23239>:
          D.23241 = &MEM[(void *)"gdb" + 2B];
          D.23242 = *D.23241;
          D.23243 = (int) D.23242;
          D.23244 = __s2 + 2;
          D.23245 = *D.23244;
          D.23246 = (int) D.23245;
          __result = D.23243 - D.23246;
          if (__s2_len > 2) goto <D.23247>; else goto <D.23248>;
          <D.23247>:
          if (__result == 0) goto <D.23249>; else goto <D.23250>;
          <D.23249>:
          D.23251 = &MEM[(void *)"gdb" + 3B];
          D.23252 = *D.23251;
          D.23253 = (int) D.23252;
          D.23254 = __s2 + 3;
          D.23255 = *D.23254;
          D.23256 = (int) D.23255;
          __result = D.23253 - D.23256;
          <D.23250>:
          <D.23248>:
          <D.23240>:
          <D.23238>:
          <D.23230>:
          <D.23228>:
        }
        D.23173 = __result;
      }
      iftmp.0 = -D.23173;
      goto <D.23257>;
      <D.23221>:
      iftmp.0 = __builtin_strcmp (arg, "gdb");
      <D.23257>:
      D.23174 = iftmp.0;
    }
    if (D.23174 == 0) goto <D.23258>; else goto <D.23259>;
    <D.23258>:
    use_gdb_interface = 1;
    <D.23259>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = arg;
        D.23263 = "save-symfiles";
        D.23264 = MEM[(const unsigned char *)D.23263];
        D.23265 = (int) D.23264;
        D.23266 = *__s2;
        D.23267 = (int) D.23266;
        __result = D.23265 - D.23267;
        {
          if (__s2_len != 0) goto <D.23268>; else goto <D.23269>;
          <D.23268>:
          if (__result == 0) goto <D.23270>; else goto <D.23271>;
          <D.23270>:
          D.23272 = &MEM[(void *)"save-symfiles" + 1B];
          D.23273 = *D.23272;
          D.23274 = (int) D.23273;
          D.23275 = __s2 + 1;
          D.23276 = *D.23275;
          D.23277 = (int) D.23276;
          __result = D.23274 - D.23277;
          if (__s2_len > 1) goto <D.23278>; else goto <D.23279>;
          <D.23278>:
          if (__result == 0) goto <D.23280>; else goto <D.23281>;
          <D.23280>:
          D.23282 = &MEM[(void *)"save-symfiles" + 2B];
          D.23283 = *D.23282;
          D.23284 = (int) D.23283;
          D.23285 = __s2 + 2;
          D.23286 = *D.23285;
          D.23287 = (int) D.23286;
          __result = D.23284 - D.23287;
          if (__s2_len > 2) goto <D.23288>; else goto <D.23289>;
          <D.23288>:
          if (__result == 0) goto <D.23290>; else goto <D.23291>;
          <D.23290>:
          D.23292 = &MEM[(void *)"save-symfiles" + 3B];
          D.23293 = *D.23292;
          D.23294 = (int) D.23293;
          D.23295 = __s2 + 3;
          D.23296 = *D.23295;
          D.23297 = (int) D.23296;
          __result = D.23294 - D.23297;
          <D.23291>:
          <D.23289>:
          <D.23281>:
          <D.23279>:
          <D.23271>:
          <D.23269>:
        }
        D.23182 = __result;
      }
      iftmp.1 = -D.23182;
      goto <D.23298>;
      <D.23262>:
      iftmp.1 = __builtin_strcmp (arg, "save-symfiles");
      <D.23298>:
      D.23183 = iftmp.1;
    }
    if (D.23183 == 0) goto <D.23299>; else goto <D.23300>;
    <D.23299>:
    save_symfiles = 1;
    <D.23300>:
  }
  ptr = ptr + 8;
  <D.23185>:
  if (ptr != 0B) goto <D.23301>; else goto <D.23186>;
  <D.23301>:
  D.23302 = *ptr;
  if (D.23302 != 0B) goto <D.23184>; else goto <D.23186>;
  <D.23186>:
  il_file.2 = fopen ("xdb.il", "w");
  il_file = il_file.2;
  il_file.3 = il_file;
  if (il_file.3 == 0B) goto <D.23305>; else goto <D.23306>;
  <D.23305>:
  use_gdb_interface = 0;
  monoeg_g_log (0B, 16, "** Unable to create xdb.il. Managed symbol names won\'t be available.");
  return;
  <D.23306>:
  use_gdb_interface.4 = use_gdb_interface;
  if (use_gdb_interface.4 != 0) goto <D.23308>; else goto <D.23309>;
  <D.23308>:
  return;
  <D.23309>:
  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.23314 = mono_unwind_get_cie_program ();
  mono_dwarf_writer_emit_base_info (xdebug_writer.8, "JITted code", D.23314);
}


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.23317>; else goto <D.23318>;
  <D.23317>:
  xdebug_w.9 = xdebug_w;
  xdebug_writer.10 = xdebug_writer;
  xdebug_end_emit (xdebug_w.9, xdebug_writer.10, 0B);
  <D.23318>:
  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.23326;
  long unsigned int D.23327;
  struct jit_code_entry * D.23328;
  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.23321>; else goto <D.23322>;
      <D.23321>:
      {
        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.23326 = (long unsigned int) img_size.14;
        fwrite (img, D.23326, 1, fp);
        fclose (fp);
        monoeg_g_free (file_name);
      }
      <D.23322>:
      entry = monoeg_malloc0 (32);
      entry->symfile_addr = img;
      psize = &entry->symfile_size1;
      img_size.14 = img_size;
      D.23327 = (long unsigned int) img_size.14;
      *psize = D.23327;
      D.23328 = __jit_debug_descriptor.first_entry;
      entry->next_entry = D.23328;
      D.23328 = __jit_debug_descriptor.first_entry;
      if (D.23328 != 0B) goto <D.23329>; else goto <D.23330>;
      <D.23329>:
      D.23328 = __jit_debug_descriptor.first_entry;
      D.23328->prev_entry = entry;
      <D.23330>:
      __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.23336;
  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.23332>; else goto <D.23333>;
  <D.23332>:
  il_file.16 = fopen ("xdb.il", "w");
  il_file = il_file.16;
  <D.23333>:
  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.23336 = mono_unwind_get_cie_program ();
  mono_dwarf_writer_emit_base_info (dw, "JITted code", D.23336);
  *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.23345;
  int xdebug_method_count.22;
  struct MonoJitInfo * D.23349;
  struct MonoMethod * D.23350;
  struct MonoDomain * D.23351;
  struct MonoDwarfWriter * xdebug_writer.23;
  struct MonoMethod * D.23353;
  void * D.23354;
  int D.23355;
  unsigned int D.23356;
  struct MonoInst * * D.23357;
  struct MonoInst * * D.23358;
  struct GSList * D.23359;
  struct MonoMethod * D.23363;
  struct MonoDomain * D.23364;
  struct MonoMethod * D.23365;
  struct FILE * xdebug_fp.24;
  struct MonoDebugMethodJitInfo * dmji;

  use_gdb_interface.18 = use_gdb_interface;
  if (use_gdb_interface.18 != 0) goto <D.23338>; else goto <D.23339>;
  <D.23338>:
  mono_loader_lock ();
  xdebug_syms.19 = xdebug_syms;
  if (xdebug_syms.19 == 0B) goto <D.23341>; else goto <D.23342>;
  <D.23341>:
  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.23342>:
  xdebug_method_count.21 = xdebug_method_count;
  D.23345 = xdebug_method_count.21 % 100;
  if (D.23345 == 0) goto <D.23346>; else goto <D.23347>;
  <D.23346>:
  mono_xdebug_flush ();
  <D.23347>:
  xdebug_method_count.21 = xdebug_method_count;
  xdebug_method_count.22 = xdebug_method_count.21 + 1;
  xdebug_method_count = xdebug_method_count.22;
  D.23349 = cfg->jit_info;
  D.23350 = jinfo_get_method (D.23349);
  D.23351 = mono_domain_get ();
  dmji = mono_debug_find_method (D.23350, D.23351);
  xdebug_writer.23 = xdebug_writer;
  D.23349 = cfg->jit_info;
  D.23353 = jinfo_get_method (D.23349);
  D.23349 = cfg->jit_info;
  D.23354 = D.23349->code_start;
  D.23349 = cfg->jit_info;
  D.23355 = D.23349->code_size;
  D.23356 = (unsigned int) D.23355;
  D.23357 = cfg->args;
  D.23358 = cfg->locals;
  D.23359 = cfg->unwind_ops;
  mono_dwarf_writer_emit_method (xdebug_writer.23, cfg, D.23353, 0B, 0B, D.23354, D.23356, D.23357, D.23358, D.23359, dmji);
  mono_debug_free_method_jit_info (dmji);
  mono_loader_unlock ();
  goto <D.23360>;
  <D.23339>:
  xdebug_writer.23 = xdebug_writer;
  if (xdebug_writer.23 == 0B) goto <D.23361>; else goto <D.23362>;
  <D.23361>:
  return;
  <D.23362>:
  mono_loader_lock ();
  D.23349 = cfg->jit_info;
  D.23363 = jinfo_get_method (D.23349);
  D.23364 = mono_domain_get ();
  dmji = mono_debug_find_method (D.23363, D.23364);
  xdebug_writer.23 = xdebug_writer;
  D.23349 = cfg->jit_info;
  D.23365 = jinfo_get_method (D.23349);
  D.23349 = cfg->jit_info;
  D.23354 = D.23349->code_start;
  D.23349 = cfg->jit_info;
  D.23355 = D.23349->code_size;
  D.23356 = (unsigned int) D.23355;
  D.23357 = cfg->args;
  D.23358 = cfg->locals;
  D.23359 = cfg->unwind_ops;
  mono_dwarf_writer_emit_method (xdebug_writer.23, cfg, D.23365, 0B, 0B, D.23354, D.23356, D.23357, D.23358, D.23359, dmji);
  mono_debug_free_method_jit_info (dmji);
  xdebug_fp.24 = xdebug_fp;
  fflush (xdebug_fp.24);
  mono_loader_unlock ();
  <D.23360>:
}


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

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


mono_save_trampoline_xdebug_info (struct MonoTrampInfo * info)
{
  int use_gdb_interface.25;
  struct MonoDwarfWriter * dw.26;
  char * D.23374;
  guint8 * D.23375;
  unsigned int D.23376;
  struct GSList * D.23377;
  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.23371>; else goto <D.23372>;
  <D.23371>:
  {
    struct MonoImageWriter * w;
    struct MonoDwarfWriter * dw;

    try
      {
        mono_loader_lock_if_inited ();
        xdebug_begin_emit (&w, &dw);
        dw.26 = dw;
        D.23374 = info->name;
        D.23375 = info->code;
        D.23376 = info->code_size;
        D.23377 = info->unwind_ops;
        mono_dwarf_writer_emit_trampoline (dw.26, D.23374, 0B, 0B, D.23375, D.23376, D.23377);
        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.23379>;
  <D.23372>:
  xdebug_writer.28 = xdebug_writer;
  if (xdebug_writer.28 == 0B) goto <D.23381>; else goto <D.23382>;
  <D.23381>:
  return;
  <D.23382>:
  mono_loader_lock_if_inited ();
  xdebug_writer.28 = xdebug_writer;
  D.23374 = info->name;
  D.23375 = info->code;
  D.23376 = info->code_size;
  D.23377 = info->unwind_ops;
  mono_dwarf_writer_emit_trampoline (xdebug_writer.28, D.23374, 0B, 0B, D.23375, D.23376, D.23377);
  xdebug_fp.29 = xdebug_fp;
  fflush (xdebug_fp.29);
  mono_loader_unlock_if_inited ();
  <D.23379>:
}