mono_dwarf_writer_create (struct MonoImageWriter * writer, struct FILE * il_file, int il_file_start_line, gboolean appending, gboolean emit_line_numbers)
{
  struct MonoImageWriter * D.22766;
  int D.22767;
  _Bool D.22768;
  long int D.22769;
  long int D.22770;
  int D.22775;
  struct FILE * D.22781;
  const char * D.22782;
  struct GHashTable * D.22783;
  struct GHashTable * D.22784;
  struct GHashTable * D.22785;
  struct GHashTable * D.22786;
  struct MonoDwarfWriter * D.22787;
  struct MonoDwarfWriter * w;

  w = monoeg_malloc0 (92);
  w->w = writer;
  w->il_file = il_file;
  w->il_file_line_index = il_file_start_line;
  w->appending = appending;
  if (appending != 0) goto <D.22764>; else goto <D.22765>;
  <D.22764>:
  D.22766 = w->w;
  D.22767 = img_writer_subsections_supported (D.22766);
  D.22768 = D.22767 == 0;
  D.22769 = (long int) D.22768;
  D.22770 = __builtin_expect (D.22769, 0);
  if (D.22770 != 0) goto <D.22771>; else goto <D.22772>;
  <D.22771>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 94, "img_writer_subsections_supported (w->w)");
  <D.22772>:
  <D.22765>:
  w->emit_line = 1;
  if (appending != 0) goto <D.22773>; else goto <D.22774>;
  <D.22773>:
  D.22766 = w->w;
  D.22775 = img_writer_subsections_supported (D.22766);
  if (D.22775 == 0) goto <D.22776>; else goto <D.22777>;
  <D.22776>:
  w->emit_line = 0;
  <D.22777>:
  goto <D.22778>;
  <D.22774>:
  w->collect_line_info = 1;
  <D.22778>:
  if (emit_line_numbers == 0) goto <D.22779>; else goto <D.22780>;
  <D.22779>:
  w->emit_line = 0;
  w->collect_line_info = 0;
  <D.22780>:
  D.22766 = w->w;
  D.22781 = img_writer_get_fp (D.22766);
  w->fp = D.22781;
  D.22766 = w->w;
  D.22782 = img_writer_get_temp_label_prefix (D.22766);
  w->temp_prefix = D.22782;
  D.22783 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_die = D.22783;
  D.22784 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_vtype_die = D.22784;
  D.22785 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_pointer_die = D.22785;
  D.22786 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_reference_die = D.22786;
  w->cur_file_index = -1;
  D.22787 = w;
  return D.22787;
}


mono_dwarf_writer_destroy (struct MonoDwarfWriter * w)
{
  monoeg_g_free (w);
}


mono_dwarf_writer_get_il_file_line_index (struct MonoDwarfWriter * w)
{
  int D.22789;

  D.22789 = w->il_file_line_index;
  return D.22789;
}


mono_dwarf_escape_path (const char * name)
{
  char * D.22791;
  unsigned int D.22794;
  int D.22795;
  int D.22796;
  unsigned int D.22797;
  sizetype i.0;
  const char * D.22799;
  char D.22800;
  int j.1;
  sizetype j.2;
  char * D.22805;
  int j.3;
  sizetype j.4;
  char * D.22808;
  int j.5;
  sizetype j.6;
  char * D.22812;
  char * D.22813;

  D.22791 = __builtin_strchr (name, 92);
  if (D.22791 != 0B) goto <D.22792>; else goto <D.22793>;
  <D.22792>:
  {
    char * s;
    int len;
    int i;
    int j;

    D.22794 = strlen (name);
    len = (int) D.22794;
    D.22795 = len + 1;
    D.22796 = D.22795 * 2;
    D.22797 = (unsigned int) D.22796;
    s = monoeg_malloc0 (D.22797);
    j = 0;
    i = 0;
    goto <D.22367>;
    <D.22366>:
    i.0 = (sizetype) i;
    D.22799 = name + i.0;
    D.22800 = *D.22799;
    if (D.22800 == 92) goto <D.22801>; else goto <D.22802>;
    <D.22801>:
    j.1 = j;
    j = j.1 + 1;
    j.2 = (sizetype) j.1;
    D.22805 = s + j.2;
    *D.22805 = 92;
    j.3 = j;
    j = j.3 + 1;
    j.4 = (sizetype) j.3;
    D.22808 = s + j.4;
    *D.22808 = 92;
    goto <D.22809>;
    <D.22802>:
    j.5 = j;
    j = j.5 + 1;
    j.6 = (sizetype) j.5;
    D.22812 = s + j.6;
    i.0 = (sizetype) i;
    D.22799 = name + i.0;
    D.22800 = *D.22799;
    *D.22812 = D.22800;
    <D.22809>:
    i = i + 1;
    <D.22367>:
    if (i < len) goto <D.22366>; else goto <D.22368>;
    <D.22368>:
    D.22813 = s;
    return D.22813;
  }
  <D.22793>:
  D.22813 = monoeg_strdup (name);
  return D.22813;
}


monoeg_strdup (const gchar * str)
{
  gchar * D.22817;

  if (str != 0B) goto <D.22815>; else goto <D.22816>;
  <D.22815>:
  D.22817 = __strdup (str);
  return D.22817;
  <D.22816>:
  D.22817 = 0B;
  return D.22817;
}


