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


__attribute__((visibility ("hidden")))
mono_xdebug_init (const char * options)
{
  int D.23027;
  int D.23030;
  char * D.23034;
  struct FILE * D.23035;
  struct FILE * il_file.0;
  int use_gdb_interface.1;
  struct FILE * D.23042;
  struct FILE * xdebug_fp.2;
  struct MonoDwarfWriter * D.23044;
  struct MonoDwarfWriter * xdebug_writer.3;
  struct GSList * D.23046;
  struct MonoImageWriter * w;
  char * * args;
  char * * ptr;

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

    arg = *ptr;
    D.23027 = strcmp (arg, "gdb");
    if (D.23027 == 0) goto <D.23028>; else goto <D.23029>;
    <D.23028>:
    use_gdb_interface = 1;
    <D.23029>:
    D.23030 = strcmp (arg, "save-symfiles");
    if (D.23030 == 0) goto <D.23031>; else goto <D.23032>;
    <D.23031>:
    save_symfiles = 1;
    <D.23032>:
  }
  ptr = ptr + 8;
  <D.22993>:
  if (ptr != 0B) goto <D.23033>; else goto <D.22994>;
  <D.23033>:
  D.23034 = *ptr;
  if (D.23034 != 0B) goto <D.22992>; else goto <D.22994>;
  <D.22994>:
  D.23035 = fopen ("xdb.il", "w");
  il_file = D.23035;
  il_file.0 = il_file;
  if (il_file.0 == 0B) goto <D.23037>; else goto <D.23038>;
  <D.23037>:
  use_gdb_interface = 0;
  monoeg_g_log (0B, 16, "** Unable to create xdb.il. Managed symbol names won\'t be available.");
  return;
  <D.23038>:
  use_gdb_interface.1 = use_gdb_interface;
  if (use_gdb_interface.1 != 0) goto <D.23040>; else goto <D.23041>;
  <D.23040>:
  return;
  <D.23041>:
  unlink ("xdb.s");
  D.23042 = fopen ("xdb.s", "w");
  xdebug_fp = D.23042;
  xdebug_fp.2 = xdebug_fp;
  w = img_writer_create (xdebug_fp.2, 0);
  img_writer_emit_start (w);
  il_file.0 = il_file;
  D.23044 = mono_dwarf_writer_create (w, il_file.0, 0, 1, 1);
  xdebug_writer = D.23044;
  img_writer_emit_section_change (w, ".text", 0);
  img_writer_emit_string (w, "");
  xdebug_writer.3 = xdebug_writer;
  D.23046 = mono_unwind_get_cie_program ();
  mono_dwarf_writer_emit_base_info (xdebug_writer.3, "JITted code", D.23046);
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.4;
  int iftmp.5;
  int D.23056;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.23049>; else goto <D.23050>;
  <D.23049>:
  if (__ret == 1) goto <D.23052>; else goto <D.23053>;
  <D.23052>:
  iftmp.5 = -1;
  goto <D.23054>;
  <D.23053>:
  iftmp.5 = 1;
  <D.23054>:
  iftmp.4 = iftmp.5;
  goto <D.23055>;
  <D.23050>:
  iftmp.4 = 0;
  <D.23055>:
  __ret = iftmp.4;
  D.23056 = __ret;
  return D.23056;
}


mono_xdebug_flush ()
{
  struct MonoImageWriter * xdebug_w.6;
  struct MonoDwarfWriter * xdebug_writer.7;

  xdebug_w.6 = xdebug_w;
  if (xdebug_w.6 != 0B) goto <D.23059>; else goto <D.23060>;
  <D.23059>:
  xdebug_w.6 = xdebug_w;
  xdebug_writer.7 = xdebug_writer;
  xdebug_end_emit (xdebug_w.6, xdebug_writer.7, 0B);
  <D.23060>:
  xdebug_begin_emit (&xdebug_w, &xdebug_writer);
}