mono_dwarf_writer_emit_base_info (struct MonoDwarfWriter * w, const char * cu_name, struct GSList * base_unwind_program)
{
  struct MonoImageWriter * D.22819;
  int D.22820;
  int D.22823;
  int D.22826;
  const char * D.22830;
  int D.22831;
  unsigned char D.22832;
  int D.22833;
  int D.22834;
  unsigned char D.22835;
  int D.22836;
  const char * D.22837;
  unsigned int i.7;
  char * s;
  char * build_info;
  int i;

  w->cie_program = base_unwind_program;
  emit_section_change (w, ".debug_abbrev", 0);
  emit_dwarf_abbrev (w, 1, 17, 1, &compile_unit_attr, 14);
  emit_dwarf_abbrev (w, 2, 46, 1, &subprogram_attr, 10);
  emit_dwarf_abbrev (w, 3, 5, 0, &param_attr, 6);
  emit_dwarf_abbrev (w, 15, 5, 0, &param_loclist_attr, 6);
  emit_dwarf_abbrev (w, 4, 36, 0, &base_type_attr, 6);
  emit_dwarf_abbrev (w, 5, 2, 1, &struct_type_attr, 4);
  emit_dwarf_abbrev (w, 17, 2, 0, &struct_type_attr, 4);
  emit_dwarf_abbrev (w, 6, 13, 0, &data_member_attr, 6);
  emit_dwarf_abbrev (w, 7, 22, 0, &typedef_attr, 4);
  emit_dwarf_abbrev (w, 8, 4, 1, &enum_type_attr, 6);
  emit_dwarf_abbrev (w, 9, 40, 0, &enumerator_attr, 4);
  emit_dwarf_abbrev (w, 10, 57, 1, &namespace_attr, 2);
  emit_dwarf_abbrev (w, 11, 52, 0, &variable_attr, 6);
  emit_dwarf_abbrev (w, 12, 52, 0, &variable_loclist_attr, 6);
  emit_dwarf_abbrev (w, 13, 15, 0, &pointer_type_attr, 2);
  emit_dwarf_abbrev (w, 14, 16, 0, &reference_type_attr, 2);
  emit_dwarf_abbrev (w, 16, 28, 0, &inheritance_attr, 4);
  emit_dwarf_abbrev (w, 18, 46, 0, &tramp_subprogram_attr, 6);
  emit_byte (w, 0);
  emit_section_change (w, ".debug_info", 0);
  emit_label (w, ".Ldebug_info_start");
  emit_symbol_diff (w, ".Ldebug_info_end", ".Ldebug_info_begin", 0);
  emit_label (w, ".Ldebug_info_begin");
  emit_int16 (w, 2);
  emit_int32 (w, 0);
  emit_byte (w, 4);
  D.22819 = w->w;
  D.22820 = img_writer_subsections_supported (D.22819);
  if (D.22820 != 0) goto <D.22821>; else goto <D.22822>;
  <D.22821>:
  D.22823 = w->appending;
  if (D.22823 != 0) goto <D.22824>; else goto <D.22825>;
  <D.22824>:
  emit_section_change (w, ".debug_info", 1);
  emit_byte (w, 0);
  emit_label (w, ".Ldebug_info_end");
  emit_section_change (w, ".debug_info", 0);
  <D.22825>:
  <D.22822>:
  emit_uleb128 (w, 1);
  build_info = mono_get_runtime_build_info ();
  s = monoeg_g_strdup_printf ("Mono AOT Compiler %s", build_info);
  emit_string (w, s);
  monoeg_g_free (build_info);
  monoeg_g_free (s);
  emit_string (w, cu_name);
  emit_string (w, "");
  emit_byte (w, 2);
  emit_pointer_value (w, 0B);
  emit_pointer_value (w, 0B);
  D.22826 = w->emit_line;
  if (D.22826 != 0) goto <D.22827>; else goto <D.22828>;
  <D.22827>:
  emit_symbol_diff (w, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
  goto <D.22829>;
  <D.22828>:
  emit_pointer_value (w, 0B);
  <D.22829>:
  i = 0;
  goto <D.22424>;
  <D.22423>:
  D.22830 = basic_types[i].die_name;
  emit_label (w, D.22830);
  emit_uleb128 (w, 4);
  D.22831 = basic_types[i].size;
  D.22832 = (unsigned char) D.22831;
  D.22833 = (int) D.22832;
  emit_byte (w, D.22833);
  D.22834 = basic_types[i].encoding;
  D.22835 = (unsigned char) D.22834;
  D.22836 = (int) D.22835;
  emit_byte (w, D.22836);
  D.22837 = basic_types[i].name;
  emit_string (w, D.22837);
  i = i + 1;
  <D.22424>:
  i.7 = (unsigned int) i;
  if (i.7 <= 16) goto <D.22423>; else goto <D.22425>;
  <D.22425>:
  emit_debug_info_end (w);
  emit_section_change (w, ".debug_loc", 0);
  emit_label (w, ".Ldebug_loc_start");
  emit_cie (w);
}


emit_dwarf_abbrev (struct MonoDwarfWriter * w, int code, int tag, gboolean has_child, int * attrs, int attrs_len)
{
  unsigned int code.8;
  unsigned int tag.9;
  unsigned char D.22841;
  int D.22842;
  unsigned int i.10;
  unsigned int D.22844;
  int * D.22845;
  int D.22846;
  unsigned int D.22847;
  int i;

  code.8 = (unsigned int) code;
  emit_uleb128 (w, code.8);
  tag.9 = (unsigned int) tag;
  emit_uleb128 (w, tag.9);
  D.22841 = (unsigned char) has_child;
  D.22842 = (int) D.22841;
  emit_byte (w, D.22842);
  i = 0;
  goto <D.22280>;
  <D.22279>:
  i.10 = (unsigned int) i;
  D.22844 = i.10 * 4;
  D.22845 = attrs + D.22844;
  D.22846 = *D.22845;
  D.22847 = (unsigned int) D.22846;
  emit_uleb128 (w, D.22847);
  i = i + 1;
  <D.22280>:
  if (i < attrs_len) goto <D.22279>; else goto <D.22281>;
  <D.22281>:
  emit_uleb128 (w, 0);
  emit_uleb128 (w, 0);
}


emit_int16 (struct MonoDwarfWriter * w, int value)
{
  struct MonoImageWriter * D.22848;

  D.22848 = w->w;
  img_writer_emit_int16 (D.22848, value);
}


emit_int32 (struct MonoDwarfWriter * w, int value)
{
  struct MonoImageWriter * D.22849;

  D.22849 = w->w;
  img_writer_emit_int32 (D.22849, value);
}


emit_symbol_diff (struct MonoDwarfWriter * w, const char * end, const char * start, int offset)
{
  struct MonoImageWriter * D.22850;

  D.22850 = w->w;
  img_writer_emit_symbol_diff (D.22850, end, start, offset);
}


emit_pointer_value (struct MonoDwarfWriter * w, void * ptr)
{
  int ptr.11;
  gssize val;

  try
    {
      ptr.11 = (int) ptr;
      val = ptr.11;
      emit_bytes (w, &val, 4);
    }
  finally
    {
      val = {CLOBBER};
    }
}


emit_bytes (struct MonoDwarfWriter * w, const guint8 * buf, int size)
{
  struct MonoImageWriter * D.22852;

  D.22852 = w->w;
  img_writer_emit_bytes (D.22852, buf, size);
}


emit_uleb128 (struct MonoDwarfWriter * w, guint32 value)
{
  unsigned char D.22853;
  int D.22856;

  <D.22235>:
  {
    guint8 b;

    D.22853 = (unsigned char) value;
    b = D.22853 & 127;
    value = value >> 7;
    if (value != 0) goto <D.22854>; else goto <D.22855>;
    <D.22854>:
    b = b | 128;
    <D.22855>:
    D.22856 = (int) b;
    emit_byte (w, D.22856);
  }
  if (value != 0) goto <D.22235>; else goto <D.22236>;
  <D.22236>:
}


emit_byte (struct MonoDwarfWriter * w, guint8 val)
{
  struct MonoImageWriter * D.22857;
  int D.22858;

  D.22857 = w->w;
  D.22858 = (int) val;
  img_writer_emit_byte (D.22857, D.22858);
}


emit_string (struct MonoDwarfWriter * w, const char * value)
{
  struct MonoImageWriter * D.22859;

  D.22859 = w->w;
  img_writer_emit_string (D.22859, value);
}


emit_debug_info_end (struct MonoDwarfWriter * w)
{

}


emit_section_change (struct MonoDwarfWriter * w, const char * section_name, int subsection_index)
{
  struct MonoImageWriter * D.22860;

  D.22860 = w->w;
  img_writer_emit_section_change (D.22860, section_name, subsection_index);
}


emit_label (struct MonoDwarfWriter * w, const char * name)
{
  struct MonoImageWriter * D.22861;

  D.22861 = w->w;
  img_writer_emit_label (D.22861, name);
}


emit_cie (struct MonoDwarfWriter * w)
{
  int D.22862;
  long long int D.22863;
  int D.22864;
  unsigned int D.22865;
  struct GSList * D.22866;
  unsigned int uw_info_len.12;
  int uw_info_len.13;

  emit_section_change (w, ".debug_frame", 0);
  emit_alignment (w, 8);
  emit_symbol_diff (w, ".Lcie0_end", ".Lcie0_start", 0);
  emit_label (w, ".Lcie0_start");
  emit_int32 (w, -1);
  emit_byte (w, 3);
  emit_string (w, "");
  emit_sleb128 (w, 1);
  D.22862 = mono_unwind_get_dwarf_data_align ();
  D.22863 = (long long int) D.22862;
  emit_sleb128 (w, D.22863);
  D.22864 = mono_unwind_get_dwarf_pc_reg ();
  D.22865 = (unsigned int) D.22864;
  emit_uleb128 (w, D.22865);
  D.22866 = w->cie_program;
  w->cie_program = D.22866;
  D.22866 = w->cie_program;
  if (D.22866 != 0B) goto <D.22867>; else goto <D.22868>;
  <D.22867>:
  {
    guint32 uw_info_len;
    guint8 * uw_info;

    try
      {
        D.22866 = w->cie_program;
        uw_info = mono_unwind_ops_encode (D.22866, &uw_info_len);
        uw_info_len.12 = uw_info_len;
        uw_info_len.13 = (int) uw_info_len.12;
        emit_bytes (w, uw_info, uw_info_len.13);
        monoeg_g_free (uw_info);
      }
    finally
      {
        uw_info_len = {CLOBBER};
      }
  }
  <D.22868>:
  emit_alignment (w, 4);
  emit_label (w, ".Lcie0_end");
}


emit_sleb128 (struct MonoDwarfWriter * w, gint64 value)
{
  _Bool D.22871;
  unsigned char D.22872;
  unsigned int D.22875;
  int D.22876;
  long long int D.22877;
  long long int D.22878;
  int D.22884;
  int D.22885;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;

  more = 1;
  D.22871 = value < 0;
  negative = (gboolean) D.22871;
  size = 64;
  goto <D.22246>;
  <D.22245>:
  D.22872 = (unsigned char) value;
  byte = D.22872 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.22873>; else goto <D.22874>;
  <D.22873>:
  D.22875 = size + 4294967289;
  D.22876 = (int) D.22875;
  D.22877 = 1 << D.22876;
  D.22878 = -D.22877;
  value = D.22878 | value;
  <D.22874>:
  if (value == 0) goto <D.22883>; else goto <D.22879>;
  <D.22883>:
  D.22884 = (int) byte;
  D.22885 = D.22884 & 64;
  if (D.22885 == 0) goto <D.22880>; else goto <D.22879>;
  <D.22879>:
  if (value == -1) goto <D.22886>; else goto <D.22881>;
  <D.22886>:
  D.22884 = (int) byte;
  D.22885 = D.22884 & 64;
  if (D.22885 != 0) goto <D.22880>; else goto <D.22881>;
  <D.22880>:
  more = 0;
  goto <D.22882>;
  <D.22881>:
  byte = byte | 128;
  <D.22882>:
  D.22884 = (int) byte;
  emit_byte (w, D.22884);
  <D.22246>:
  if (more != 0) goto <D.22245>; else goto <D.22247>;
  <D.22247>:
}


emit_alignment (struct MonoDwarfWriter * w, int size)
{
  struct MonoImageWriter * D.22887;

  D.22887 = w->w;
  img_writer_emit_alignment (D.22887, size);
}


mono_dwarf_writer_close (struct MonoDwarfWriter * w)
{
  int D.22888;
  int D.22891;

  D.22888 = w->appending;
  if (D.22888 == 0) goto <D.22889>; else goto <D.22890>;
  <D.22889>:
  emit_section_change (w, ".debug_info", 0);
  emit_byte (w, 0);
  emit_label (w, ".Ldebug_info_end");
  <D.22890>:
  D.22891 = w->collect_line_info;
  if (D.22891 != 0) goto <D.22892>; else goto <D.22893>;
  <D.22892>:
  emit_all_line_number_info (w);
  <D.22893>:
}


emit_all_line_number_info (struct MonoDwarfWriter * w)
{
  int D.22894;
  _Bool D.22895;
  long int D.22896;
  long int D.22897;
  struct GSList * D.22900;
  struct MonoMethod * D.22901;
  struct GPtrArray * source_file_list.14;
  void * * D.22905;
  unsigned int i.15;
  unsigned int D.22907;
  void * * D.22908;
  char * D.22909;
  unsigned int i.16;
  unsigned int D.22911;
  struct GHashTable * D.22912;
  int D.22913;
  const void * D.22914;
  int D.22915;
  void * D.22918;
  int D.22921;
  int D.22922;
  int D.22923;
  void * D.22924;
  int D.22926;
  char * D.22927;
  int D.22928;
  void * D.22931;
  char * D.22935;
  unsigned int dir_index.17;
  struct MonoMethod * D.22937;
  struct MonoDomain * D.22938;
  char * D.22939;
  char * D.22940;
  guint8 * D.22941;
  unsigned int D.22942;
  int i;
  struct GHashTable * dir_to_index;
  struct GHashTable * index_to_dir;
  struct GSList * l;
  struct GSList * info_list;

  D.22894 = w->collect_line_info;
  D.22895 = D.22894 == 0;
  D.22896 = (long int) D.22895;
  D.22897 = __builtin_expect (D.22896, 0);
  if (D.22897 != 0) goto <D.22898>; else goto <D.22899>;
  <D.22898>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 709, "w->collect_line_info");
  <D.22899>:
  add_line_number_file_name (w, "<unknown>", 0, 0);
  D.22900 = w->line_info;
  info_list = monoeg_g_slist_reverse (D.22900);
  l = info_list;
  goto <D.22387>;
  <D.22386>:
  {
    struct MethodLineNumberInfo * info;
    struct MonoDebugMethodInfo * minfo;
    char * source_file;
    struct GPtrArray * source_file_list;

    try
      {
        info = l->data;
        D.22901 = info->method;
        minfo = mono_debug_lookup_method (D.22901);
        if (minfo == 0B) goto <D.22902>; else goto <D.22903>;
        <D.22902>:
        // predicted unlikely by continue predictor.
        goto <D.22381>;
        <D.22903>:
        mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B);
        i = 0;
        goto <D.22384>;
        <D.22383>:
        {
          struct MonoDebugSourceInfo * sinfo;

          source_file_list.14 = source_file_list;
          D.22905 = source_file_list.14->pdata;
          i.15 = (unsigned int) i;
          D.22907 = i.15 * 4;
          D.22908 = D.22905 + D.22907;
          sinfo = *D.22908;
          D.22909 = sinfo->source_file;
          add_line_number_file_name (w, D.22909, 0, 0);
        }
        i = i + 1;
        <D.22384>:
        i.16 = (unsigned int) i;
        source_file_list.14 = source_file_list;
        D.22911 = source_file_list.14->len;
        if (i.16 < D.22911) goto <D.22383>; else goto <D.22385>;
        <D.22385>:
      }
    finally
      {
        source_file = {CLOBBER};
        source_file_list = {CLOBBER};
      }
  }
  <D.22381>:
  l = l->next;
  <D.22387>:
  if (l != 0B) goto <D.22386>; else goto <D.22388>;
  <D.22388>:
  dir_to_index = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  index_to_dir = monoeg_g_hash_table_new (0B, 0B);
  i = 0;
  goto <D.22394>;
  <D.22393>:
  {
    char * name;
    char * copy;
    int dir_index;

    D.22912 = w->index_to_file;
    D.22913 = i + 1;
    D.22914 = (const void *) D.22913;
    name = monoeg_g_hash_table_lookup (D.22912, D.22914);
    dir_index = 0;
    D.22915 = monoeg_g_path_is_absolute (name);
    if (D.22915 != 0) goto <D.22916>; else goto <D.22917>;
    <D.22916>:
    {
      char * dir;

      dir = monoeg_g_path_get_dirname (name);
      D.22918 = monoeg_g_hash_table_lookup (dir_to_index, dir);
      dir_index = (int) D.22918;
      if (dir_index == 0) goto <D.22919>; else goto <D.22920>;
      <D.22919>:
      dir_index = w->line_number_dir_index;
      D.22921 = w->line_number_dir_index;
      D.22922 = D.22921 + 1;
      w->line_number_dir_index = D.22922;
      copy = monoeg_strdup (dir);
      D.22923 = dir_index + 1;
      D.22924 = (void *) D.22923;
      monoeg_g_hash_table_insert_replace (dir_to_index, copy, D.22924, 0);
      D.22923 = dir_index + 1;
      D.22924 = (void *) D.22923;
      monoeg_g_hash_table_insert_replace (index_to_dir, D.22924, copy, 0);
      goto <D.22925>;
      <D.22920>:
      dir_index = dir_index + -1;
      <D.22925>:
      monoeg_g_free (dir);
    }
    <D.22917>:
  }
  i = i + 1;
  <D.22394>:
  D.22926 = w->line_number_file_index;
  if (D.22926 > i) goto <D.22393>; else goto <D.22395>;
  <D.22395>:
  emit_section_change (w, ".debug_line", 0);
  emit_label (w, ".Ldebug_line_section_start");
  emit_label (w, ".Ldebug_line_start");
  emit_symbol_diff (w, ".Ldebug_line_end", ".", -4);
  emit_int16 (w, 2);
  emit_symbol_diff (w, ".Ldebug_line_header_end", ".", -4);
  emit_byte (w, 1);
  emit_byte (w, 1);
  emit_byte (w, 251);
  emit_byte (w, 14);
  emit_byte (w, 13);
  emit_byte (w, 0);
  emit_byte (w, 1);
  emit_byte (w, 1);
  emit_byte (w, 1);
  emit_byte (w, 1);
  emit_byte (w, 0);
  emit_byte (w, 0);
  emit_byte (w, 0);
  emit_byte (w, 1);
  emit_byte (w, 0);
  emit_byte (w, 0);
  emit_byte (w, 1);
  emit_section_change (w, ".debug_line", 0);
  i = 0;
  goto <D.22398>;
  <D.22397>:
  {
    char * dir;

    D.22913 = i + 1;
    D.22914 = (const void *) D.22913;
    dir = monoeg_g_hash_table_lookup (index_to_dir, D.22914);
    D.22927 = mono_dwarf_escape_path (dir);
    emit_string (w, D.22927);
  }
  i = i + 1;
  <D.22398>:
  D.22921 = w->line_number_dir_index;
  if (D.22921 > i) goto <D.22397>; else goto <D.22399>;
  <D.22399>:
  emit_byte (w, 0);
  i = 0;
  goto <D.22405>;
  <D.22404>:
  {
    char * name;
    char * basename;
    char * dir;
    int dir_index;

    D.22912 = w->index_to_file;
    D.22913 = i + 1;
    D.22914 = (const void *) D.22913;
    name = monoeg_g_hash_table_lookup (D.22912, D.22914);
    basename = 0B;
    dir_index = 0;
    D.22928 = monoeg_g_path_is_absolute (name);
    if (D.22928 != 0) goto <D.22929>; else goto <D.22930>;
    <D.22929>:
    dir = monoeg_g_path_get_dirname (name);
    D.22931 = monoeg_g_hash_table_lookup (dir_to_index, dir);
    dir_index = (int) D.22931;
    basename = monoeg_g_path_get_basename (name);
    <D.22930>:
    if (basename != 0B) goto <D.22932>; else goto <D.22933>;
    <D.22932>:
    emit_string (w, basename);
    goto <D.22934>;
    <D.22933>:
    D.22935 = mono_dwarf_escape_path (name);
    emit_string (w, D.22935);
    <D.22934>:
    dir_index.17 = (unsigned int) dir_index;
    emit_uleb128 (w, dir_index.17);
    emit_byte (w, 0);
    emit_byte (w, 0);
  }
  i = i + 1;
  <D.22405>:
  D.22926 = w->line_number_file_index;
  if (D.22926 > i) goto <D.22404>; else goto <D.22406>;
  <D.22406>:
  emit_byte (w, 0);
  emit_label (w, ".Ldebug_line_header_end");
  l = info_list;
  goto <D.22410>;
  <D.22409>:
  {
    struct MethodLineNumberInfo * info;
    struct MonoDebugMethodJitInfo * dmji;

    info = l->data;
    D.22937 = info->method;
    D.22938 = mono_domain_get ();
    dmji = mono_debug_find_method (D.22937, D.22938);
    D.22937 = info->method;
    D.22939 = info->start_symbol;
    D.22940 = info->end_symbol;
    D.22941 = info->code;
    D.22942 = info->code_size;
    emit_line_number_info (w, D.22937, D.22939, D.22940, D.22941, D.22942, dmji);
    mono_debug_free_method_jit_info (dmji);
  }
  l = l->next;
  <D.22410>:
  if (l != 0B) goto <D.22409>; else goto <D.22411>;
  <D.22411>:
  monoeg_g_slist_free (info_list);
  emit_byte (w, 0);
  emit_byte (w, 1);
  emit_byte (w, 1);
  emit_label (w, ".Ldebug_line_end");
}


add_line_number_file_name (struct MonoDwarfWriter * w, const char * name, gint64 last_mod_time, gint64 file_size)
{
  struct GHashTable * D.22945;
  struct GHashTable * D.22948;
  struct GHashTable * D.22949;
  void * D.22950;
  int D.22953;
  int D.22954;
  int D.22955;
  int D.22956;
  void * D.22957;
  struct GHashTable * D.22958;
  int index;
  char * copy;

  D.22945 = w->file_to_index;
  if (D.22945 == 0B) goto <D.22946>; else goto <D.22947>;
  <D.22946>:
  D.22948 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  w->file_to_index = D.22948;
  D.22949 = monoeg_g_hash_table_new (0B, 0B);
  w->index_to_file = D.22949;
  <D.22947>:
  D.22945 = w->file_to_index;
  D.22950 = monoeg_g_hash_table_lookup (D.22945, name);
  index = (int) D.22950;
  if (index > 0) goto <D.22951>; else goto <D.22952>;
  <D.22951>:
  D.22953 = index + -1;
  return D.22953;
  <D.22952>:
  index = w->line_number_file_index;
  D.22954 = w->line_number_file_index;
  D.22955 = D.22954 + 1;
  w->line_number_file_index = D.22955;
  copy = monoeg_strdup (name);
  D.22945 = w->file_to_index;
  D.22956 = index + 1;
  D.22957 = (void *) D.22956;
  monoeg_g_hash_table_insert_replace (D.22945, copy, D.22957, 0);
  D.22958 = w->index_to_file;
  D.22956 = index + 1;
  D.22957 = (void *) D.22956;
  monoeg_g_hash_table_insert_replace (D.22958, D.22957, copy, 0);
  D.22953 = index;
  return D.22953;
}


emit_line_number_info (struct MonoDwarfWriter * w, struct MonoMethod * method, char * start_symbol, char * end_symbol, guint8 * code, guint32 code_size, struct MonoDebugMethodJitInfo * debug_info)
{
  int D.22960;
  _Bool D.22963;
  long int D.22964;
  long int D.22965;
  unsigned int D.22968;
  unsigned int D.22969;
  struct MonoDebugLineNumberEntry * D.22970;
  unsigned int D.22971;
  unsigned int D.22972;
  unsigned int D.22973;
  unsigned int i.18;
  unsigned int D.22975;
  unsigned int j.19;
  unsigned int D.22979;
  int * D.22980;
  unsigned int j.20;
  unsigned int D.22982;
  unsigned int i.21;
  unsigned int D.22984;
  sizetype i.22;
  sizetype D.22988;
  sizetype D.22989;
  unsigned int D.22990;
  int D.22991;
  unsigned int D.22992;
  unsigned int j.23;
  unsigned int D.23001;
  int * D.23002;
  unsigned int i.24;
  unsigned int il_offset.25;
  char * D.23013;
  unsigned int D.23014;
  int D.23015;
  int prev_line.26;
  unsigned int D.23017;
  int D.23023;
  long long int D.23024;
  int D.22676;
  int D.23030;
  int D.23033;
  int D.23035;
  unsigned int file_index.27;
  unsigned int D.23041;
  long long int D.23042;
  const unsigned char * ip.28;
  struct FILE * D.23047;
  int D.23048;
  int D.23049;
  unsigned int D.23050;
  unsigned int D.23051;
  const guint8 * ip.29;
  int ip.30;
  int ip.31;
  unsigned int il_offset.32;
  unsigned int D.23056;
  int * D.23057;
  const unsigned char * D.23058;
  unsigned int D.23059;
  unsigned int D.23062;
  int * D.23063;
  int D.23068;
  unsigned int D.23069;
  int D.23070;
  int D.23071;
  unsigned int prev_native_offset.33;
  unsigned int D.23073;
  long long int D.23074;
  guint32 prev_line;
  guint32 prev_native_offset;
  int i;
  int file_index;
  int il_offset;
  int prev_il_offset;
  gboolean first;
  struct MonoDebugSourceLocation * loc;
  char * prev_file_name;
  struct MonoMethodHeader * header;
  struct MonoDebugMethodInfo * minfo;
  struct MonoDebugLineNumberEntry * ln_array;
  int * native_to_il_offset;

  prev_line = 0;
  prev_native_offset = 0;
  first = 1;
  prev_file_name = 0B;
  header = mono_method_get_header (method);
  native_to_il_offset = 0B;
  D.22960 = w->emit_line;
  if (D.22960 == 0) goto <D.22961>; else goto <D.22962>;
  <D.22961>:
  mono_metadata_free_mh (header);
  return;
  <D.22962>:
  minfo = mono_debug_lookup_method (method);
  D.22963 = code_size == 0;
  D.22964 = (long int) D.22963;
  D.22965 = __builtin_expect (D.22964, 0);
  if (D.22965 != 0) goto <D.22966>; else goto <D.22967>;
  <D.22966>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1585, "code_size");
  <D.22967>:
  D.22968 = debug_info->num_line_numbers;
  D.22969 = D.22968 * 8;
  ln_array = monoeg_malloc0 (D.22969);
  D.22970 = debug_info->line_numbers;
  D.22968 = debug_info->num_line_numbers;
  D.22971 = D.22968 * 8;
  memcpy (ln_array, D.22970, D.22971);
  D.22968 = debug_info->num_line_numbers;
  qsort (ln_array, D.22968, 8, compare_lne);
  D.22972 = code_size + 1;
  D.22973 = D.22972 * 4;
  native_to_il_offset = monoeg_malloc0 (D.22973);
  i = 0;
  goto <D.22663>;
  <D.22662>:
  {
    int j;
    struct MonoDebugLineNumberEntry * lne;

    i.18 = (unsigned int) i;
    D.22975 = i.18 * 8;
    lne = ln_array + D.22975;
    if (i == 0) goto <D.22976>; else goto <D.22977>;
    <D.22976>:
    j = 0;
    goto <D.22653>;
    <D.22652>:
    j.19 = (unsigned int) j;
    D.22979 = j.19 * 4;
    D.22980 = native_to_il_offset + D.22979;
    *D.22980 = -1;
    j = j + 1;
    <D.22653>:
    j.20 = (unsigned int) j;
    D.22982 = lne->native_offset;
    if (j.20 < D.22982) goto <D.22652>; else goto <D.22654>;
    <D.22654>:
    <D.22977>:
    i.21 = (unsigned int) i;
    D.22968 = debug_info->num_line_numbers;
    D.22984 = D.22968 + 4294967295;
    if (i.21 < D.22984) goto <D.22985>; else goto <D.22986>;
    <D.22985>:
    {
      struct MonoDebugLineNumberEntry * lne_next;

      i.22 = (sizetype) i;
      D.22988 = i.22 + 1;
      D.22989 = D.22988 * 8;
      lne_next = ln_array + D.22989;
      D.22982 = lne->native_offset;
      j = (int) D.22982;
      goto <D.22657>;
      <D.22656>:
      j.19 = (unsigned int) j;
      D.22979 = j.19 * 4;
      D.22980 = native_to_il_offset + D.22979;
      D.22990 = lne->il_offset;
      D.22991 = (int) D.22990;
      *D.22980 = D.22991;
      j = j + 1;
      <D.22657>:
      j.20 = (unsigned int) j;
      D.22992 = lne_next->native_offset;
      if (j.20 < D.22992) goto <D.22656>; else goto <D.22658>;
      <D.22658>:
    }
    goto <D.22993>;
    <D.22986>:
    D.22982 = lne->native_offset;
    j = (int) D.22982;
    goto <D.22660>;
    <D.22659>:
    j.19 = (unsigned int) j;
    D.22979 = j.19 * 4;
    D.22980 = native_to_il_offset + D.22979;
    D.22990 = lne->il_offset;
    D.22991 = (int) D.22990;
    *D.22980 = D.22991;
    j = j + 1;
    <D.22660>:
    j.23 = (unsigned int) j;
    if (j.23 < code_size) goto <D.22659>; else goto <D.22661>;
    <D.22661>:
    <D.22993>:
  }
  i = i + 1;
  <D.22663>:
  i.21 = (unsigned int) i;
  D.22968 = debug_info->num_line_numbers;
  if (i.21 < D.22968) goto <D.22662>; else goto <D.22664>;
  <D.22664>:
  monoeg_g_free (ln_array);
  prev_line = 1;
  prev_il_offset = -1;
  i = 0;
  goto <D.22678>;
  <D.22677>:
  {
    int line_diff;
    int addr_diff;

    if (minfo == 0B) goto <D.22995>; else goto <D.22996>;
    <D.22995>:
    // predicted unlikely by continue predictor.
    goto <D.22667>;
    <D.22996>:
    D.22970 = debug_info->line_numbers;
    if (D.22970 == 0B) goto <D.22997>; else goto <D.22998>;
    <D.22997>:
    // predicted unlikely by continue predictor.
    goto <D.22667>;
    <D.22998>:
    if (native_to_il_offset != 0B) goto <D.22999>; else goto <D.23000>;
    <D.22999>:
    i.18 = (unsigned int) i;
    D.23001 = i.18 * 4;
    D.23002 = native_to_il_offset + D.23001;
    il_offset = *D.23002;
    goto <D.23003>;
    <D.23000>:
    i.24 = (unsigned int) i;
    il_offset = il_offset_from_address (method, debug_info, i.24);
    <D.23003>:
    i.18 = (unsigned int) i;
    D.23001 = i.18 * 4;
    D.23002 = native_to_il_offset + D.23001;
    il_offset = *D.23002;
    if (il_offset < 0) goto <D.23005>; else goto <D.23006>;
    <D.23005>:
    // predicted unlikely by continue predictor.
    goto <D.22667>;
    <D.23006>:
    if (il_offset == prev_il_offset) goto <D.23007>; else goto <D.23008>;
    <D.23007>:
    // predicted unlikely by continue predictor.
    goto <D.22667>;
    <D.23008>:
    prev_il_offset = il_offset;
    il_offset.25 = (unsigned int) il_offset;
    loc = mono_debug_symfile_lookup_location (minfo, il_offset.25);
    if (loc == 0B) goto <D.23010>; else goto <D.23012>;
    <D.23012>:
    D.23013 = loc->source_file;
    if (D.23013 == 0B) goto <D.23010>; else goto <D.23011>;
    <D.23010>:
    // predicted unlikely by continue predictor.
    goto <D.22667>;
    <D.23011>:
    D.23014 = loc->row;
    D.23015 = (int) D.23014;
    prev_line.26 = (int) prev_line;
    line_diff = D.23015 - prev_line.26;
    i.24 = (unsigned int) i;
    D.23017 = i.24 - prev_native_offset;
    addr_diff = (int) D.23017;
    if (first != 0) goto <D.23018>; else goto <D.23019>;
    <D.23018>:
    emit_section_change (w, ".debug_line", 4);
    emit_byte (w, 0);
    emit_byte (w, 5);
    emit_byte (w, 2);
    if (start_symbol != 0B) goto <D.23020>; else goto <D.23021>;
    <D.23020>:
    emit_pointer_unaligned (w, start_symbol);
    goto <D.23022>;
    <D.23021>:
    emit_pointer_value (w, code);
    <D.23022>:
    emit_byte (w, 3);
    D.23014 = loc->row;
    D.23015 = (int) D.23014;
    prev_line.26 = (int) prev_line;
    D.23023 = D.23015 - prev_line.26;
    D.23024 = (long long int) D.23023;
    emit_sleb128 (w, D.23024);
    prev_line = loc->row;
    prev_native_offset = (guint32) i;
    first = 0;
    <D.23019>:
    D.23014 = loc->row;
    if (D.23014 != prev_line) goto <D.23025>; else goto <D.23026>;
    <D.23025>:
    if (prev_file_name == 0B) goto <D.23027>; else goto <D.23029>;
    <D.23029>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.23013 = loc->source_file;
      D.22676 = __builtin_strcmp (D.23013, prev_file_name);
    }
    if (D.22676 != 0) goto <D.23027>; else goto <D.23028>;
    <D.23027>:
    D.23030 = w->collect_line_info;
    if (D.23030 != 0) goto <D.23031>; else goto <D.23032>;
    <D.23031>:
    D.23013 = loc->source_file;
    D.23033 = get_line_number_file_name (w, D.23013);
    file_index = D.23033 + 1;
    goto <D.23034>;
    <D.23032>:
    D.23013 = loc->source_file;
    file_index = emit_line_number_file_name (w, D.23013, 0, 0);
    <D.23034>:
    monoeg_g_free (prev_file_name);
    D.23013 = loc->source_file;
    prev_file_name = monoeg_strdup (D.23013);
    D.23035 = w->cur_file_index;
    if (D.23035 != file_index) goto <D.23036>; else goto <D.23037>;
    <D.23036>:
    emit_byte (w, 4);
    file_index.27 = (unsigned int) file_index;
    emit_uleb128 (w, file_index.27);
    emit_byte (w, 1);
    w->cur_file_index = file_index;
    <D.23037>:
    <D.23028>:
    emit_advance_op (w, line_diff, addr_diff);
    prev_line = loc->row;
    prev_native_offset = (guint32) i;
    <D.23026>:
    mono_debug_symfile_free_location (loc);
  }
  <D.22667>:
  i = i + 1;
  <D.22678>:
  i.24 = (unsigned int) i;
  if (i.24 < code_size) goto <D.22677>; else goto <D.22679>;
  <D.22679>:
  monoeg_g_free (native_to_il_offset);
  monoeg_g_free (prev_file_name);
  if (first == 0) goto <D.23039>; else goto <D.23040>;
  <D.23039>:
  emit_byte (w, 2);
  D.23041 = code_size - prev_native_offset;
  D.23042 = (long long int) D.23041;
  emit_sleb128 (w, D.23042);
  emit_byte (w, 1);
  emit_byte (w, 0);
  emit_byte (w, 1);
  emit_byte (w, 1);
  goto <D.23043>;
  <D.23040>:
  if (start_symbol == 0B) goto <D.23044>; else goto <D.23045>;
  <D.23044>:
  {
    char * name;
    char * dis;
    const guint8 * ip;
    int prev_line;
    int prev_native_offset;
    int * il_to_line;

    try
      {
        ip.28 = header->code;
        ip = ip.28;
        name = mono_method_full_name (method, 1);
        D.23047 = w->il_file;
        fprintf (D.23047, "// %s\n", name);
        D.23048 = w->il_file_line_index;
        D.23049 = D.23048 + 1;
        w->il_file_line_index = D.23049;
        monoeg_g_free (name);
        D.23050 = header->code_size;
        D.23051 = D.23050 * 4;
        il_to_line = monoeg_malloc0 (D.23051);
        emit_section_change (w, ".debug_line", 4);
        emit_byte (w, 0);
        emit_byte (w, 5);
        emit_byte (w, 2);
        emit_pointer_value (w, code);
        goto <D.22688>;
        <D.22687>:
        {
          int il_offset;

          ip.29 = ip;
          ip.30 = (int) ip.29;
          ip.28 = header->code;
          ip.31 = (int) ip.28;
          il_offset = ip.30 - ip.31;
          D.23048 = w->il_file_line_index;
          D.23049 = D.23048 + 1;
          w->il_file_line_index = D.23049;
          ip.29 = ip;
          dis = disasm_ins (method, ip.29, &ip);
          D.23047 = w->il_file;
          fprintf (D.23047, "%s\n", dis);
          monoeg_g_free (dis);
          il_offset.32 = (unsigned int) il_offset;
          D.23056 = il_offset.32 * 4;
          D.23057 = il_to_line + D.23056;
          D.23048 = w->il_file_line_index;
          *D.23057 = D.23048;
        }
        <D.22688>:
        ip.28 = header->code;
        D.23050 = header->code_size;
        D.23058 = ip.28 + D.23050;
        ip.29 = ip;
        if (D.23058 > ip.29) goto <D.22687>; else goto <D.22689>;
        <D.22689>:
        prev_line = 1;
        prev_native_offset = 0;
        i = 0;
        goto <D.22694>;
        <D.22693>:
        {
          struct MonoDebugLineNumberEntry * lne;
          int line;

          D.22970 = debug_info->line_numbers;
          i.18 = (unsigned int) i;
          D.22975 = i.18 * 8;
          lne = D.22970 + D.22975;
          D.23059 = lne->il_offset;
          D.23050 = header->code_size;
          if (D.23059 >= D.23050) goto <D.23060>; else goto <D.23061>;
          <D.23060>:
          // predicted unlikely by continue predictor.
          goto <D.22692>;
          <D.23061>:
          D.23059 = lne->il_offset;
          D.23062 = D.23059 * 4;
          D.23063 = il_to_line + D.23062;
          line = *D.23063;
          if (line == 0) goto <D.23064>; else goto <D.23065>;
          <D.23064>:
          // predicted unlikely by continue predictor.
          goto <D.22692>;
          <D.23065>:
          if (line != prev_line) goto <D.23066>; else goto <D.23067>;
          <D.23066>:
          D.23068 = line - prev_line;
          D.23069 = lne->native_offset;
          D.23070 = (int) D.23069;
          D.23071 = D.23070 - prev_native_offset;
          emit_advance_op (w, D.23068, D.23071);
          prev_line = line;
          D.23069 = lne->native_offset;
          prev_native_offset = (int) D.23069;
          <D.23067>:
        }
        <D.22692>:
        i = i + 1;
        <D.22694>:
        i.21 = (unsigned int) i;
        D.22968 = debug_info->num_line_numbers;
        if (i.21 < D.22968) goto <D.22693>; else goto <D.22695>;
        <D.22695>:
        emit_byte (w, 2);
        prev_native_offset.33 = (unsigned int) prev_native_offset;
        D.23073 = code_size - prev_native_offset.33;
        D.23074 = (long long int) D.23073;
        emit_sleb128 (w, D.23074);
        emit_byte (w, 1);
        emit_byte (w, 0);
        emit_byte (w, 1);
        emit_byte (w, 1);
        D.23047 = w->il_file;
        fflush (D.23047);
        monoeg_g_free (il_to_line);
      }
    finally
      {
        ip = {CLOBBER};
      }
  }
  <D.23045>:
  <D.23043>:
  mono_metadata_free_mh (header);
}


compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b)
{
  unsigned int D.23076;
  unsigned int D.23077;
  gint D.23080;
  unsigned int D.23081;
  unsigned int D.23082;
  unsigned int D.23083;
  unsigned int D.23084;

  D.23076 = a->native_offset;
  D.23077 = b->native_offset;
  if (D.23076 == D.23077) goto <D.23078>; else goto <D.23079>;
  <D.23078>:
  D.23081 = a->il_offset;
  D.23082 = b->il_offset;
  D.23083 = D.23081 - D.23082;
  D.23080 = (gint) D.23083;
  return D.23080;
  <D.23079>:
  D.23076 = a->native_offset;
  D.23077 = b->native_offset;
  D.23084 = D.23076 - D.23077;
  D.23080 = (gint) D.23084;
  return D.23080;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.23086;
  unsigned int D.23087;

  D.23087 = __builtin_object_size (__dest, 0);
  D.23086 = __builtin___memcpy_chk (__dest, __src, __len, D.23087);
  return D.23086;
}