xdebug_end_emit (struct MonoImageWriter * w, struct MonoDwarfWriter * dw, struct MonoMethod * method)
{
  int D.23062;
  int file_counter.8;
  int file_counter.9;
  unsigned int img_size.10;
  long unsigned int D.23068;
  long unsigned int D.23069;
  struct jit_code_entry * D.23070;
  guint8 * img;
  guint32 img_size;
  struct jit_code_entry * entry;
  guint64 * psize;

  try
    {
      D.23062 = mono_dwarf_writer_get_il_file_line_index (dw);
      il_file_line_index = D.23062;
      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.23063>; else goto <D.23064>;
      <D.23063>:
      {
        struct FILE * fp;
        char * file_name;
        static int file_counter;

        file_counter.8 = file_counter;
        file_counter.9 = file_counter.8 + 1;
        file_counter = file_counter.9;
        file_counter.8 = file_counter;
        file_name = monoeg_g_strdup_printf ("xdb-%d.o", file_counter.8);
        img_size.10 = img_size;
        printf ("%s %p %d\n", file_name, img, img_size.10);
        fp = fopen (file_name, "w");
        img_size.10 = img_size;
        D.23068 = (long unsigned int) img_size.10;
        fwrite (img, D.23068, 1, fp);
        fclose (fp);
        monoeg_g_free (file_name);
      }
      <D.23064>:
      entry = monoeg_malloc0 (32);
      entry->symfile_addr = img;
      psize = &entry->symfile_size1;
      img_size.10 = img_size;
      D.23069 = (long unsigned int) img_size.10;
      *psize = D.23069;
      D.23070 = __jit_debug_descriptor.first_entry;
      entry->next_entry = D.23070;
      D.23070 = __jit_debug_descriptor.first_entry;
      if (D.23070 != 0B) goto <D.23071>; else goto <D.23072>;
      <D.23071>:
      D.23070 = __jit_debug_descriptor.first_entry;
      D.23070->prev_entry = entry;
      <D.23072>:
      __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.11;
  struct FILE * D.23076;
  int il_file_line_index.12;
  struct GSList * D.23078;
  struct MonoImageWriter * w;
  struct MonoDwarfWriter * dw;

  w = img_writer_create (0B, 1);
  img_writer_emit_start (w);
  il_file.11 = il_file;
  if (il_file.11 == 0B) goto <D.23074>; else goto <D.23075>;
  <D.23074>:
  D.23076 = fopen ("xdb.il", "w");
  il_file = D.23076;
  <D.23075>:
  il_file.11 = il_file;
  il_file_line_index.12 = il_file_line_index;
  dw = mono_dwarf_writer_create (w, il_file.11, il_file_line_index.12, 0, 1);
  D.23078 = mono_unwind_get_cie_program ();
  mono_dwarf_writer_emit_base_info (dw, "JITted code", D.23078);
  *out_w = w;
  *out_dw = dw;
}


__attribute__((visibility ("hidden")))
mono_save_xdebug_info (struct MonoCompile * cfg)
{
  int use_gdb_interface.13;
  struct GHashTable * xdebug_syms.14;
  struct GHashTable * D.23085;
  int xdebug_method_count.15;
  int D.23087;
  int D.23090;
  struct MonoJitInfo * D.23091;
  struct MonoMethod * D.23092;
  struct MonoDomain * D.23093;
  struct MonoDwarfWriter * xdebug_writer.16;
  struct MonoMethod * D.23095;
  void * D.23096;
  int D.23097;
  unsigned int D.23098;
  struct MonoInst * * D.23099;
  struct MonoInst * * D.23100;
  struct GSList * D.23101;
  struct MonoMethod * D.23105;
  struct MonoDomain * D.23106;
  struct MonoMethod * D.23107;
  struct FILE * xdebug_fp.17;
  struct MonoDebugMethodJitInfo * dmji;

  use_gdb_interface.13 = use_gdb_interface;
  if (use_gdb_interface.13 != 0) goto <D.23080>; else goto <D.23081>;
  <D.23080>:
  mono_loader_lock ();
  xdebug_syms.14 = xdebug_syms;
  if (xdebug_syms.14 == 0B) goto <D.23083>; else goto <D.23084>;
  <D.23083>:
  D.23085 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  xdebug_syms = D.23085;
  <D.23084>:
  xdebug_method_count.15 = xdebug_method_count;
  D.23087 = xdebug_method_count.15 % 100;
  if (D.23087 == 0) goto <D.23088>; else goto <D.23089>;
  <D.23088>:
  mono_xdebug_flush ();
  <D.23089>:
  xdebug_method_count.15 = xdebug_method_count;
  D.23090 = xdebug_method_count.15 + 1;
  xdebug_method_count = D.23090;
  D.23091 = cfg->jit_info;
  D.23092 = jinfo_get_method (D.23091);
  D.23093 = mono_domain_get ();
  dmji = mono_debug_find_method (D.23092, D.23093);
  xdebug_writer.16 = xdebug_writer;
  D.23091 = cfg->jit_info;
  D.23095 = jinfo_get_method (D.23091);
  D.23091 = cfg->jit_info;
  D.23096 = D.23091->code_start;
  D.23091 = cfg->jit_info;
  D.23097 = D.23091->code_size;
  D.23098 = (unsigned int) D.23097;
  D.23099 = cfg->args;
  D.23100 = cfg->locals;
  D.23101 = cfg->unwind_ops;
  mono_dwarf_writer_emit_method (xdebug_writer.16, cfg, D.23095, 0B, 0B, D.23096, D.23098, D.23099, D.23100, D.23101, dmji);
  mono_debug_free_method_jit_info (dmji);
  mono_loader_unlock ();
  goto <D.23102>;
  <D.23081>:
  xdebug_writer.16 = xdebug_writer;
  if (xdebug_writer.16 == 0B) goto <D.23103>; else goto <D.23104>;
  <D.23103>:
  return;
  <D.23104>:
  mono_loader_lock ();
  D.23091 = cfg->jit_info;
  D.23105 = jinfo_get_method (D.23091);
  D.23106 = mono_domain_get ();
  dmji = mono_debug_find_method (D.23105, D.23106);
  xdebug_writer.16 = xdebug_writer;
  D.23091 = cfg->jit_info;
  D.23107 = jinfo_get_method (D.23091);
  D.23091 = cfg->jit_info;
  D.23096 = D.23091->code_start;
  D.23091 = cfg->jit_info;
  D.23097 = D.23091->code_size;
  D.23098 = (unsigned int) D.23097;
  D.23099 = cfg->args;
  D.23100 = cfg->locals;
  D.23101 = cfg->unwind_ops;
  mono_dwarf_writer_emit_method (xdebug_writer.16, cfg, D.23107, 0B, 0B, D.23096, D.23098, D.23099, D.23100, D.23101, dmji);
  mono_debug_free_method_jit_info (dmji);
  xdebug_fp.17 = xdebug_fp;
  fflush (xdebug_fp.17);
  mono_loader_unlock ();
  <D.23102>:
}


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

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


__attribute__((visibility ("hidden")))
mono_save_trampoline_xdebug_info (struct MonoTrampInfo * info)
{
  int use_gdb_interface.18;
  struct MonoDwarfWriter * dw.19;
  char * D.23116;
  guint8 * D.23117;
  unsigned int D.23118;
  struct GSList * D.23119;
  struct MonoImageWriter * w.20;
  struct MonoDwarfWriter * xdebug_writer.21;
  struct FILE * xdebug_fp.22;

  use_gdb_interface.18 = use_gdb_interface;
  if (use_gdb_interface.18 != 0) goto <D.23113>; else goto <D.23114>;
  <D.23113>:
  {
    struct MonoImageWriter * w;
    struct MonoDwarfWriter * dw;

    try
      {
        mono_loader_lock_if_inited ();
        xdebug_begin_emit (&w, &dw);
        dw.19 = dw;
        D.23116 = info->name;
        D.23117 = info->code;
        D.23118 = info->code_size;
        D.23119 = info->unwind_ops;
        mono_dwarf_writer_emit_trampoline (dw.19, D.23116, 0B, 0B, D.23117, D.23118, D.23119);
        w.20 = w;
        dw.19 = dw;
        xdebug_end_emit (w.20, dw.19, 0B);
        mono_loader_unlock_if_inited ();
      }
    finally
      {
        w = {CLOBBER};
        dw = {CLOBBER};
      }
  }
  goto <D.23121>;
  <D.23114>:
  xdebug_writer.21 = xdebug_writer;
  if (xdebug_writer.21 == 0B) goto <D.23123>; else goto <D.23124>;
  <D.23123>:
  return;
  <D.23124>:
  mono_loader_lock_if_inited ();
  xdebug_writer.21 = xdebug_writer;
  D.23116 = info->name;
  D.23117 = info->code;
  D.23118 = info->code_size;
  D.23119 = info->unwind_ops;
  mono_dwarf_writer_emit_trampoline (xdebug_writer.21, D.23116, 0B, 0B, D.23117, D.23118, D.23119);
  xdebug_fp.22 = xdebug_fp;
  fflush (xdebug_fp.22);
  mono_loader_unlock_if_inited ();
  <D.23121>:
}