il_offset_from_address (struct MonoMethod * method, struct MonoDebugMethodJitInfo * jit, guint32 native_offset)
{
  struct MonoDebugLineNumberEntry * D.23089;
  gint32 D.23092;
  unsigned int D.23093;
  unsigned int D.23094;
  unsigned int i.34;
  unsigned int D.23096;
  struct MonoDebugLineNumberEntry * D.23097;
  unsigned int D.23098;
  unsigned int D.23101;
  int i;

  D.23089 = jit->line_numbers;
  if (D.23089 == 0B) goto <D.23090>; else goto <D.23091>;
  <D.23090>:
  D.23092 = -1;
  return D.23092;
  <D.23091>:
  D.23093 = jit->num_line_numbers;
  D.23094 = D.23093 + 4294967295;
  i = (int) D.23094;
  goto <D.22615>;
  <D.22614>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.23089 = jit->line_numbers;
        i.34 = (unsigned int) i;
        D.23096 = i.34 * 8;
        D.23097 = D.23089 + D.23096;
        lne = *D.23097;
        D.23098 = lne.native_offset;
        if (D.23098 <= native_offset) goto <D.23099>; else goto <D.23100>;
        <D.23099>:
        D.23101 = lne.il_offset;
        D.23092 = (gint32) D.23101;
        return D.23092;
        <D.23100>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.22615>:
  if (i >= 0) goto <D.22614>; else goto <D.22616>;
  <D.22616>:
  D.23092 = -1;
  return D.23092;
}


emit_pointer_unaligned (struct MonoDwarfWriter * w, const char * target)
{
  struct MonoImageWriter * D.23105;

  D.23105 = w->w;
  img_writer_emit_pointer_unaligned (D.23105, target);
}


get_line_number_file_name (struct MonoDwarfWriter * w, const char * name)
{
  struct GHashTable * D.23106;
  _Bool D.23107;
  long int D.23108;
  long int D.23109;
  void * D.23112;
  _Bool D.23113;
  long int D.23114;
  long int D.23115;
  int D.23118;
  int index;

  D.23106 = w->file_to_index;
  D.23107 = D.23106 == 0B;
  D.23108 = (long int) D.23107;
  D.23109 = __builtin_expect (D.23108, 0);
  if (D.23109 != 0) goto <D.23110>; else goto <D.23111>;
  <D.23110>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 648, "w->file_to_index");
  <D.23111>:
  D.23106 = w->file_to_index;
  D.23112 = monoeg_g_hash_table_lookup (D.23106, name);
  index = (int) D.23112;
  D.23113 = index <= 0;
  D.23114 = (long int) D.23113;
  D.23115 = __builtin_expect (D.23114, 0);
  if (D.23115 != 0) goto <D.23116>; else goto <D.23117>;
  <D.23116>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 650, "index > 0");
  <D.23117>:
  D.23118 = index + -1;
  return D.23118;
}


emit_line_number_file_name (struct MonoDwarfWriter * w, const char * name, gint64 last_mod_time, gint64 file_size)
{
  struct GHashTable * D.23120;
  struct GHashTable * D.23123;
  void * D.23124;
  int D.23127;
  int D.23128;
  struct GHashTable * D.23131;
  struct GHashTable * D.23134;
  void * D.23135;
  int D.23138;
  int D.23139;
  gchar * D.23140;
  void * dir_index.35;
  unsigned int dir_index.36;
  int D.23149;
  int D.23150;
  gchar * D.23151;
  void * index.37;
  int index;
  int dir_index;
  char * basename;

  basename = 0B;
  D.23120 = w->file_to_index;
  if (D.23120 == 0B) goto <D.23121>; else goto <D.23122>;
  <D.23121>:
  D.23123 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  w->file_to_index = D.23123;
  <D.23122>:
  D.23120 = w->file_to_index;
  D.23124 = monoeg_g_hash_table_lookup (D.23120, name);
  index = (int) D.23124;
  if (index > 0) goto <D.23125>; else goto <D.23126>;
  <D.23125>:
  D.23127 = index;
  return D.23127;
  <D.23126>:
  D.23128 = monoeg_g_path_is_absolute (name);
  if (D.23128 != 0) goto <D.23129>; else goto <D.23130>;
  <D.23129>:
  {
    char * dir;

    dir = monoeg_g_path_get_dirname (name);
    D.23131 = w->dir_to_index;
    if (D.23131 == 0B) goto <D.23132>; else goto <D.23133>;
    <D.23132>:
    D.23134 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
    w->dir_to_index = D.23134;
    <D.23133>:
    D.23131 = w->dir_to_index;
    D.23135 = monoeg_g_hash_table_lookup (D.23131, dir);
    dir_index = (int) D.23135;
    if (dir_index == 0) goto <D.23136>; else goto <D.23137>;
    <D.23136>:
    emit_section_change (w, ".debug_line", 2);
    emit_string (w, dir);
    D.23138 = w->line_number_dir_index;
    D.23139 = D.23138 + 1;
    w->line_number_dir_index = D.23139;
    dir_index = w->line_number_dir_index;
    D.23131 = w->dir_to_index;
    D.23140 = monoeg_strdup (dir);
    dir_index.35 = (void *) dir_index;
    monoeg_g_hash_table_insert_replace (D.23131, D.23140, dir_index.35, 0);
    <D.23137>:
    monoeg_g_free (dir);
    basename = monoeg_g_path_get_basename (name);
  }
  goto <D.23142>;
  <D.23130>:
  dir_index = 0;
  <D.23142>:
  emit_section_change (w, ".debug_line", 3);
  if (basename != 0B) goto <D.23143>; else goto <D.23144>;
  <D.23143>:
  emit_string (w, basename);
  goto <D.23145>;
  <D.23144>:
  emit_string (w, name);
  <D.23145>:
  dir_index.36 = (unsigned int) dir_index;
  emit_uleb128 (w, dir_index.36);
  emit_byte (w, 0);
  emit_byte (w, 0);
  emit_section_change (w, ".debug_line", 4);
  if (basename != 0B) goto <D.23147>; else goto <D.23148>;
  <D.23147>:
  monoeg_g_free (basename);
  <D.23148>:
  D.23149 = w->line_number_file_index;
  D.23150 = D.23149 + 1;
  w->line_number_file_index = D.23150;
  index = w->line_number_file_index;
  D.23120 = w->file_to_index;
  D.23151 = monoeg_strdup (name);
  index.37 = (void *) index;
  monoeg_g_hash_table_insert_replace (D.23120, D.23151, index.37, 0);
  D.23127 = index;
  return D.23127;
}


disasm_ins (struct MonoMethod * method, const guchar * ip, const guint8 * * endip)
{
  const guchar * ip.38;
  unsigned char D.23155;
  const guchar * D.23158;
  unsigned char D.23159;
  int D.23160;
  const unsigned char * D.23161;
  _Bool D.23162;
  long int D.23163;
  long int D.23164;
  int ip.39;
  const unsigned char * D.23168;
  int D.23169;
  int D.23170;
  const char * D.23171;
  const guchar * ip.40;
  const char * D.23173;
  char * D.23175;
  char * dis;
  struct MonoDisHelper dh;
  struct MonoMethodHeader * header;

  try
    {
      header = mono_method_get_header (method);
      memset (&dh, 0, 24);
      dh.newline = "";
      dh.label_format = "IL_%04x: ";
      dh.label_target = "IL_%04x";
      dh.tokener = token_handler;
      ip.38 = ip;
      token_handler_ip = ip.38;
      ip.38 = ip;
      D.23155 = *ip.38;
      if (D.23155 == 240) goto <D.23156>; else goto <D.23157>;
      <D.23156>:
      {
        guint32 token;
        void * data;

        ip.38 = ip;
        D.23158 = ip.38 + 1;
        D.23159 = *D.23158;
        D.23160 = (int) D.23159;
        switch (D.23160) <default: <D.22606>, case 0: <D.22602>, case 11: <D.22605>>
        <D.22602>:
        {
          struct MonoJitICallInfo * info;

          ip.38 = ip;
          D.23161 = ip.38 + 2;
          token = mono_read32 (D.23161);
          data = mono_method_get_wrapper_data (method, token);
          info = mono_find_jit_icall_by_addr (data);
          D.23162 = info == 0B;
          D.23163 = (long int) D.23162;
          D.23164 = __builtin_expect (D.23163, 0);
          if (D.23164 != 0) goto <D.23165>; else goto <D.23166>;
          <D.23165>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1470, "info");
          <D.23166>:
          ip.38 = ip;
          ip.39 = (int) ip.38;
          D.23168 = header->code;
          D.23169 = (int) D.23168;
          D.23170 = ip.39 - D.23169;
          D.23171 = info->name;
          dis = monoeg_g_strdup_printf ("IL_%04x: mono_icall <%s>", D.23170, D.23171);
          ip.38 = ip;
          ip.40 = ip.38 + 6;
          ip = ip.40;
          goto <D.22604>;
        }
        <D.22605>:
        ip.38 = ip;
        D.23161 = ip.38 + 2;
        token = mono_read32 (D.23161);
        data = mono_method_get_wrapper_data (method, token);
        ip.38 = ip;
        ip.39 = (int) ip.38;
        D.23168 = header->code;
        D.23169 = (int) D.23168;
        D.23170 = ip.39 - D.23169;
        D.23173 = MEM[(struct MonoClass *)data].name;
        dis = monoeg_g_strdup_printf ("IL_%04x: mono_classconst <%s>", D.23170, D.23173);
        ip.38 = ip;
        ip.40 = ip.38 + 6;
        ip = ip.40;
        goto <D.22604>;
        <D.22606>:
        ip.38 = ip;
        dis = mono_disasm_code_one (&dh, method, ip.38, &ip);
        <D.22604>:
      }
      goto <D.23174>;
      <D.23157>:
      ip.38 = ip;
      dis = mono_disasm_code_one (&dh, method, ip.38, &ip);
      <D.23174>:
      token_handler_ip = 0B;
      ip.38 = ip;
      *endip = ip.38;
      mono_metadata_free_mh (header);
      D.23175 = dis;
      return D.23175;
    }
  finally
    {
      dh = {CLOBBER};
    }
}


token_handler (struct MonoDisHelper * dh, struct MonoMethod * method, guint32 token)
{
  unsigned int D.23178;
  unsigned int D.23179;
  const guint8 * token_handler_ip.41;
  unsigned char D.23183;
  int D.23184;
  struct MonoClass * D.23188;
  struct MonoImage * D.23189;
  struct MonoClass * klass.42;
  struct MonoClass * klass.43;
  const char * D.23192;
  char * D.23202;
  char * res;
  char * desc;
  struct MonoMethod * cmethod;
  struct MonoClass * klass;
  struct MonoClassField * field;
  void * data;

  try
    {
      data = 0B;
      D.23178 = BIT_FIELD_REF <*method, 32, 160>;
      D.23179 = D.23178 & 124;
      if (D.23179 != 0) goto <D.23180>; else goto <D.23181>;
      <D.23180>:
      data = mono_method_get_wrapper_data (method, token);
      <D.23181>:
      token_handler_ip.41 = token_handler_ip;
      D.23183 = *token_handler_ip.41;
      D.23184 = (int) D.23183;
      switch (D.23184) <default: <D.22591>, case 40: <D.22584>, case 41: <D.22586>, case 111: <D.22585>, case 115: <D.22583>, case 116: <D.22580>, case 117: <D.22579>, case 123: <D.22587>, case 125: <D.22589>, case 126: <D.22588>, case 128: <D.22590>, case 143: <D.22581>>
      <D.22579>:
      <D.22580>:
      <D.22581>:
      D.23178 = BIT_FIELD_REF <*method, 32, 160>;
      D.23179 = D.23178 & 124;
      if (D.23179 != 0) goto <D.23185>; else goto <D.23186>;
      <D.23185>:
      klass = data;
      goto <D.23187>;
      <D.23186>:
      D.23188 = method->klass;
      D.23189 = D.23188->image;
      klass.42 = mono_class_get_full (D.23189, token, 0B);
      klass = klass.42;
      <D.23187>:
      klass.43 = klass;
      D.23192 = klass.43->name;
      res = monoeg_g_strdup_printf ("<%s>", D.23192);
      goto <D.22582>;
      <D.22583>:
      <D.22584>:
      <D.22585>:
      D.23178 = BIT_FIELD_REF <*method, 32, 160>;
      D.23179 = D.23178 & 124;
      if (D.23179 != 0) goto <D.23193>; else goto <D.23194>;
      <D.23193>:
      cmethod = data;
      goto <D.23195>;
      <D.23194>:
      D.23188 = method->klass;
      D.23189 = D.23188->image;
      cmethod = mono_get_method_full (D.23189, token, 0B, 0B);
      <D.23195>:
      desc = mono_method_full_name (cmethod, 1);
      res = monoeg_g_strdup_printf ("<%s>", desc);
      monoeg_g_free (desc);
      goto <D.22582>;
      <D.22586>:
      D.23178 = BIT_FIELD_REF <*method, 32, 160>;
      D.23179 = D.23178 & 124;
      if (D.23179 != 0) goto <D.23196>; else goto <D.23197>;
      <D.23196>:
      desc = mono_signature_get_desc (data, 0);
      res = monoeg_g_strdup_printf ("<%s>", desc);
      monoeg_g_free (desc);
      goto <D.23198>;
      <D.23197>:
      res = monoeg_g_strdup_printf ("<0x%08x>", token);
      <D.23198>:
      goto <D.22582>;
      <D.22587>:
      <D.22588>:
      <D.22589>:
      <D.22590>:
      D.23178 = BIT_FIELD_REF <*method, 32, 160>;
      D.23179 = D.23178 & 124;
      if (D.23179 != 0) goto <D.23199>; else goto <D.23200>;
      <D.23199>:
      field = data;
      goto <D.23201>;
      <D.23200>:
      D.23188 = method->klass;
      D.23189 = D.23188->image;
      field = mono_field_from_token (D.23189, token, &klass, 0B);
      <D.23201>:
      desc = mono_field_full_name (field);
      res = monoeg_g_strdup_printf ("<%s>", desc);
      monoeg_g_free (desc);
      goto <D.22582>;
      <D.22591>:
      res = monoeg_g_strdup_printf ("<0x%08x>", token);
      goto <D.22582>;
      <D.22582>:
      D.23202 = res;
      return D.23202;
    }
  finally
    {
      klass = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23207;
  int D.23212;
  void * D.23214;
  unsigned int D.23215;

  D.23207 = __builtin_constant_p (__len);
  if (D.23207 != 0) goto <D.23208>; else goto <D.23209>;
  <D.23208>:
  if (__len == 0) goto <D.23210>; else goto <D.23211>;
  <D.23210>:
  D.23212 = __builtin_constant_p (__ch);
  if (D.23212 == 0) goto <D.23205>; else goto <D.23213>;
  <D.23213>:
  if (__ch != 0) goto <D.23205>; else goto <D.23206>;
  <D.23205>:
  __warn_memset_zero_len ();
  D.23214 = __dest;
  return D.23214;
  <D.23206>:
  <D.23211>:
  <D.23209>:
  D.23215 = __builtin_object_size (__dest, 0);
  D.23214 = __builtin___memset_chk (__dest, __ch, __len, D.23215);
  return D.23214;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.23217;

  D.23217 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.23217;
}


emit_advance_op (struct MonoDwarfWriter * w, int line_diff, int addr_diff)
{
  unsigned int line_diff.44;
  unsigned int D.23220;
  int max_special_addr_diff.45;
  int D.23228;
  int D.23231;
  int D.23232;
  int D.23233;
  int D.23234;
  unsigned char D.23239;
  int D.23240;
  long long int D.23242;
  long long int D.23243;
  gint64 opcode;

  opcode = 0;
  line_diff.44 = (unsigned int) line_diff;
  D.23220 = line_diff.44 + 5;
  if (D.23220 <= 13) goto <D.23221>; else goto <D.23222>;
  <D.23221>:
  max_special_addr_diff.45 = max_special_addr_diff;
  if (max_special_addr_diff.45 == 0) goto <D.23224>; else goto <D.23225>;
  <D.23224>:
  max_special_addr_diff = 17;
  <D.23225>:
  max_special_addr_diff.45 = max_special_addr_diff;
  if (addr_diff > max_special_addr_diff.45) goto <D.23226>; else goto <D.23227>;
  <D.23226>:
  max_special_addr_diff.45 = max_special_addr_diff;
  D.23228 = max_special_addr_diff.45 * 2;
  if (D.23228 > addr_diff) goto <D.23229>; else goto <D.23230>;
  <D.23229>:
  emit_byte (w, 8);
  max_special_addr_diff.45 = max_special_addr_diff;
  addr_diff = addr_diff - max_special_addr_diff.45;
  <D.23230>:
  <D.23227>:
  D.23231 = line_diff + 5;
  D.23232 = addr_diff * 14;
  D.23233 = D.23231 + D.23232;
  D.23234 = D.23233 + 13;
  opcode = (gint64) D.23234;
  if (opcode > 255) goto <D.23235>; else goto <D.23236>;
  <D.23235>:
  opcode = 0;
  <D.23236>:
  <D.23222>:
  if (opcode != 0) goto <D.23237>; else goto <D.23238>;
  <D.23237>:
  D.23239 = (unsigned char) opcode;
  D.23240 = (int) D.23239;
  emit_byte (w, D.23240);
  goto <D.23241>;
  <D.23238>:
  emit_byte (w, 3);
  D.23242 = (long long int) line_diff;
  emit_sleb128 (w, D.23242);
  emit_byte (w, 2);
  D.23243 = (long long int) addr_diff;
  emit_sleb128 (w, D.23243);
  emit_byte (w, 1);
  <D.23241>:
}


mono_dwarf_writer_emit_method (struct MonoDwarfWriter * w, struct MonoCompile * cfg, struct MonoMethod * method, char * start_symbol, char * end_symbol, guint8 * code, guint32 code_size, struct MonoInst * * args, struct MonoInst * * locals, struct GSList * unwind_info, struct MonoDebugMethodJitInfo * debug_info)
{
  unsigned int D.23247;
  unsigned int D.23248;
  struct MonoClass * D.23250;
  unsigned int D.23251;
  unsigned int D.23252;
  <unnamed-unsigned:1> D.23256;
  int D.23257;
  int D.23258;
  short unsigned int D.23259;
  int D.23260;
  int D.23261;
  struct MonoType * D.23262;
  short unsigned int D.23263;
  int D.23264;
  unsigned int D.23265;
  unsigned int D.23266;
  void * D.23270;
  struct MonoInst * iftmp.46;
  unsigned int i.47;
  unsigned int D.23275;
  struct MonoInst * * D.23276;
  int D.23284;
  int D.23286;
  unsigned int D.23294;
  unsigned int D.23295;
  char * * D.23296;
  guint32 iftmp.48;
  char D.23301;
  unsigned char D.23308;
  int D.23309;
  int D.23310;
  struct MonoClass * D.23311;
  struct MonoType * D.23312;
  guint8 * p.49;
  int code_size.50;
  sizetype D.23319;
  guint8 * D.23320;
  sizetype D.23321;
  guint8 * D.23322;
  int p.51;
  int buf.52;
  int D.23325;
  unsigned int D.23326;
  unsigned char D.23328;
  int D.23329;
  struct MonoInst * * D.23330;
  int D.23335;
  guint32 iftmp.53;
  struct MonoDebugLocalVar * D.23344;
  unsigned int j.54;
  unsigned int D.23346;
  struct MonoDebugLocalVar * D.23347;
  int D.23348;
  int D.23350;
  unsigned char D.23360;
  int D.23361;
  int D.23362;
  int D.23365;
  sizetype D.23368;
  guint8 * D.23369;
  sizetype D.23370;
  guint8 * D.23371;
  int D.23377;
  int D.23378;
  const mono_byte * D.23381;
  int D.23384;
  gchar * D.23387;
  gchar * D.23388;
  struct GSList * D.23389;
  struct GSList * D.23390;
  char * name;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  char * * names;
  struct MonoDebugLocalsInfo * locals_info;
  int i;
  guint8 buf[128];
  guint8 * p;

  try
    {
      emit_section_change (w, ".debug_info", 0);
      sig = mono_method_signature (method);
      header = mono_method_get_header (method);
      i = 0;
      goto <D.22727>;
      <D.22726>:
      {
        struct MonoType * t;

        if (i == 0) goto <D.23246>; else goto <D.23244>;
        <D.23246>:
        D.23247 = BIT_FIELD_REF <*sig, 32, 64>;
        D.23248 = D.23247 & 4194304;
        if (D.23248 != 0) goto <D.23249>; else goto <D.23244>;
        <D.23249>:
        D.23250 = method->klass;
        D.23251 = BIT_FIELD_REF <*D.23250, 32, 160>;
        D.23252 = D.23251 & 8;
        if (D.23252 != 0) goto <D.23253>; else goto <D.23254>;
        <D.23253>:
        D.23250 = method->klass;
        t = &D.23250->this_arg;
        goto <D.23255>;
        <D.23254>:
        D.23250 = method->klass;
        t = &D.23250->byval_arg;
        <D.23255>:
        goto <D.23245>;
        <D.23244>:
        D.23256 = sig->hasthis;
        D.23257 = (int) D.23256;
        D.23258 = i - D.23257;
        t = sig->params[D.23258];
        <D.23245>:
        emit_type (w, t);
      }
      i = i + 1;
      <D.22727>:
      D.23259 = sig->param_count;
      D.23260 = (int) D.23259;
      D.23256 = sig->hasthis;
      D.23257 = (int) D.23256;
      D.23261 = D.23260 + D.23257;
      if (D.23261 > i) goto <D.22726>; else goto <D.22728>;
      <D.22728>:
      i = 0;
      goto <D.22730>;
      <D.22729>:
      D.23262 = header->locals[i];
      emit_type (w, D.23262);
      i = i + 1;
      <D.22730>:
      D.23263 = header->num_locals;
      D.23264 = (int) D.23263;
      if (D.23264 > i) goto <D.22729>; else goto <D.22731>;
      <D.22731>:
      D.23259 = sig->param_count;
      D.23265 = (unsigned int) D.23259;
      D.23266 = D.23265 * 4;
      names = monoeg_malloc0 (D.23266);
      mono_method_get_param_names (method, names);
      emit_uleb128 (w, 2);
      name = mono_method_full_name (method, 0);
      emit_string (w, name);
      emit_string (w, name);
      monoeg_g_free (name);
      if (start_symbol != 0B) goto <D.23267>; else goto <D.23268>;
      <D.23267>:
      emit_pointer_unaligned (w, start_symbol);
      emit_pointer_unaligned (w, end_symbol);
      goto <D.23269>;
      <D.23268>:
      emit_pointer_value (w, code);
      D.23270 = code + code_size;
      emit_pointer_value (w, D.23270);
      <D.23269>:
      emit_byte (w, 2);
      emit_byte (w, 118);
      emit_byte (w, 16);
      i = 0;
      goto <D.22739>;
      <D.22738>:
      {
        struct MonoInst * arg;
        struct MonoType * t;
        const char * pname;
        char pname_buf[128];
        struct MonoMethodVar * vmv;
        gboolean need_loclist;

        try
          {
            if (args != 0B) goto <D.23272>; else goto <D.23273>;
            <D.23272>:
            i.47 = (unsigned int) i;
            D.23275 = i.47 * 4;
            D.23276 = args + D.23275;
            iftmp.46 = *D.23276;
            goto <D.23277>;
            <D.23273>:
            iftmp.46 = 0B;
            <D.23277>:
            arg = iftmp.46;
            vmv = 0B;
            need_loclist = 0;
            vmv = find_vmv (cfg, arg);
            if (code != 0B) goto <D.23280>; else goto <D.23281>;
            <D.23280>:
            if (vmv != 0B) goto <D.23282>; else goto <D.23283>;
            <D.23282>:
            D.23284 = vmv->live_range_start;
            if (D.23284 != 0) goto <D.23278>; else goto <D.23285>;
            <D.23285>:
            D.23286 = vmv->live_range_end;
            if (D.23286 != 0) goto <D.23278>; else goto <D.23279>;
            <D.23278>:
            need_loclist = 1;
            <D.23279>:
            <D.23283>:
            <D.23281>:
            if (i == 0) goto <D.23289>; else goto <D.23287>;
            <D.23289>:
            D.23247 = BIT_FIELD_REF <*sig, 32, 64>;
            D.23248 = D.23247 & 4194304;
            if (D.23248 != 0) goto <D.23290>; else goto <D.23287>;
            <D.23290>:
            D.23250 = method->klass;
            D.23251 = BIT_FIELD_REF <*D.23250, 32, 160>;
            D.23252 = D.23251 & 8;
            if (D.23252 != 0) goto <D.23291>; else goto <D.23292>;
            <D.23291>:
            D.23250 = method->klass;
            t = &D.23250->this_arg;
            goto <D.23293>;
            <D.23292>:
            D.23250 = method->klass;
            t = &D.23250->byval_arg;
            <D.23293>:
            pname = "this";
            goto <D.23288>;
            <D.23287>:
            D.23256 = sig->hasthis;
            D.23257 = (int) D.23256;
            D.23258 = i - D.23257;
            t = sig->params[D.23258];
            D.23256 = sig->hasthis;
            D.23257 = (int) D.23256;
            D.23258 = i - D.23257;
            D.23294 = (unsigned int) D.23258;
            D.23295 = D.23294 * 4;
            D.23296 = names + D.23295;
            pname = *D.23296;
            <D.23288>:
            if (need_loclist != 0) goto <D.23298>; else goto <D.23299>;
            <D.23298>:
            iftmp.48 = 15;
            goto <D.23300>;
            <D.23299>:
            iftmp.48 = 3;
            <D.23300>:
            emit_uleb128 (w, iftmp.48);
            D.23301 = *pname;
            if (D.23301 == 0) goto <D.23302>; else goto <D.23303>;
            <D.23302>:
            D.23256 = sig->hasthis;
            D.23257 = (int) D.23256;
            D.23258 = i - D.23257;
            sprintf (&pname_buf, "param%d", D.23258);
            pname = &pname_buf;
            <D.23303>:
            emit_string (w, pname);
            if (arg == 0B) goto <D.23304>; else goto <D.23307>;
            <D.23307>:
            D.23308 = arg->flags;
            D.23309 = (int) D.23308;
            D.23310 = D.23309 & 2;
            if (D.23310 != 0) goto <D.23304>; else goto <D.23305>;
            <D.23304>:
            D.23311 = mono_defaults.int32_class;
            D.23312 = &D.23311->byval_arg;
            emit_var_type (w, D.23312);
            goto <D.23306>;
            <D.23305>:
            emit_var_type (w, t);
            <D.23306>:
            p = &buf;
            p.49 = p;
            encode_var_location (w, arg, p.49, &p);
            if (need_loclist != 0) goto <D.23314>; else goto <D.23315>;
            <D.23314>:
            vmv->live_range_start = 0;
            D.23286 = vmv->live_range_end;
            if (D.23286 == 0) goto <D.23316>; else goto <D.23317>;
            <D.23316>:
            code_size.50 = (int) code_size;
            vmv->live_range_end = code_size.50;
            <D.23317>:
            D.23284 = vmv->live_range_start;
            D.23319 = (sizetype) D.23284;
            D.23320 = code + D.23319;
            D.23286 = vmv->live_range_end;
            D.23321 = (sizetype) D.23286;
            D.23322 = code + D.23321;
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23325 = p.51 - buf.52;
            D.23326 = (unsigned int) D.23325;
            emit_loclist (w, arg, D.23320, D.23322, &buf, D.23326);
            goto <D.23327>;
            <D.23315>:
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23325 = p.51 - buf.52;
            D.23328 = (unsigned char) D.23325;
            D.23329 = (int) D.23328;
            emit_byte (w, D.23329);
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23325 = p.51 - buf.52;
            emit_bytes (w, &buf, D.23325);
            <D.23327>:
          }
        finally
          {
            pname_buf = {CLOBBER};
          }
      }
      i = i + 1;
      <D.22739>:
      D.23259 = sig->param_count;
      D.23260 = (int) D.23259;
      D.23256 = sig->hasthis;
      D.23257 = (int) D.23256;
      D.23261 = D.23260 + D.23257;
      if (D.23261 > i) goto <D.22738>; else goto <D.22740>;
      <D.22740>:
      monoeg_g_free (names);
      locals_info = mono_debug_lookup_locals (method);
      i = 0;
      goto <D.22751>;
      <D.22750>:
      {
        struct MonoInst * ins;
        char name_buf[128];
        int j;
        struct MonoMethodVar * vmv;
        gboolean need_loclist;
        char * lname;

        try
          {
            i.47 = (unsigned int) i;
            D.23275 = i.47 * 4;
            D.23330 = locals + D.23275;
            ins = *D.23330;
            vmv = 0B;
            need_loclist = 0;
            vmv = find_vmv (cfg, ins);
            if (code != 0B) goto <D.23331>; else goto <D.23332>;
            <D.23331>:
            if (vmv != 0B) goto <D.23333>; else goto <D.23334>;
            <D.23333>:
            D.23335 = vmv->live_range_start;
            if (D.23335 != 0) goto <D.23336>; else goto <D.23337>;
            <D.23336>:
            need_loclist = 1;
            <D.23337>:
            <D.23334>:
            <D.23332>:
            if (need_loclist != 0) goto <D.23339>; else goto <D.23340>;
            <D.23339>:
            iftmp.53 = 12;
            goto <D.23341>;
            <D.23340>:
            iftmp.53 = 11;
            <D.23341>:
            emit_uleb128 (w, iftmp.53);
            lname = 0B;
            if (locals_info != 0B) goto <D.23342>; else goto <D.23343>;
            <D.23342>:
            j = 0;
            goto <D.22749>;
            <D.22748>:
            D.23344 = locals_info->locals;
            j.54 = (unsigned int) j;
            D.23346 = j.54 * 12;
            D.23347 = D.23344 + D.23346;
            D.23348 = D.23347->index;
            if (D.23348 == i) goto <D.22747>; else goto <D.23349>;
            <D.23349>:
            j = j + 1;
            <D.22749>:
            D.23350 = locals_info->num_locals;
            if (D.23350 > j) goto <D.22748>; else goto <D.22747>;
            <D.22747>:
            D.23350 = locals_info->num_locals;
            if (D.23350 > j) goto <D.23351>; else goto <D.23352>;
            <D.23351>:
            D.23344 = locals_info->locals;
            j.54 = (unsigned int) j;
            D.23346 = j.54 * 12;
            D.23347 = D.23344 + D.23346;
            lname = D.23347->name;
            <D.23352>:
            <D.23343>:
            if (lname != 0B) goto <D.23353>; else goto <D.23354>;
            <D.23353>:
            emit_string (w, lname);
            goto <D.23355>;
            <D.23354>:
            sprintf (&name_buf, "V_%d", i);
            emit_string (w, &name_buf);
            <D.23355>:
            if (ins == 0B) goto <D.23356>; else goto <D.23359>;
            <D.23359>:
            D.23360 = ins->flags;
            D.23361 = (int) D.23360;
            D.23362 = D.23361 & 2;
            if (D.23362 != 0) goto <D.23356>; else goto <D.23357>;
            <D.23356>:
            D.23311 = mono_defaults.int32_class;
            D.23312 = &D.23311->byval_arg;
            emit_var_type (w, D.23312);
            goto <D.23358>;
            <D.23357>:
            D.23262 = header->locals[i];
            emit_var_type (w, D.23262);
            <D.23358>:
            p = &buf;
            p.49 = p;
            encode_var_location (w, ins, p.49, &p);
            if (need_loclist != 0) goto <D.23363>; else goto <D.23364>;
            <D.23363>:
            D.23365 = vmv->live_range_end;
            if (D.23365 == 0) goto <D.23366>; else goto <D.23367>;
            <D.23366>:
            code_size.50 = (int) code_size;
            vmv->live_range_end = code_size.50;
            <D.23367>:
            D.23335 = vmv->live_range_start;
            D.23368 = (sizetype) D.23335;
            D.23369 = code + D.23368;
            D.23365 = vmv->live_range_end;
            D.23370 = (sizetype) D.23365;
            D.23371 = code + D.23370;
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23325 = p.51 - buf.52;
            D.23326 = (unsigned int) D.23325;
            emit_loclist (w, ins, D.23369, D.23371, &buf, D.23326);
            goto <D.23372>;
            <D.23364>:
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23325 = p.51 - buf.52;
            D.23328 = (unsigned char) D.23325;
            D.23329 = (int) D.23328;
            emit_byte (w, D.23329);
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23325 = p.51 - buf.52;
            emit_bytes (w, &buf, D.23325);
            <D.23372>:
          }
        finally
          {
            name_buf = {CLOBBER};
          }
      }
      i = i + 1;
      <D.22751>:
      D.23263 = header->num_locals;
      D.23264 = (int) D.23263;
      if (D.23264 > i) goto <D.22750>; else goto <D.22752>;
      <D.22752>:
      if (locals_info != 0B) goto <D.23373>; else goto <D.23374>;
      <D.23373>:
      mono_debug_symfile_free_locals (locals_info);
      <D.23374>:
      emit_uleb128 (w, 0);
      emit_line (w);
      emit_debug_info_end (w);
      if (unwind_info != 0B) goto <D.23375>; else goto <D.23376>;
      <D.23375>:
      D.23377 = w->fde_index;
      emit_fde (w, D.23377, start_symbol, end_symbol, code, code_size, unwind_info, 1);
      D.23377 = w->fde_index;
      D.23378 = D.23377 + 1;
      w->fde_index = D.23378;
      <D.23376>:
      if (debug_info != 0B) goto <D.23379>; else goto <D.23380>;
      <D.23379>:
      D.23381 = debug_info->code_start;
      if (D.23381 == code) goto <D.23382>; else goto <D.23383>;
      <D.23382>:
      D.23384 = w->collect_line_info;
      if (D.23384 != 0) goto <D.23385>; else goto <D.23386>;
      <D.23385>:
      {
        struct MethodLineNumberInfo * info;

        info = monoeg_malloc0 (20);
        info->method = method;
        D.23387 = monoeg_strdup (start_symbol);
        info->start_symbol = D.23387;
        D.23388 = monoeg_strdup (end_symbol);
        info->end_symbol = D.23388;
        info->code = code;
        info->code_size = code_size;
        D.23389 = w->line_info;
        D.23390 = monoeg_g_slist_prepend (D.23389, info);
        w->line_info = D.23390;
      }
      goto <D.23391>;
      <D.23386>:
      emit_line_number_info (w, method, start_symbol, end_symbol, code, code_size, debug_info);
      <D.23391>:
      <D.23383>:
      <D.23380>:
      emit_line (w);
      mono_metadata_free_mh (header);
    }
  finally
    {
      buf = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_type (struct MonoDwarfWriter * w, struct MonoType * t)
{
  unsigned int D.23392;
  unsigned int D.23393;
  unsigned char D.23396;
  struct MonoClass * D.23402;
  int D.23403;
  int D.23404;
  unsigned int j.55;
  int D.23411;
  unsigned int D.23415;
  unsigned int D.23416;
  int D.23419;
  struct MonoClass * klass;
  int j;
  const char * tdie;

  klass = mono_class_from_mono_type (t);
  D.23392 = BIT_FIELD_REF <*t, 32, 32>;
  D.23393 = D.23392 & 1073741824;
  if (D.23393 != 0) goto <D.23394>; else goto <D.23395>;
  <D.23394>:
  D.23396 = t->type;
  if (D.23396 == 17) goto <D.23397>; else goto <D.23398>;
  <D.23397>:
  tdie = emit_class_dwarf_info (w, klass, 1);
  if (tdie != 0B) goto <D.23399>; else goto <D.23400>;
  <D.23399>:
  return;
  <D.23400>:
  goto <D.23401>;
  <D.23398>:
  emit_class_dwarf_info (w, klass, 0);
  <D.23401>:
  D.23402 = mono_defaults.int_class;
  t = &D.23402->byval_arg;
  <D.23395>:
  j = 0;
  goto <D.22539>;
  <D.22538>:
  D.23403 = basic_types[j].type;
  D.23396 = t->type;
  D.23404 = (int) D.23396;
  if (D.23403 == D.23404) goto <D.22537>; else goto <D.23405>;
  <D.23405>:
  j = j + 1;
  <D.22539>:
  j.55 = (unsigned int) j;
  if (j.55 <= 16) goto <D.22538>; else goto <D.22537>;
  <D.22537>:
  j.55 = (unsigned int) j;
  if (j.55 <= 16) goto <D.23407>; else goto <D.23408>;
  <D.23407>:
  if (j <= 63) goto <D.23409>; else goto <D.23410>;
  <D.23409>:
  D.23411 = base_types_emitted[j];
  if (D.23411 == 0) goto <D.23412>; else goto <D.23413>;
  <D.23412>:
  emit_class_dwarf_info (w, klass, 0);
  base_types_emitted[j] = 1;
  <D.23413>:
  <D.23410>:
  goto <D.23414>;
  <D.23408>:
  D.23396 = t->type;
  D.23404 = (int) D.23396;
  switch (D.23404) <default: <D.22546>, case 15: <D.22545>, case 17: <D.22543>, case 18: <D.22540>, case 20: <D.22542>, case 21: <D.22544>>
  <D.22540>:
  emit_class_dwarf_info (w, klass, 0);
  goto <D.22541>;
  <D.22542>:
  goto <D.22541>;
  <D.22543>:
  D.23415 = BIT_FIELD_REF <*klass, 32, 160>;
  D.23416 = D.23415 & 16;
  if (D.23416 != 0) goto <D.23417>; else goto <D.23418>;
  <D.23417>:
  emit_class_dwarf_info (w, klass, 0);
  <D.23418>:
  goto <D.22541>;
  <D.22544>:
  D.23419 = mono_type_is_struct (t);
  if (D.23419 == 0) goto <D.23420>; else goto <D.23421>;
  <D.23420>:
  emit_class_dwarf_info (w, klass, 0);
  <D.23421>:
  goto <D.22541>;
  <D.22545>:
  goto <D.22541>;
  <D.22546>:
  goto <D.22541>;
  <D.22541>:
  <D.23414>:
}


emit_class_dwarf_info (struct MonoDwarfWriter * w, struct MonoClass * klass, gboolean vtype)
{
  char * D.23429;
  unsigned char D.23433;
  unsigned int D.23440;
  unsigned int D.23441;
  unsigned char D.23445;
  const char * D.23449;
  const char * iftmp.56;
  const char * D.23454;
  char D.23455;
  int D.23458;
  int D.23459;
  struct GHashTable * D.23460;
  struct GHashTable * D.23461;
  struct MonoType * D.23464;
  struct MonoClass * D.23465;
  unsigned int size.57;
  int D.23467;
  struct MonoType * D.23468;
  unsigned char D.23469;
  int D.23470;
  unsigned int k.58;
  _Bool D.23473;
  long int D.23474;
  long int D.23475;
  const char * D.23478;
  int D.22476;
  int iftmp.59;
  int D.22472;
  const char[8] * D.23482;
  unsigned char D.23483;
  int D.23484;
  unsigned char D.23485;
  int D.23486;
  const unsigned char * D.23491;
  unsigned char D.23492;
  int D.23493;
  const unsigned char * D.23494;
  unsigned char D.23495;
  int D.23496;
  const unsigned char * D.23501;
  unsigned char D.23502;
  int D.23503;
  const unsigned char * D.23504;
  unsigned char D.23505;
  int D.23506;
  const unsigned char * D.23511;
  unsigned char D.23512;
  int D.23513;
  const unsigned char * D.23514;
  unsigned char D.23515;
  int D.23516;
  const char * D.23518;
  struct MonoType * D.23521;
  short unsigned int D.23522;
  int D.23523;
  int D.23524;
  int D.22486;
  int iftmp.60;
  int D.22485;
  const char[9] * D.23530;
  unsigned char D.23531;
  int D.23532;
  unsigned char D.23533;
  int D.23534;
  const unsigned char * D.23539;
  unsigned char D.23540;
  int D.23541;
  const unsigned char * D.23542;
  unsigned char D.23543;
  int D.23544;
  const unsigned char * D.23549;
  unsigned char D.23550;
  int D.23551;
  const unsigned char * D.23552;
  unsigned char D.23553;
  int D.23554;
  const unsigned char * D.23559;
  unsigned char D.23560;
  int D.23561;
  const unsigned char * D.23562;
  unsigned char D.23563;
  int D.23564;
  const char * D.23566;
  const char * D.23569;
  const char * p.61;
  const char * p.62;
  unsigned int D.23572;
  struct MonoType * D.23573;
  unsigned char D.23574;
  int D.23575;
  char D.23576;
  long long int D.23577;
  short unsigned int D.23578;
  long long int D.23579;
  unsigned int D.23580;
  long long int D.23581;
  long long unsigned int D.23582;
  long long int D.23583;
  unsigned int D.23584;
  long long int D.23585;
  struct MonoClass * D.23587;
  int D.23591;
  int iftmp.63;
  struct MonoClassField * D.23599;
  guint32 iftmp.64;
  int D.23604;
  unsigned int D.23605;
  guint8 * p.65;
  guint8 * p.66;
  guint8 * p.67;
  int p.68;
  int buf.69;
  int D.23613;
  unsigned char D.23614;
  int D.23615;
  const char * D.23620;
  guint8 * p.70;
  guint8 * p.71;
  unsigned int D.23625;
  int D.23628;
  unsigned int D.23629;
  unsigned int D.23630;
  unsigned int D.23631;
  char * die;
  char * pointer_die;
  char * reference_die;
  char * full_name;
  char * p;
  void * iter;
  struct MonoClassField * field;
  const char * fdie;
  int k;
  gboolean emit_namespace;
  gboolean has_children;
  struct GHashTable * cache;

  try
    {
      emit_namespace = 0;
      if (vtype != 0) goto <D.23424>; else goto <D.23425>;
      <D.23424>:
      cache = w->class_to_vtype_die;
      goto <D.23426>;
      <D.23425>:
      cache = w->class_to_die;
      <D.23426>:
      die = monoeg_g_hash_table_lookup (cache, klass);
      if (die != 0B) goto <D.23427>; else goto <D.23428>;
      <D.23427>:
      D.23429 = die;
      return D.23429;
      <D.23428>:
      D.23433 = klass->byval_arg.type;
      if (D.23433 != 18) goto <D.23434>; else goto <D.23435>;
      <D.23434>:
      D.23433 = klass->byval_arg.type;
      if (D.23433 != 28) goto <D.23436>; else goto <D.23437>;
      <D.23436>:
      D.23433 = klass->byval_arg.type;
      if (D.23433 != 21) goto <D.23438>; else goto <D.23439>;
      <D.23438>:
      D.23440 = BIT_FIELD_REF <*klass, 32, 160>;
      D.23441 = D.23440 & 16;
      if (D.23441 == 0) goto <D.23442>; else goto <D.23443>;
      <D.23442>:
      D.23433 = klass->byval_arg.type;
      if (D.23433 != 17) goto <D.23432>; else goto <D.23444>;
      <D.23444>:
      if (vtype == 0) goto <D.23432>; else goto <D.23431>;
      <D.23432>:
      D.23433 = klass->byval_arg.type;
      D.23445 = D.23433 + 254;
      if (D.23445 > 11) goto <D.23430>; else goto <D.23446>;
      <D.23446>:
      if (vtype != 0) goto <D.23430>; else goto <D.23431>;
      <D.23430>:
      D.23429 = 0B;
      return D.23429;
      <D.23431>:
      <D.23443>:
      <D.23439>:
      <D.23437>:
      <D.23435>:
      if (emit_namespace != 0) goto <D.23447>; else goto <D.23448>;
      <D.23447>:
      emit_uleb128 (w, 10);
      D.23449 = klass->name_space;
      emit_string (w, D.23449);
      <D.23448>:
      D.23449 = klass->name_space;
      D.23449 = klass->name_space;
      if (D.23449 != 0B) goto <D.23451>; else goto <D.23452>;
      <D.23451>:
      iftmp.56 = ".";
      goto <D.23453>;
      <D.23452>:
      iftmp.56 = "";
      <D.23453>:
      D.23454 = klass->name;
      full_name = monoeg_g_strdup_printf ("%s%s%s", D.23449, iftmp.56, D.23454);
      p = full_name;
      goto <D.22459>;
      <D.22458>:
      D.23455 = *p;
      if (D.23455 == 46) goto <D.23456>; else goto <D.23457>;
      <D.23456>:
      *p = 95;
      <D.23457>:
      p = p + 1;
      <D.22459>:
      D.23455 = *p;
      if (D.23455 != 0) goto <D.22458>; else goto <D.22460>;
      <D.22460>:
      D.23458 = w->tdie_index;
      die = monoeg_g_strdup_printf (".LTDIE_%d", D.23458);
      D.23458 = w->tdie_index;
      pointer_die = monoeg_g_strdup_printf (".LTDIE_%d_POINTER", D.23458);
      D.23458 = w->tdie_index;
      reference_die = monoeg_g_strdup_printf (".LTDIE_%d_REFERENCE", D.23458);
      D.23458 = w->tdie_index;
      D.23459 = D.23458 + 1;
      w->tdie_index = D.23459;
      D.23460 = w->class_to_pointer_die;
      monoeg_g_hash_table_insert_replace (D.23460, klass, pointer_die, 0);
      D.23461 = w->class_to_reference_die;
      monoeg_g_hash_table_insert_replace (D.23461, klass, reference_die, 0);
      monoeg_g_hash_table_insert_replace (cache, klass, die, 0);
      D.23440 = BIT_FIELD_REF <*klass, 32, 160>;
      D.23441 = D.23440 & 16;
      if (D.23441 != 0) goto <D.23462>; else goto <D.23463>;
      <D.23462>:
      {
        int size;

        D.23464 = mono_class_enum_basetype (klass);
        D.23465 = mono_class_from_mono_type (D.23464);
        size = mono_class_value_size (D.23465, 0B);
        emit_label (w, die);
        emit_uleb128 (w, 8);
        emit_string (w, full_name);
        size.57 = (unsigned int) size;
        emit_uleb128 (w, size.57);
        k = 0;
        goto <D.22464>;
        <D.22463>:
        D.23467 = basic_types[k].type;
        D.23468 = mono_class_enum_basetype (klass);
        D.23469 = D.23468->type;
        D.23470 = (int) D.23469;
        if (D.23467 == D.23470) goto <D.22462>; else goto <D.23471>;
        <D.23471>:
        k = k + 1;
        <D.22464>:
        k.58 = (unsigned int) k;
        if (k.58 <= 16) goto <D.22463>; else goto <D.22462>;
        <D.22462>:
        k.58 = (unsigned int) k;
        D.23473 = k.58 > 16;
        D.23474 = (long int) D.23473;
        D.23475 = __builtin_expect (D.23474, 0);
        if (D.23475 != 0) goto <D.23476>; else goto <D.23477>;
        <D.23476>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1055, "k < G_N_ELEMENTS (basic_types)");
        <D.23477>:
        D.23478 = basic_types[k].die_name;
        emit_symbol_diff (w, D.23478, ".Ldebug_info_start", 0);
        iter = 0B;
        goto <D.22477>;
        <D.22501>:
        {
          const char * p;
          int len;
          MonoTypeEnum def_type;

          try
            {
              {
                size_t __s1_len;
                size_t __s2_len;

                __s1_len = 7;
                if (__s1_len <= 3) goto <D.23480>; else goto <D.23481>;
                <D.23480>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = mono_field_get_name (field);
                  D.23482 = "value__";
                  D.23483 = MEM[(const unsigned char *)D.23482];
                  D.23484 = (int) D.23483;
                  D.23485 = *__s2;
                  D.23486 = (int) D.23485;
                  __result = D.23484 - D.23486;
                  {
                    if (__s1_len != 0) goto <D.23487>; else goto <D.23488>;
                    <D.23487>:
                    if (__result == 0) goto <D.23489>; else goto <D.23490>;
                    <D.23489>:
                    D.23491 = &MEM[(void *)"value__" + 1B];
                    D.23492 = *D.23491;
                    D.23493 = (int) D.23492;
                    D.23494 = __s2 + 1;
                    D.23495 = *D.23494;
                    D.23496 = (int) D.23495;
                    __result = D.23493 - D.23496;
                    if (__s1_len > 1) goto <D.23497>; else goto <D.23498>;
                    <D.23497>:
                    if (__result == 0) goto <D.23499>; else goto <D.23500>;
                    <D.23499>:
                    D.23501 = &MEM[(void *)"value__" + 2B];
                    D.23502 = *D.23501;
                    D.23503 = (int) D.23502;
                    D.23504 = __s2 + 2;
                    D.23505 = *D.23504;
                    D.23506 = (int) D.23505;
                    __result = D.23503 - D.23506;
                    if (__s1_len > 2) goto <D.23507>; else goto <D.23508>;
                    <D.23507>:
                    if (__result == 0) goto <D.23509>; else goto <D.23510>;
                    <D.23509>:
                    D.23511 = &MEM[(void *)"value__" + 3B];
                    D.23512 = *D.23511;
                    D.23513 = (int) D.23512;
                    D.23514 = __s2 + 3;
                    D.23515 = *D.23514;
                    D.23516 = (int) D.23515;
                    __result = D.23513 - D.23516;
                    <D.23510>:
                    <D.23508>:
                    <D.23500>:
                    <D.23498>:
                    <D.23490>:
                    <D.23488>:
                  }
                  D.22472 = __result;
                }
                iftmp.59 = D.22472;
                goto <D.23517>;
                <D.23481>:
                D.23518 = mono_field_get_name (field);
                iftmp.59 = __builtin_strcmp ("value__", D.23518);
                <D.23517>:
                D.22476 = iftmp.59;
              }
              if (D.22476 == 0) goto <D.23519>; else goto <D.23520>;
              <D.23519>:
              // predicted unlikely by continue predictor.
              goto <D.22477>;
              <D.23520>:
              D.23521 = field->type;
              D.23522 = D.23521->attrs;
              D.23523 = (int) D.23522;
              D.23524 = D.23523 & 1536;
              if (D.23524 != 0) goto <D.23525>; else goto <D.23526>;
              <D.23525>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = mono_field_get_name (field);
                  D.23530 = "_Deleted";
                  D.23531 = MEM[(const unsigned char *)D.23530];
                  D.23532 = (int) D.23531;
                  D.23533 = *__s2;
                  D.23534 = (int) D.23533;
                  __result = D.23532 - D.23534;
                  {
                    if (__s2_len != 0) goto <D.23535>; else goto <D.23536>;
                    <D.23535>:
                    if (__result == 0) goto <D.23537>; else goto <D.23538>;
                    <D.23537>:
                    D.23539 = &MEM[(void *)"_Deleted" + 1B];
                    D.23540 = *D.23539;
                    D.23541 = (int) D.23540;
                    D.23542 = __s2 + 1;
                    D.23543 = *D.23542;
                    D.23544 = (int) D.23543;
                    __result = D.23541 - D.23544;
                    if (__s2_len > 1) goto <D.23545>; else goto <D.23546>;
                    <D.23545>:
                    if (__result == 0) goto <D.23547>; else goto <D.23548>;
                    <D.23547>:
                    D.23549 = &MEM[(void *)"_Deleted" + 2B];
                    D.23550 = *D.23549;
                    D.23551 = (int) D.23550;
                    D.23552 = __s2 + 2;
                    D.23553 = *D.23552;
                    D.23554 = (int) D.23553;
                    __result = D.23551 - D.23554;
                    if (__s2_len > 2) goto <D.23555>; else goto <D.23556>;
                    <D.23555>:
                    if (__result == 0) goto <D.23557>; else goto <D.23558>;
                    <D.23557>:
                    D.23559 = &MEM[(void *)"_Deleted" + 3B];
                    D.23560 = *D.23559;
                    D.23561 = (int) D.23560;
                    D.23562 = __s2 + 3;
                    D.23563 = *D.23562;
                    D.23564 = (int) D.23563;
                    __result = D.23561 - D.23564;
                    <D.23558>:
                    <D.23556>:
                    <D.23548>:
                    <D.23546>:
                    <D.23538>:
                    <D.23536>:
                  }
                  D.22485 = __result;
                }
                iftmp.60 = -D.22485;
                goto <D.23565>;
                <D.23529>:
                D.23566 = mono_field_get_name (field);
                iftmp.60 = __builtin_strcmp (D.23566, "_Deleted");
                <D.23565>:
                D.22486 = iftmp.60;
              }
              if (D.22486 == 0) goto <D.23567>; else goto <D.23568>;
              <D.23567>:
              // predicted unlikely by continue predictor.
              goto <D.22477>;
              <D.23568>:
              <D.23526>:
              emit_uleb128 (w, 9);
              D.23569 = mono_field_get_name (field);
              emit_string (w, D.23569);
              p.61 = mono_class_get_field_default_value (field, &def_type);
              p = p.61;
              p.62 = p;
              D.23572 = mono_metadata_decode_blob_size (p.62, &p);
              len = (int) D.23572;
              D.23573 = mono_class_enum_basetype (klass);
              D.23574 = D.23573->type;
              D.23575 = (int) D.23574;
              switch (D.23575) <default: <D.22500>, case 2: <D.22489>, case 3: <D.22493>, case 4: <D.22488>, case 5: <D.22487>, case 6: <D.22492>, case 7: <D.22491>, case 8: <D.22495>, case 9: <D.22494>, case 10: <D.22497>, case 11: <D.22496>, case 24: <D.22498>, case 25: <D.22499>>
              <D.22487>:
              <D.22488>:
              <D.22489>:
              p.62 = p;
              D.23576 = *p.62;
              D.23577 = (long long int) D.23576;
              emit_sleb128 (w, D.23577);
              goto <D.22490>;
              <D.22491>:
              <D.22492>:
              <D.22493>:
              p.62 = p;
              D.23578 = mono_read16 (p.62);
              D.23579 = (long long int) D.23578;
              emit_sleb128 (w, D.23579);
              goto <D.22490>;
              <D.22494>:
              <D.22495>:
              p.62 = p;
              D.23580 = mono_read32 (p.62);
              D.23581 = (long long int) D.23580;
              emit_sleb128 (w, D.23581);
              goto <D.22490>;
              <D.22496>:
              <D.22497>:
              p.62 = p;
              D.23582 = mono_read64 (p.62);
              D.23583 = (long long int) D.23582;
              emit_sleb128 (w, D.23583);
              goto <D.22490>;
              <D.22498>:
              <D.22499>:
              p.62 = p;
              D.23584 = mono_read32 (p.62);
              D.23585 = (long long int) D.23584;
              emit_sleb128 (w, D.23585);
              goto <D.22490>;
              <D.22500>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "dwarfwriter.c", 1103);
              <D.22490>:
            }
          finally
            {
              p = {CLOBBER};
              def_type = {CLOBBER};
            }
        }
        <D.22477>:
        field = mono_class_get_fields (klass, &iter);
        if (field != 0B) goto <D.22501>; else goto <D.22502>;
        <D.22502>:
        has_children = 1;
      }
      goto <D.23586>;
      <D.23463>:
      {
        guint8 buf[128];
        guint8 * p;
        char * parent_die;

        try
          {
            D.23587 = klass->parent;
            if (D.23587 != 0B) goto <D.23588>; else goto <D.23589>;
            <D.23588>:
            D.23587 = klass->parent;
            parent_die = emit_class_dwarf_info (w, D.23587, 0);
            goto <D.23590>;
            <D.23589>:
            parent_die = 0B;
            <D.23590>:
            iter = 0B;
            goto <D.22506>;
            <D.22507>:
            D.23521 = field->type;
            D.23522 = D.23521->attrs;
            D.23523 = (int) D.23522;
            D.23591 = D.23523 & 16;
            if (D.23591 != 0) goto <D.23592>; else goto <D.23593>;
            <D.23592>:
            // predicted unlikely by continue predictor.
            goto <D.22506>;
            <D.23593>:
            D.23521 = field->type;
            emit_type (w, D.23521);
            <D.22506>:
            field = mono_class_get_fields (klass, &iter);
            if (field != 0B) goto <D.22507>; else goto <D.22508>;
            <D.22508>:
            iter = 0B;
            if (parent_die != 0B) goto <D.23595>; else goto <D.23598>;
            <D.23598>:
            D.23599 = mono_class_get_fields (klass, &iter);
            if (D.23599 != 0B) goto <D.23595>; else goto <D.23596>;
            <D.23595>:
            iftmp.63 = 1;
            goto <D.23597>;
            <D.23596>:
            iftmp.63 = 0;
            <D.23597>:
            has_children = iftmp.63;
            emit_label (w, die);
            if (has_children != 0) goto <D.23601>; else goto <D.23602>;
            <D.23601>:
            iftmp.64 = 5;
            goto <D.23603>;
            <D.23602>:
            iftmp.64 = 17;
            <D.23603>:
            emit_uleb128 (w, iftmp.64);
            emit_string (w, full_name);
            D.23604 = klass->instance_size;
            D.23605 = (unsigned int) D.23604;
            emit_uleb128 (w, D.23605);
            if (parent_die != 0B) goto <D.23606>; else goto <D.23607>;
            <D.23606>:
            emit_uleb128 (w, 16);
            emit_symbol_diff (w, parent_die, ".Ldebug_info_start", 0);
            p = &buf;
            p.65 = p;
            p.66 = p.65;
            p.67 = p.66 + 1;
            p = p.67;
            *p.66 = 35;
            p.65 = p;
            encode_uleb128 (0, p.65, &p);
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.23613 = p.68 - buf.69;
            D.23614 = (unsigned char) D.23613;
            D.23615 = (int) D.23614;
            emit_byte (w, D.23615);
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.23613 = p.68 - buf.69;
            emit_bytes (w, &buf, D.23613);
            <D.23607>:
            iter = 0B;
            goto <D.22509>;
            <D.22510>:
            D.23521 = field->type;
            D.23522 = D.23521->attrs;
            D.23523 = (int) D.23522;
            D.23591 = D.23523 & 16;
            if (D.23591 != 0) goto <D.23616>; else goto <D.23617>;
            <D.23616>:
            // predicted unlikely by continue predictor.
            goto <D.22509>;
            <D.23617>:
            D.23521 = field->type;
            fdie = get_type_die (w, D.23521);
            if (fdie != 0B) goto <D.23618>; else goto <D.23619>;
            <D.23618>:
            emit_uleb128 (w, 6);
            D.23620 = field->name;
            emit_string (w, D.23620);
            emit_symbol_diff (w, fdie, ".Ldebug_info_start", 0);
            p = &buf;
            p.65 = p;
            p.70 = p.65;
            p.71 = p.70 + 1;
            p = p.71;
            *p.70 = 35;
            D.23440 = BIT_FIELD_REF <*klass, 32, 160>;
            D.23625 = D.23440 & 8;
            if (D.23625 != 0) goto <D.23626>; else goto <D.23623>;
            <D.23626>:
            if (vtype != 0) goto <D.23627>; else goto <D.23623>;
            <D.23627>:
            D.23628 = field->offset;
            D.23629 = (unsigned int) D.23628;
            D.23630 = D.23629 + 4294967288;
            p.65 = p;
            encode_uleb128 (D.23630, p.65, &p);
            goto <D.23624>;
            <D.23623>:
            D.23628 = field->offset;
            D.23631 = (unsigned int) D.23628;
            p.65 = p;
            encode_uleb128 (D.23631, p.65, &p);
            <D.23624>:
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.23613 = p.68 - buf.69;
            D.23614 = (unsigned char) D.23613;
            D.23615 = (int) D.23614;
            emit_byte (w, D.23615);
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.23613 = p.68 - buf.69;
            emit_bytes (w, &buf, D.23613);
            <D.23619>:
            <D.22509>:
            field = mono_class_get_fields (klass, &iter);
            if (field != 0B) goto <D.22510>; else goto <D.22511>;
            <D.22511>:
          }
        finally
          {
            buf = {CLOBBER};
            p = {CLOBBER};
          }
      }
      <D.23586>:
      if (has_children != 0) goto <D.23632>; else goto <D.23633>;
      <D.23632>:
      emit_uleb128 (w, 0);
      <D.23633>:
      emit_uleb128 (w, 7);
      emit_string (w, full_name);
      emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
      emit_label (w, pointer_die);
      emit_uleb128 (w, 13);
      emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
      emit_label (w, reference_die);
      emit_uleb128 (w, 14);
      emit_symbol_diff (w, die, ".Ldebug_info_start", 0);
      monoeg_g_free (full_name);
      if (emit_namespace != 0) goto <D.23634>; else goto <D.23635>;
      <D.23634>:
      emit_uleb128 (w, 0);
      <D.23635>:
      D.23429 = die;
      return D.23429;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_type_die (struct MonoDwarfWriter * w, struct MonoType * t)
{
  unsigned int D.23640;
  unsigned int D.23641;
  unsigned char D.23644;
  struct GHashTable * D.23647;
  struct MonoClass * D.23649;
  int D.23650;
  int D.23651;
  unsigned int j.72;
  struct GHashTable * D.23657;
  unsigned int D.23658;
  unsigned int D.23659;
  int D.23663;
  _Bool D.23667;
  long int D.23668;
  long int D.23669;
  const char * D.23672;
  struct MonoClass * klass;
  int j;
  const char * tdie;

  klass = mono_class_from_mono_type (t);
  D.23640 = BIT_FIELD_REF <*t, 32, 32>;
  D.23641 = D.23640 & 1073741824;
  if (D.23641 != 0) goto <D.23642>; else goto <D.23643>;
  <D.23642>:
  D.23644 = t->type;
  if (D.23644 == 17) goto <D.23645>; else goto <D.23646>;
  <D.23645>:
  D.23647 = w->class_to_pointer_die;
  tdie = monoeg_g_hash_table_lookup (D.23647, klass);
  goto <D.23648>;
  <D.23646>:
  tdie = get_class_die (w, klass, 0);
  <D.23648>:
  D.23649 = mono_defaults.int_class;
  t = &D.23649->byval_arg;
  <D.23643>:
  j = 0;
  goto <D.22522>;
  <D.22521>:
  D.23650 = basic_types[j].type;
  D.23644 = t->type;
  D.23651 = (int) D.23644;
  if (D.23650 == D.23651) goto <D.22520>; else goto <D.23652>;
  <D.23652>:
  j = j + 1;
  <D.22522>:
  j.72 = (unsigned int) j;
  if (j.72 <= 16) goto <D.22521>; else goto <D.22520>;
  <D.22520>:
  j.72 = (unsigned int) j;
  if (j.72 <= 16) goto <D.23654>; else goto <D.23655>;
  <D.23654>:
  tdie = basic_types[j].die_name;
  goto <D.23656>;
  <D.23655>:
  D.23644 = t->type;
  D.23651 = (int) D.23644;
  switch (D.23651) <default: <D.22529>, case 15: <D.22528>, case 17: <D.22526>, case 18: <D.22523>, case 20: <D.22525>, case 21: <D.22527>>
  <D.22523>:
  D.23657 = w->class_to_reference_die;
  tdie = monoeg_g_hash_table_lookup (D.23657, klass);
  goto <D.22524>;
  <D.22525>:
  tdie = ".LDIE_OBJECT";
  goto <D.22524>;
  <D.22526>:
  D.23658 = BIT_FIELD_REF <*klass, 32, 160>;
  D.23659 = D.23658 & 16;
  if (D.23659 != 0) goto <D.23660>; else goto <D.23661>;
  <D.23660>:
  tdie = get_class_die (w, klass, 0);
  goto <D.23662>;
  <D.23661>:
  tdie = ".LDIE_I4";
  <D.23662>:
  goto <D.22524>;
  <D.22527>:
  D.23663 = mono_type_is_struct (t);
  if (D.23663 == 0) goto <D.23664>; else goto <D.23665>;
  <D.23664>:
  D.23657 = w->class_to_reference_die;
  tdie = monoeg_g_hash_table_lookup (D.23657, klass);
  goto <D.23666>;
  <D.23665>:
  tdie = ".LDIE_I4";
  <D.23666>:
  goto <D.22524>;
  <D.22528>:
  tdie = ".LDIE_I";
  goto <D.22524>;
  <D.22529>:
  tdie = ".LDIE_I4";
  goto <D.22524>;
  <D.22524>:
  <D.23656>:
  D.23667 = tdie == 0B;
  D.23668 = (long int) D.23667;
  D.23669 = __builtin_expect (D.23668, 0);
  if (D.23669 != 0) goto <D.23670>; else goto <D.23671>;
  <D.23670>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1259, "tdie");
  <D.23671>:
  D.23672 = tdie;
  return D.23672;
}


get_class_die (struct MonoDwarfWriter * w, struct MonoClass * klass, gboolean vtype)
{
  const char * D.23677;
  struct GHashTable * cache;

  if (vtype != 0) goto <D.23674>; else goto <D.23675>;
  <D.23674>:
  cache = w->class_to_vtype_die;
  goto <D.23676>;
  <D.23675>:
  cache = w->class_to_die;
  <D.23676>:
  D.23677 = monoeg_g_hash_table_lookup (cache, klass);
  return D.23677;
}


encode_uleb128 (guint32 value, guint8 * buf, guint8 * * endbuf)
{
  unsigned char D.23679;
  guint8 * p.73;
  guint8 * p;

  p = buf;
  <D.22255>:
  {
    guint8 b;

    D.23679 = (unsigned char) value;
    b = D.23679 & 127;
    value = value >> 7;
    if (value != 0) goto <D.23680>; else goto <D.23681>;
    <D.23680>:
    b = b | 128;
    <D.23681>:
    p.73 = p;
    p = p.73 + 1;
    *p.73 = b;
  }
  if (value != 0) goto <D.22255>; else goto <D.22256>;
  <D.22256>:
  *endbuf = p;
}


find_vmv (struct MonoCompile * cfg, struct MonoInst * ins)
{
  struct MonoInst * * D.23683;
  unsigned int j.74;
  unsigned int D.23687;
  struct MonoInst * * D.23688;
  struct MonoInst * D.23689;
  unsigned int j.75;
  unsigned int D.23692;
  struct MonoMethodVar * D.23695;
  struct MonoMethodVar * D.23696;
  unsigned int D.23697;
  int j;

  D.23683 = cfg->varinfo;
  if (D.23683 != 0B) goto <D.23684>; else goto <D.23685>;
  <D.23684>:
  j = 0;
  goto <D.22703>;
  <D.22702>:
  D.23683 = cfg->varinfo;
  j.74 = (unsigned int) j;
  D.23687 = j.74 * 4;
  D.23688 = D.23683 + D.23687;
  D.23689 = *D.23688;
  if (D.23689 == ins) goto <D.22701>; else goto <D.23690>;
  <D.23690>:
  j = j + 1;
  <D.22703>:
  j.75 = (unsigned int) j;
  D.23692 = cfg->num_varinfo;
  if (j.75 < D.23692) goto <D.22702>; else goto <D.22701>;
  <D.22701>:
  j.75 = (unsigned int) j;
  D.23692 = cfg->num_varinfo;
  if (j.75 < D.23692) goto <D.23693>; else goto <D.23694>;
  <D.23693>:
  D.23696 = cfg->vars;
  j.74 = (unsigned int) j;
  D.23697 = j.74 * 56;
  D.23695 = D.23696 + D.23697;
  return D.23695;
  <D.23694>:
  <D.23685>:
  D.23695 = 0B;
  return D.23695;
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.23699;
  unsigned int D.23700;

  D.23700 = __builtin_object_size (__s, 1);
  D.23699 = __builtin___sprintf_chk (__s, 1, D.23700, __fmt, __builtin_va_arg_pack ());
  return D.23699;
}


emit_var_type (struct MonoDwarfWriter * w, struct MonoType * t)
{
  const char * tdie;

  tdie = get_type_die (w, t);
  emit_symbol_diff (w, tdie, ".Ldebug_info_start", 0);
}


encode_var_location (struct MonoDwarfWriter * w, struct MonoInst * ins, guint8 * p, guint8 * * endp)
{
  unsigned char D.23704;
  int D.23705;
  int D.23706;
  short unsigned int D.23710;
  guint8 * p.76;
  int D.23714;
  int D.23715;
  unsigned char D.23716;
  unsigned char D.23717;
  guint8 * p.77;
  guint8 * p.78;
  guint8 * p.79;
  int D.23724;
  int D.23725;
  unsigned char D.23726;
  unsigned char D.23727;
  int D.23728;
  guint8 * p.80;
  guint8 * p.81;

  if (ins == 0B) goto <D.23702>; else goto <D.23703>;
  <D.23703>:
  D.23704 = ins->flags;
  D.23705 = (int) D.23704;
  D.23706 = D.23705 & 2;
  if (D.23706 != 0) goto <D.23707>; else goto <D.23708>;
  <D.23707>:
  goto <D.23709>;
  <D.23708>:
  D.23710 = ins->opcode;
  if (D.23710 == 366) goto <D.23711>; else goto <D.23712>;
  <D.23711>:
  p.76 = p;
  D.23714 = ins->dreg;
  D.23715 = mono_hw_reg_to_dwarf_reg (D.23714);
  D.23716 = (unsigned char) D.23715;
  D.23717 = D.23716 + 80;
  *p.76 = D.23717;
  p.76 = p;
  p.77 = p.76 + 1;
  p = p.77;
  goto <D.23719>;
  <D.23712>:
  D.23710 = ins->opcode;
  if (D.23710 == 367) goto <D.23720>; else goto <D.23721>;
  <D.23720>:
  p.76 = p;
  p.78 = p.76;
  p.79 = p.78 + 1;
  p = p.79;
  D.23724 = ins->sreg1;
  D.23725 = mono_hw_reg_to_dwarf_reg (D.23724);
  D.23726 = (unsigned char) D.23725;
  D.23727 = D.23726 + 112;
  *p.78 = D.23727;
  D.23728 = ins->data.op[0].const_val;
  p.76 = p;
  encode_sleb128 (D.23728, p.76, &p);
  goto <D.23729>;
  <D.23721>:
  p.76 = p;
  p.80 = p.76;
  p.81 = p.80 + 1;
  p = p.81;
  *p.80 = 80;
  <D.23729>:
  <D.23719>:
  <D.23709>:
  <D.23702>:
  p.76 = p;
  *endp = p.76;
}


encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  _Bool D.23732;
  unsigned char D.23733;
  unsigned int D.23736;
  int D.23737;
  int D.23738;
  int D.23739;
  int D.23745;
  int D.23746;
  guint8 * p.82;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;
  guint8 * p;

  more = 1;
  D.23732 = value < 0;
  negative = (gboolean) D.23732;
  size = 32;
  p = buf;
  goto <D.22268>;
  <D.22267>:
  D.23733 = (unsigned char) value;
  byte = D.23733 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.23734>; else goto <D.23735>;
  <D.23734>:
  D.23736 = size + 4294967289;
  D.23737 = (int) D.23736;
  D.23738 = 1 << D.23737;
  D.23739 = -D.23738;
  value = D.23739 | value;
  <D.23735>:
  if (value == 0) goto <D.23744>; else goto <D.23740>;
  <D.23744>:
  D.23745 = (int) byte;
  D.23746 = D.23745 & 64;
  if (D.23746 == 0) goto <D.23741>; else goto <D.23740>;
  <D.23740>:
  if (value == -1) goto <D.23747>; else goto <D.23742>;
  <D.23747>:
  D.23745 = (int) byte;
  D.23746 = D.23745 & 64;
  if (D.23746 != 0) goto <D.23741>; else goto <D.23742>;
  <D.23741>:
  more = 0;
  goto <D.23743>;
  <D.23742>:
  byte = byte | 128;
  <D.23743>:
  p.82 = p;
  p = p.82 + 1;
  *p.82 = byte;
  <D.22268>:
  if (more != 0) goto <D.22267>; else goto <D.22269>;
  <D.22269>:
  *endbuf = p;
}


emit_loclist (struct MonoDwarfWriter * w, struct MonoInst * ins, guint8 * loclist_begin_addr, guint8 * loclist_end_addr, guint8 * expr, guint32 expr_len)
{
  int D.23749;
  int D.23750;
  int D.23751;
  unsigned char D.23752;
  int D.23753;
  unsigned int D.23754;
  unsigned char D.23755;
  int D.23756;
  int expr_len.83;
  char label[128];

  try
    {
      emit_push_section (w, ".debug_loc", 0);
      D.23749 = w->loclist_index;
      D.23750 = D.23749;
      D.23751 = D.23750 + 1;
      w->loclist_index = D.23751;
      sprintf (&label, ".Lloclist_%d", D.23750);
      emit_label (w, &label);
      emit_pointer_value (w, loclist_begin_addr);
      emit_pointer_value (w, loclist_end_addr);
      D.23752 = (unsigned char) expr_len;
      D.23753 = (int) D.23752;
      emit_byte (w, D.23753);
      D.23754 = expr_len / 256;
      D.23755 = (unsigned char) D.23754;
      D.23756 = (int) D.23755;
      emit_byte (w, D.23756);
      expr_len.83 = (int) expr_len;
      emit_bytes (w, expr, expr_len.83);
      emit_pointer_value (w, 0B);
      emit_pointer_value (w, 0B);
      emit_pop_section (w);
      emit_symbol_diff (w, &label, ".Ldebug_loc_start", 0);
    }
  finally
    {
      label = {CLOBBER};
    }
}


emit_push_section (struct MonoDwarfWriter * w, const char * section_name, int subsection)
{
  struct MonoImageWriter * D.23758;

  D.23758 = w->w;
  img_writer_emit_push_section (D.23758, section_name, subsection);
}


emit_pop_section (struct MonoDwarfWriter * w)
{
  struct MonoImageWriter * D.23759;

  D.23759 = w->w;
  img_writer_emit_pop_section (D.23759);
}


emit_fde (struct MonoDwarfWriter * w, int fde_index, char * start_symbol, char * end_symbol, guint8 * code, guint32 code_size, struct GSList * unwind_ops, gboolean use_cie)
{
  _Bool D.23765;
  long int D.23766;
  long int D.23767;
  int code_size.84;
  struct GSList * D.23772;
  unsigned int i.85;
  unsigned int D.23778;
  unsigned int uw_info_len.86;
  int uw_info_len.87;
  char symbol1[128];
  char symbol2[128];
  struct GSList * l;
  guint8 * uw_info;
  guint32 uw_info_len;

  try
    {
      emit_section_change (w, ".debug_frame", 0);
      sprintf (&symbol1, ".Lfde%d_start", fde_index);
      sprintf (&symbol2, ".Lfde%d_end", fde_index);
      emit_symbol_diff (w, &symbol2, &symbol1, 0);
      emit_label (w, &symbol1);
      emit_int32 (w, 0);
      if (start_symbol != 0B) goto <D.23760>; else goto <D.23761>;
      <D.23760>:
      emit_pointer (w, start_symbol);
      if (end_symbol != 0B) goto <D.23762>; else goto <D.23763>;
      <D.23762>:
      emit_symbol_diff (w, end_symbol, start_symbol, 0);
      goto <D.23764>;
      <D.23763>:
      D.23765 = code_size == 0;
      D.23766 = (long int) D.23765;
      D.23767 = __builtin_expect (D.23766, 0);
      if (D.23767 != 0) goto <D.23768>; else goto <D.23769>;
      <D.23768>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 395, "code_size");
      <D.23769>:
      code_size.84 = (int) code_size;
      emit_int32 (w, code_size.84);
      <D.23764>:
      goto <D.23771>;
      <D.23761>:
      emit_pointer_value (w, code);
      code_size.84 = (int) code_size;
      emit_int32 (w, code_size.84);
      <D.23771>:
      l = unwind_ops;
      D.23772 = w->cie_program;
      if (D.23772 != 0B) goto <D.23773>; else goto <D.23774>;
      <D.23773>:
      {
        int i;

        i = 0;
        goto <D.22309>;
        <D.22308>:
        if (l != 0B) goto <D.23775>; else goto <D.23776>;
        <D.23775>:
        l = l->next;
        <D.23776>:
        i = i + 1;
        <D.22309>:
        i.85 = (unsigned int) i;
        D.23772 = w->cie_program;
        D.23778 = monoeg_g_slist_length (D.23772);
        if (i.85 < D.23778) goto <D.22308>; else goto <D.22310>;
        <D.22310>:
      }
      <D.23774>:
      uw_info = mono_unwind_ops_encode (l, &uw_info_len);
      uw_info_len.86 = uw_info_len;
      uw_info_len.87 = (int) uw_info_len.86;
      emit_bytes (w, uw_info, uw_info_len.87);
      monoeg_g_free (uw_info);
      emit_alignment (w, 4);
      emit_label (w, &symbol2);
    }
  finally
    {
      symbol1 = {CLOBBER};
      symbol2 = {CLOBBER};
      uw_info_len = {CLOBBER};
    }
}


emit_pointer (struct MonoDwarfWriter * w, const char * target)
{
  struct MonoImageWriter * D.23781;

  D.23781 = w->w;
  img_writer_emit_pointer (D.23781, target);
}


emit_line (struct MonoDwarfWriter * w)
{
  struct MonoImageWriter * D.23782;

  D.23782 = w->w;
  img_writer_emit_line (D.23782);
}


mono_dwarf_writer_emit_trampoline (struct MonoDwarfWriter * w, const char * tramp_name, char * start_symbol, char * end_symbol, guint8 * code, guint32 code_size, struct GSList * unwind_info)
{
  void * D.23783;
  int D.23784;
  int D.23785;

  emit_section_change (w, ".debug_info", 0);
  emit_uleb128 (w, 18);
  emit_string (w, tramp_name);
  emit_pointer_value (w, code);
  D.23783 = code + code_size;
  emit_pointer_value (w, D.23783);
  emit_uleb128 (w, 0);
  emit_debug_info_end (w);
  D.23784 = w->fde_index;
  emit_fde (w, D.23784, start_symbol, end_symbol, code, code_size, unwind_info, 0);
  D.23784 = w->fde_index;
  D.23785 = D.23784 + 1;
  w->fde_index = D.23785;
}