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.25601;
  int D.25602;
  _Bool D.25603;
  long int D.25604;
  long int D.25605;
  int D.25610;
  struct FILE * D.25616;
  const char * D.25617;
  struct GHashTable * D.25618;
  struct GHashTable * D.25619;
  struct GHashTable * D.25620;
  struct GHashTable * D.25621;
  struct MonoDwarfWriter * D.25622;
  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.25599>; else goto <D.25600>;
  <D.25599>:
  D.25601 = w->w;
  D.25602 = img_writer_subsections_supported (D.25601);
  D.25603 = D.25602 == 0;
  D.25604 = (long int) D.25603;
  D.25605 = __builtin_expect (D.25604, 0);
  if (D.25605 != 0) goto <D.25606>; else goto <D.25607>;
  <D.25606>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 94, "img_writer_subsections_supported (w->w)");
  <D.25607>:
  <D.25600>:
  w->emit_line = 1;
  if (appending != 0) goto <D.25608>; else goto <D.25609>;
  <D.25608>:
  D.25601 = w->w;
  D.25610 = img_writer_subsections_supported (D.25601);
  if (D.25610 == 0) goto <D.25611>; else goto <D.25612>;
  <D.25611>:
  w->emit_line = 0;
  <D.25612>:
  goto <D.25613>;
  <D.25609>:
  w->collect_line_info = 1;
  <D.25613>:
  if (emit_line_numbers == 0) goto <D.25614>; else goto <D.25615>;
  <D.25614>:
  w->emit_line = 0;
  w->collect_line_info = 0;
  <D.25615>:
  D.25601 = w->w;
  D.25616 = img_writer_get_fp (D.25601);
  w->fp = D.25616;
  D.25601 = w->w;
  D.25617 = img_writer_get_temp_label_prefix (D.25601);
  w->temp_prefix = D.25617;
  D.25618 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_die = D.25618;
  D.25619 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_vtype_die = D.25619;
  D.25620 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_pointer_die = D.25620;
  D.25621 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_reference_die = D.25621;
  w->cur_file_index = -1;
  D.25622 = w;
  return D.25622;
}


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


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

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


mono_dwarf_escape_path (const char * name)
{
  char * D.25626;
  unsigned int D.25629;
  int D.25630;
  int D.25631;
  unsigned int D.25632;
  sizetype i.0;
  const char * D.25634;
  char D.25635;
  int j.1;
  sizetype j.2;
  char * D.25640;
  int j.3;
  sizetype j.4;
  char * D.25643;
  int j.5;
  sizetype j.6;
  char * D.25647;
  char * D.25648;

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

    D.25629 = strlen (name);
    len = (int) D.25629;
    D.25630 = len + 1;
    D.25631 = D.25630 * 2;
    D.25632 = (unsigned int) D.25631;
    s = monoeg_malloc0 (D.25632);
    j = 0;
    i = 0;
    goto <D.25200>;
    <D.25199>:
    i.0 = (sizetype) i;
    D.25634 = name + i.0;
    D.25635 = *D.25634;
    if (D.25635 == 92) goto <D.25636>; else goto <D.25637>;
    <D.25636>:
    j.1 = j;
    j = j.1 + 1;
    j.2 = (sizetype) j.1;
    D.25640 = s + j.2;
    *D.25640 = 92;
    j.3 = j;
    j = j.3 + 1;
    j.4 = (sizetype) j.3;
    D.25643 = s + j.4;
    *D.25643 = 92;
    goto <D.25644>;
    <D.25637>:
    j.5 = j;
    j = j.5 + 1;
    j.6 = (sizetype) j.5;
    D.25647 = s + j.6;
    i.0 = (sizetype) i;
    D.25634 = name + i.0;
    D.25635 = *D.25634;
    *D.25647 = D.25635;
    <D.25644>:
    i = i + 1;
    <D.25200>:
    if (i < len) goto <D.25199>; else goto <D.25201>;
    <D.25201>:
    D.25648 = s;
    return D.25648;
  }
  <D.25628>:
  D.25648 = monoeg_strdup (name);
  return D.25648;
}


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

  if (str != 0B) goto <D.25650>; else goto <D.25651>;
  <D.25650>:
  D.25652 = __strdup (str);
  return D.25652;
  <D.25651>:
  D.25652 = 0B;
  return D.25652;
}


mono_dwarf_writer_emit_base_info (struct MonoDwarfWriter * w, const char * cu_name, struct GSList * base_unwind_program)
{
  struct MonoImageWriter * D.25654;
  int D.25655;
  int D.25658;
  int D.25661;
  const char * D.25665;
  int D.25666;
  unsigned char D.25667;
  int D.25668;
  unsigned char D.25669;
  const char * D.25670;
  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.25654 = w->w;
  D.25655 = img_writer_subsections_supported (D.25654);
  if (D.25655 != 0) goto <D.25656>; else goto <D.25657>;
  <D.25656>:
  D.25658 = w->appending;
  if (D.25658 != 0) goto <D.25659>; else goto <D.25660>;
  <D.25659>:
  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.25660>:
  <D.25657>:
  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.25661 = w->emit_line;
  if (D.25661 != 0) goto <D.25662>; else goto <D.25663>;
  <D.25662>:
  emit_symbol_diff (w, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
  goto <D.25664>;
  <D.25663>:
  emit_pointer_value (w, 0B);
  <D.25664>:
  i = 0;
  goto <D.25257>;
  <D.25256>:
  D.25665 = basic_types[i].die_name;
  emit_label (w, D.25665);
  emit_uleb128 (w, 4);
  D.25666 = basic_types[i].size;
  D.25667 = (unsigned char) D.25666;
  emit_byte (w, D.25667);
  D.25668 = basic_types[i].encoding;
  D.25669 = (unsigned char) D.25668;
  emit_byte (w, D.25669);
  D.25670 = basic_types[i].name;
  emit_string (w, D.25670);
  i = i + 1;
  <D.25257>:
  i.7 = (unsigned int) i;
  if (i.7 <= 16) goto <D.25256>; else goto <D.25258>;
  <D.25258>:
  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.25674;
  unsigned int i.10;
  unsigned int D.25676;
  int * D.25677;
  int D.25678;
  unsigned int D.25679;
  int i;

  code.8 = (unsigned int) code;
  emit_uleb128 (w, code.8);
  tag.9 = (unsigned int) tag;
  emit_uleb128 (w, tag.9);
  D.25674 = (unsigned char) has_child;
  emit_byte (w, D.25674);
  i = 0;
  goto <D.25113>;
  <D.25112>:
  i.10 = (unsigned int) i;
  D.25676 = i.10 * 4;
  D.25677 = attrs + D.25676;
  D.25678 = *D.25677;
  D.25679 = (unsigned int) D.25678;
  emit_uleb128 (w, D.25679);
  i = i + 1;
  <D.25113>:
  if (i < attrs_len) goto <D.25112>; else goto <D.25114>;
  <D.25114>:
  emit_uleb128 (w, 0);
  emit_uleb128 (w, 0);
}


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

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


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

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


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

  D.25682 = w->w;
  img_writer_emit_symbol_diff (D.25682, 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.25684;

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


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

  <D.25068>:
  {
    guint8 b;

    D.25685 = (unsigned char) value;
    b = D.25685 & 127;
    value = value >> 7;
    if (value != 0) goto <D.25686>; else goto <D.25687>;
    <D.25686>:
    b = b | 128;
    <D.25687>:
    emit_byte (w, b);
  }
  if (value != 0) goto <D.25068>; else goto <D.25069>;
  <D.25069>:
}


emit_byte (struct MonoDwarfWriter * w, guint8 val)
{
  struct MonoImageWriter * D.25688;

  D.25688 = w->w;
  img_writer_emit_byte (D.25688, val);
}


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

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


emit_debug_info_end (struct MonoDwarfWriter * w)
{

}


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

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


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

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


emit_cie (struct MonoDwarfWriter * w)
{
  int D.25692;
  long long int D.25693;
  int D.25694;
  unsigned int D.25695;
  struct GSList * D.25696;
  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.25692 = mono_unwind_get_dwarf_data_align ();
  D.25693 = (long long int) D.25692;
  emit_sleb128 (w, D.25693);
  D.25694 = mono_unwind_get_dwarf_pc_reg ();
  D.25695 = (unsigned int) D.25694;
  emit_uleb128 (w, D.25695);
  D.25696 = w->cie_program;
  w->cie_program = D.25696;
  D.25696 = w->cie_program;
  if (D.25696 != 0B) goto <D.25697>; else goto <D.25698>;
  <D.25697>:
  {
    guint32 uw_info_len;
    guint8 * uw_info;

    try
      {
        D.25696 = w->cie_program;
        uw_info = mono_unwind_ops_encode (D.25696, &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.25698>:
  emit_alignment (w, 4);
  emit_label (w, ".Lcie0_end");
}


emit_sleb128 (struct MonoDwarfWriter * w, gint64 value)
{
  _Bool D.25701;
  unsigned char D.25702;
  unsigned int D.25705;
  int D.25706;
  long long int D.25707;
  long long int D.25708;
  int D.25714;
  int D.25715;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;

  more = 1;
  D.25701 = value < 0;
  negative = (gboolean) D.25701;
  size = 64;
  goto <D.25079>;
  <D.25078>:
  D.25702 = (unsigned char) value;
  byte = D.25702 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.25703>; else goto <D.25704>;
  <D.25703>:
  D.25705 = size + 4294967289;
  D.25706 = (int) D.25705;
  D.25707 = 1 << D.25706;
  D.25708 = -D.25707;
  value = D.25708 | value;
  <D.25704>:
  if (value == 0) goto <D.25713>; else goto <D.25709>;
  <D.25713>:
  D.25714 = (int) byte;
  D.25715 = D.25714 & 64;
  if (D.25715 == 0) goto <D.25710>; else goto <D.25709>;
  <D.25709>:
  if (value == -1) goto <D.25716>; else goto <D.25711>;
  <D.25716>:
  D.25714 = (int) byte;
  D.25715 = D.25714 & 64;
  if (D.25715 != 0) goto <D.25710>; else goto <D.25711>;
  <D.25710>:
  more = 0;
  goto <D.25712>;
  <D.25711>:
  byte = byte | 128;
  <D.25712>:
  emit_byte (w, byte);
  <D.25079>:
  if (more != 0) goto <D.25078>; else goto <D.25080>;
  <D.25080>:
}


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

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


mono_dwarf_writer_close (struct MonoDwarfWriter * w)
{
  int D.25718;
  int D.25721;

  D.25718 = w->appending;
  if (D.25718 == 0) goto <D.25719>; else goto <D.25720>;
  <D.25719>:
  emit_section_change (w, ".debug_info", 0);
  emit_byte (w, 0);
  emit_label (w, ".Ldebug_info_end");
  <D.25720>:
  D.25721 = w->collect_line_info;
  if (D.25721 != 0) goto <D.25722>; else goto <D.25723>;
  <D.25722>:
  emit_all_line_number_info (w);
  <D.25723>:
}


emit_all_line_number_info (struct MonoDwarfWriter * w)
{
  int D.25724;
  _Bool D.25725;
  long int D.25726;
  long int D.25727;
  struct GSList * D.25730;
  struct MonoMethod * D.25731;
  struct GPtrArray * source_file_list.14;
  void * * D.25735;
  unsigned int i.15;
  unsigned int D.25737;
  void * * D.25738;
  char * D.25739;
  unsigned int i.16;
  unsigned int D.25741;
  struct GHashTable * D.25742;
  int D.25743;
  const void * D.25744;
  int D.25745;
  void * D.25748;
  int D.25751;
  int D.25752;
  int D.25753;
  void * D.25754;
  int D.25756;
  char * D.25757;
  int D.25758;
  void * D.25761;
  char * D.25765;
  unsigned int dir_index.17;
  struct MonoMethod * D.25767;
  struct MonoDomain * D.25768;
  char * D.25769;
  char * D.25770;
  guint8 * D.25771;
  unsigned int D.25772;
  int i;
  struct GHashTable * dir_to_index;
  struct GHashTable * index_to_dir;
  struct GSList * l;
  struct GSList * info_list;

  D.25724 = w->collect_line_info;
  D.25725 = D.25724 == 0;
  D.25726 = (long int) D.25725;
  D.25727 = __builtin_expect (D.25726, 0);
  if (D.25727 != 0) goto <D.25728>; else goto <D.25729>;
  <D.25728>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 709, "w->collect_line_info");
  <D.25729>:
  add_line_number_file_name (w, "<unknown>", 0, 0);
  D.25730 = w->line_info;
  info_list = monoeg_g_slist_reverse (D.25730);
  l = info_list;
  goto <D.25220>;
  <D.25219>:
  {
    struct MethodLineNumberInfo * info;
    struct MonoDebugMethodInfo * minfo;
    char * source_file;
    struct GPtrArray * source_file_list;

    try
      {
        info = l->data;
        D.25731 = info->method;
        minfo = mono_debug_lookup_method (D.25731);
        if (minfo == 0B) goto <D.25732>; else goto <D.25733>;
        <D.25732>:
        // predicted unlikely by continue predictor.
        goto <D.25214>;
        <D.25733>:
        mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B);
        i = 0;
        goto <D.25217>;
        <D.25216>:
        {
          struct MonoDebugSourceInfo * sinfo;

          source_file_list.14 = source_file_list;
          D.25735 = source_file_list.14->pdata;
          i.15 = (unsigned int) i;
          D.25737 = i.15 * 4;
          D.25738 = D.25735 + D.25737;
          sinfo = *D.25738;
          D.25739 = sinfo->source_file;
          add_line_number_file_name (w, D.25739, 0, 0);
        }
        i = i + 1;
        <D.25217>:
        i.16 = (unsigned int) i;
        source_file_list.14 = source_file_list;
        D.25741 = source_file_list.14->len;
        if (i.16 < D.25741) goto <D.25216>; else goto <D.25218>;
        <D.25218>:
      }
    finally
      {
        source_file = {CLOBBER};
        source_file_list = {CLOBBER};
      }
  }
  <D.25214>:
  l = l->next;
  <D.25220>:
  if (l != 0B) goto <D.25219>; else goto <D.25221>;
  <D.25221>:
  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.25227>;
  <D.25226>:
  {
    char * name;
    char * copy;
    int dir_index;

    D.25742 = w->index_to_file;
    D.25743 = i + 1;
    D.25744 = (const void *) D.25743;
    name = monoeg_g_hash_table_lookup (D.25742, D.25744);
    dir_index = 0;
    D.25745 = monoeg_g_path_is_absolute (name);
    if (D.25745 != 0) goto <D.25746>; else goto <D.25747>;
    <D.25746>:
    {
      char * dir;

      dir = monoeg_g_path_get_dirname (name);
      D.25748 = monoeg_g_hash_table_lookup (dir_to_index, dir);
      dir_index = (int) D.25748;
      if (dir_index == 0) goto <D.25749>; else goto <D.25750>;
      <D.25749>:
      dir_index = w->line_number_dir_index;
      D.25751 = w->line_number_dir_index;
      D.25752 = D.25751 + 1;
      w->line_number_dir_index = D.25752;
      copy = monoeg_strdup (dir);
      D.25753 = dir_index + 1;
      D.25754 = (void *) D.25753;
      monoeg_g_hash_table_insert_replace (dir_to_index, copy, D.25754, 0);
      D.25753 = dir_index + 1;
      D.25754 = (void *) D.25753;
      monoeg_g_hash_table_insert_replace (index_to_dir, D.25754, copy, 0);
      goto <D.25755>;
      <D.25750>:
      dir_index = dir_index + -1;
      <D.25755>:
      monoeg_g_free (dir);
    }
    <D.25747>:
  }
  i = i + 1;
  <D.25227>:
  D.25756 = w->line_number_file_index;
  if (D.25756 > i) goto <D.25226>; else goto <D.25228>;
  <D.25228>:
  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.25231>;
  <D.25230>:
  {
    char * dir;

    D.25743 = i + 1;
    D.25744 = (const void *) D.25743;
    dir = monoeg_g_hash_table_lookup (index_to_dir, D.25744);
    D.25757 = mono_dwarf_escape_path (dir);
    emit_string (w, D.25757);
  }
  i = i + 1;
  <D.25231>:
  D.25751 = w->line_number_dir_index;
  if (D.25751 > i) goto <D.25230>; else goto <D.25232>;
  <D.25232>:
  emit_byte (w, 0);
  i = 0;
  goto <D.25238>;
  <D.25237>:
  {
    char * name;
    char * basename;
    char * dir;
    int dir_index;

    D.25742 = w->index_to_file;
    D.25743 = i + 1;
    D.25744 = (const void *) D.25743;
    name = monoeg_g_hash_table_lookup (D.25742, D.25744);
    basename = 0B;
    dir_index = 0;
    D.25758 = monoeg_g_path_is_absolute (name);
    if (D.25758 != 0) goto <D.25759>; else goto <D.25760>;
    <D.25759>:
    dir = monoeg_g_path_get_dirname (name);
    D.25761 = monoeg_g_hash_table_lookup (dir_to_index, dir);
    dir_index = (int) D.25761;
    basename = monoeg_g_path_get_basename (name);
    <D.25760>:
    if (basename != 0B) goto <D.25762>; else goto <D.25763>;
    <D.25762>:
    emit_string (w, basename);
    goto <D.25764>;
    <D.25763>:
    D.25765 = mono_dwarf_escape_path (name);
    emit_string (w, D.25765);
    <D.25764>:
    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.25238>:
  D.25756 = w->line_number_file_index;
  if (D.25756 > i) goto <D.25237>; else goto <D.25239>;
  <D.25239>:
  emit_byte (w, 0);
  emit_label (w, ".Ldebug_line_header_end");
  l = info_list;
  goto <D.25243>;
  <D.25242>:
  {
    struct MethodLineNumberInfo * info;
    struct MonoDebugMethodJitInfo * dmji;

    info = l->data;
    D.25767 = info->method;
    D.25768 = mono_domain_get ();
    dmji = mono_debug_find_method (D.25767, D.25768);
    D.25767 = info->method;
    D.25769 = info->start_symbol;
    D.25770 = info->end_symbol;
    D.25771 = info->code;
    D.25772 = info->code_size;
    emit_line_number_info (w, D.25767, D.25769, D.25770, D.25771, D.25772, dmji);
    mono_debug_free_method_jit_info (dmji);
  }
  l = l->next;
  <D.25243>:
  if (l != 0B) goto <D.25242>; else goto <D.25244>;
  <D.25244>:
  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.25775;
  struct GHashTable * D.25778;
  struct GHashTable * D.25779;
  void * D.25780;
  int D.25783;
  int D.25784;
  int D.25785;
  int D.25786;
  void * D.25787;
  struct GHashTable * D.25788;
  int index;
  char * copy;

  D.25775 = w->file_to_index;
  if (D.25775 == 0B) goto <D.25776>; else goto <D.25777>;
  <D.25776>:
  D.25778 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  w->file_to_index = D.25778;
  D.25779 = monoeg_g_hash_table_new (0B, 0B);
  w->index_to_file = D.25779;
  <D.25777>:
  D.25775 = w->file_to_index;
  D.25780 = monoeg_g_hash_table_lookup (D.25775, name);
  index = (int) D.25780;
  if (index > 0) goto <D.25781>; else goto <D.25782>;
  <D.25781>:
  D.25783 = index + -1;
  return D.25783;
  <D.25782>:
  index = w->line_number_file_index;
  D.25784 = w->line_number_file_index;
  D.25785 = D.25784 + 1;
  w->line_number_file_index = D.25785;
  copy = monoeg_strdup (name);
  D.25775 = w->file_to_index;
  D.25786 = index + 1;
  D.25787 = (void *) D.25786;
  monoeg_g_hash_table_insert_replace (D.25775, copy, D.25787, 0);
  D.25788 = w->index_to_file;
  D.25786 = index + 1;
  D.25787 = (void *) D.25786;
  monoeg_g_hash_table_insert_replace (D.25788, D.25787, copy, 0);
  D.25783 = index;
  return D.25783;
}


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.25790;
  _Bool D.25793;
  long int D.25794;
  long int D.25795;
  unsigned int D.25798;
  unsigned int D.25799;
  struct MonoDebugLineNumberEntry * D.25800;
  unsigned int D.25801;
  unsigned int D.25802;
  unsigned int D.25803;
  unsigned int i.18;
  unsigned int D.25805;
  unsigned int j.19;
  unsigned int D.25809;
  int * D.25810;
  unsigned int j.20;
  unsigned int D.25812;
  unsigned int i.21;
  unsigned int D.25814;
  sizetype i.22;
  sizetype D.25818;
  sizetype D.25819;
  unsigned int D.25820;
  int D.25821;
  unsigned int D.25822;
  unsigned int j.23;
  unsigned int D.25831;
  int * D.25832;
  unsigned int i.24;
  unsigned int il_offset.25;
  char * D.25843;
  unsigned int D.25844;
  int D.25845;
  int prev_line.26;
  unsigned int D.25847;
  int D.25853;
  long long int D.25854;
  int D.25509;
  int D.25860;
  int D.25863;
  int D.25865;
  unsigned int file_index.27;
  unsigned int D.25871;
  long long int D.25872;
  const unsigned char * ip.28;
  struct FILE * D.25877;
  int D.25878;
  int D.25879;
  unsigned int D.25880;
  unsigned int D.25881;
  const guint8 * ip.29;
  int ip.30;
  int ip.31;
  unsigned int il_offset.32;
  unsigned int D.25886;
  int * D.25887;
  const unsigned char * D.25888;
  unsigned int D.25889;
  unsigned int D.25892;
  int * D.25893;
  int D.25898;
  unsigned int D.25899;
  int D.25900;
  int D.25901;
  unsigned int prev_native_offset.33;
  unsigned int D.25903;
  long long int D.25904;
  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.25790 = w->emit_line;
  if (D.25790 == 0) goto <D.25791>; else goto <D.25792>;
  <D.25791>:
  mono_metadata_free_mh (header);
  return;
  <D.25792>:
  minfo = mono_debug_lookup_method (method);
  D.25793 = code_size == 0;
  D.25794 = (long int) D.25793;
  D.25795 = __builtin_expect (D.25794, 0);
  if (D.25795 != 0) goto <D.25796>; else goto <D.25797>;
  <D.25796>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1585, "code_size");
  <D.25797>:
  D.25798 = debug_info->num_line_numbers;
  D.25799 = D.25798 * 8;
  ln_array = monoeg_malloc0 (D.25799);
  D.25800 = debug_info->line_numbers;
  D.25798 = debug_info->num_line_numbers;
  D.25801 = D.25798 * 8;
  memcpy (ln_array, D.25800, D.25801);
  D.25798 = debug_info->num_line_numbers;
  qsort (ln_array, D.25798, 8, compare_lne);
  D.25802 = code_size + 1;
  D.25803 = D.25802 * 4;
  native_to_il_offset = monoeg_malloc0 (D.25803);
  i = 0;
  goto <D.25496>;
  <D.25495>:
  {
    int j;
    struct MonoDebugLineNumberEntry * lne;

    i.18 = (unsigned int) i;
    D.25805 = i.18 * 8;
    lne = ln_array + D.25805;
    if (i == 0) goto <D.25806>; else goto <D.25807>;
    <D.25806>:
    j = 0;
    goto <D.25486>;
    <D.25485>:
    j.19 = (unsigned int) j;
    D.25809 = j.19 * 4;
    D.25810 = native_to_il_offset + D.25809;
    *D.25810 = -1;
    j = j + 1;
    <D.25486>:
    j.20 = (unsigned int) j;
    D.25812 = lne->native_offset;
    if (j.20 < D.25812) goto <D.25485>; else goto <D.25487>;
    <D.25487>:
    <D.25807>:
    i.21 = (unsigned int) i;
    D.25798 = debug_info->num_line_numbers;
    D.25814 = D.25798 + 4294967295;
    if (i.21 < D.25814) goto <D.25815>; else goto <D.25816>;
    <D.25815>:
    {
      struct MonoDebugLineNumberEntry * lne_next;

      i.22 = (sizetype) i;
      D.25818 = i.22 + 1;
      D.25819 = D.25818 * 8;
      lne_next = ln_array + D.25819;
      D.25812 = lne->native_offset;
      j = (int) D.25812;
      goto <D.25490>;
      <D.25489>:
      j.19 = (unsigned int) j;
      D.25809 = j.19 * 4;
      D.25810 = native_to_il_offset + D.25809;
      D.25820 = lne->il_offset;
      D.25821 = (int) D.25820;
      *D.25810 = D.25821;
      j = j + 1;
      <D.25490>:
      j.20 = (unsigned int) j;
      D.25822 = lne_next->native_offset;
      if (j.20 < D.25822) goto <D.25489>; else goto <D.25491>;
      <D.25491>:
    }
    goto <D.25823>;
    <D.25816>:
    D.25812 = lne->native_offset;
    j = (int) D.25812;
    goto <D.25493>;
    <D.25492>:
    j.19 = (unsigned int) j;
    D.25809 = j.19 * 4;
    D.25810 = native_to_il_offset + D.25809;
    D.25820 = lne->il_offset;
    D.25821 = (int) D.25820;
    *D.25810 = D.25821;
    j = j + 1;
    <D.25493>:
    j.23 = (unsigned int) j;
    if (j.23 < code_size) goto <D.25492>; else goto <D.25494>;
    <D.25494>:
    <D.25823>:
  }
  i = i + 1;
  <D.25496>:
  i.21 = (unsigned int) i;
  D.25798 = debug_info->num_line_numbers;
  if (i.21 < D.25798) goto <D.25495>; else goto <D.25497>;
  <D.25497>:
  monoeg_g_free (ln_array);
  prev_line = 1;
  prev_il_offset = -1;
  i = 0;
  goto <D.25511>;
  <D.25510>:
  {
    int line_diff;
    int addr_diff;

    if (minfo == 0B) goto <D.25825>; else goto <D.25826>;
    <D.25825>:
    // predicted unlikely by continue predictor.
    goto <D.25500>;
    <D.25826>:
    D.25800 = debug_info->line_numbers;
    if (D.25800 == 0B) goto <D.25827>; else goto <D.25828>;
    <D.25827>:
    // predicted unlikely by continue predictor.
    goto <D.25500>;
    <D.25828>:
    if (native_to_il_offset != 0B) goto <D.25829>; else goto <D.25830>;
    <D.25829>:
    i.18 = (unsigned int) i;
    D.25831 = i.18 * 4;
    D.25832 = native_to_il_offset + D.25831;
    il_offset = *D.25832;
    goto <D.25833>;
    <D.25830>:
    i.24 = (unsigned int) i;
    il_offset = il_offset_from_address (method, debug_info, i.24);
    <D.25833>:
    i.18 = (unsigned int) i;
    D.25831 = i.18 * 4;
    D.25832 = native_to_il_offset + D.25831;
    il_offset = *D.25832;
    if (il_offset < 0) goto <D.25835>; else goto <D.25836>;
    <D.25835>:
    // predicted unlikely by continue predictor.
    goto <D.25500>;
    <D.25836>:
    if (il_offset == prev_il_offset) goto <D.25837>; else goto <D.25838>;
    <D.25837>:
    // predicted unlikely by continue predictor.
    goto <D.25500>;
    <D.25838>:
    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.25840>; else goto <D.25842>;
    <D.25842>:
    D.25843 = loc->source_file;
    if (D.25843 == 0B) goto <D.25840>; else goto <D.25841>;
    <D.25840>:
    // predicted unlikely by continue predictor.
    goto <D.25500>;
    <D.25841>:
    D.25844 = loc->row;
    D.25845 = (int) D.25844;
    prev_line.26 = (int) prev_line;
    line_diff = D.25845 - prev_line.26;
    i.24 = (unsigned int) i;
    D.25847 = i.24 - prev_native_offset;
    addr_diff = (int) D.25847;
    if (first != 0) goto <D.25848>; else goto <D.25849>;
    <D.25848>:
    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.25850>; else goto <D.25851>;
    <D.25850>:
    emit_pointer_unaligned (w, start_symbol);
    goto <D.25852>;
    <D.25851>:
    emit_pointer_value (w, code);
    <D.25852>:
    emit_byte (w, 3);
    D.25844 = loc->row;
    D.25845 = (int) D.25844;
    prev_line.26 = (int) prev_line;
    D.25853 = D.25845 - prev_line.26;
    D.25854 = (long long int) D.25853;
    emit_sleb128 (w, D.25854);
    prev_line = loc->row;
    prev_native_offset = (guint32) i;
    first = 0;
    <D.25849>:
    D.25844 = loc->row;
    if (D.25844 != prev_line) goto <D.25855>; else goto <D.25856>;
    <D.25855>:
    if (prev_file_name == 0B) goto <D.25857>; else goto <D.25859>;
    <D.25859>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.25843 = loc->source_file;
      D.25509 = __builtin_strcmp (D.25843, prev_file_name);
    }
    if (D.25509 != 0) goto <D.25857>; else goto <D.25858>;
    <D.25857>:
    D.25860 = w->collect_line_info;
    if (D.25860 != 0) goto <D.25861>; else goto <D.25862>;
    <D.25861>:
    D.25843 = loc->source_file;
    D.25863 = get_line_number_file_name (w, D.25843);
    file_index = D.25863 + 1;
    goto <D.25864>;
    <D.25862>:
    D.25843 = loc->source_file;
    file_index = emit_line_number_file_name (w, D.25843, 0, 0);
    <D.25864>:
    monoeg_g_free (prev_file_name);
    D.25843 = loc->source_file;
    prev_file_name = monoeg_strdup (D.25843);
    D.25865 = w->cur_file_index;
    if (D.25865 != file_index) goto <D.25866>; else goto <D.25867>;
    <D.25866>:
    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.25867>:
    <D.25858>:
    emit_advance_op (w, line_diff, addr_diff);
    prev_line = loc->row;
    prev_native_offset = (guint32) i;
    <D.25856>:
    mono_debug_symfile_free_location (loc);
  }
  <D.25500>:
  i = i + 1;
  <D.25511>:
  i.24 = (unsigned int) i;
  if (i.24 < code_size) goto <D.25510>; else goto <D.25512>;
  <D.25512>:
  monoeg_g_free (native_to_il_offset);
  monoeg_g_free (prev_file_name);
  if (first == 0) goto <D.25869>; else goto <D.25870>;
  <D.25869>:
  emit_byte (w, 2);
  D.25871 = code_size - prev_native_offset;
  D.25872 = (long long int) D.25871;
  emit_sleb128 (w, D.25872);
  emit_byte (w, 1);
  emit_byte (w, 0);
  emit_byte (w, 1);
  emit_byte (w, 1);
  goto <D.25873>;
  <D.25870>:
  if (start_symbol == 0B) goto <D.25874>; else goto <D.25875>;
  <D.25874>:
  {
    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.25877 = w->il_file;
        fprintf (D.25877, "// %s\n", name);
        D.25878 = w->il_file_line_index;
        D.25879 = D.25878 + 1;
        w->il_file_line_index = D.25879;
        monoeg_g_free (name);
        D.25880 = header->code_size;
        D.25881 = D.25880 * 4;
        il_to_line = monoeg_malloc0 (D.25881);
        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.25521>;
        <D.25520>:
        {
          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.25878 = w->il_file_line_index;
          D.25879 = D.25878 + 1;
          w->il_file_line_index = D.25879;
          ip.29 = ip;
          dis = disasm_ins (method, ip.29, &ip);
          D.25877 = w->il_file;
          fprintf (D.25877, "%s\n", dis);
          monoeg_g_free (dis);
          il_offset.32 = (unsigned int) il_offset;
          D.25886 = il_offset.32 * 4;
          D.25887 = il_to_line + D.25886;
          D.25878 = w->il_file_line_index;
          *D.25887 = D.25878;
        }
        <D.25521>:
        ip.28 = header->code;
        D.25880 = header->code_size;
        D.25888 = ip.28 + D.25880;
        ip.29 = ip;
        if (D.25888 > ip.29) goto <D.25520>; else goto <D.25522>;
        <D.25522>:
        prev_line = 1;
        prev_native_offset = 0;
        i = 0;
        goto <D.25527>;
        <D.25526>:
        {
          struct MonoDebugLineNumberEntry * lne;
          int line;

          D.25800 = debug_info->line_numbers;
          i.18 = (unsigned int) i;
          D.25805 = i.18 * 8;
          lne = D.25800 + D.25805;
          D.25889 = lne->il_offset;
          D.25880 = header->code_size;
          if (D.25889 >= D.25880) goto <D.25890>; else goto <D.25891>;
          <D.25890>:
          // predicted unlikely by continue predictor.
          goto <D.25525>;
          <D.25891>:
          D.25889 = lne->il_offset;
          D.25892 = D.25889 * 4;
          D.25893 = il_to_line + D.25892;
          line = *D.25893;
          if (line == 0) goto <D.25894>; else goto <D.25895>;
          <D.25894>:
          // predicted unlikely by continue predictor.
          goto <D.25525>;
          <D.25895>:
          if (line != prev_line) goto <D.25896>; else goto <D.25897>;
          <D.25896>:
          D.25898 = line - prev_line;
          D.25899 = lne->native_offset;
          D.25900 = (int) D.25899;
          D.25901 = D.25900 - prev_native_offset;
          emit_advance_op (w, D.25898, D.25901);
          prev_line = line;
          D.25899 = lne->native_offset;
          prev_native_offset = (int) D.25899;
          <D.25897>:
        }
        <D.25525>:
        i = i + 1;
        <D.25527>:
        i.21 = (unsigned int) i;
        D.25798 = debug_info->num_line_numbers;
        if (i.21 < D.25798) goto <D.25526>; else goto <D.25528>;
        <D.25528>:
        emit_byte (w, 2);
        prev_native_offset.33 = (unsigned int) prev_native_offset;
        D.25903 = code_size - prev_native_offset.33;
        D.25904 = (long long int) D.25903;
        emit_sleb128 (w, D.25904);
        emit_byte (w, 1);
        emit_byte (w, 0);
        emit_byte (w, 1);
        emit_byte (w, 1);
        D.25877 = w->il_file;
        fflush (D.25877);
        monoeg_g_free (il_to_line);
      }
    finally
      {
        ip = {CLOBBER};
      }
  }
  <D.25875>:
  <D.25873>:
  mono_metadata_free_mh (header);
}


compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b)
{
  unsigned int D.25906;
  unsigned int D.25907;
  gint D.25910;
  unsigned int D.25911;
  unsigned int D.25912;
  unsigned int D.25913;
  unsigned int D.25914;

  D.25906 = a->native_offset;
  D.25907 = b->native_offset;
  if (D.25906 == D.25907) goto <D.25908>; else goto <D.25909>;
  <D.25908>:
  D.25911 = a->il_offset;
  D.25912 = b->il_offset;
  D.25913 = D.25911 - D.25912;
  D.25910 = (gint) D.25913;
  return D.25910;
  <D.25909>:
  D.25906 = a->native_offset;
  D.25907 = b->native_offset;
  D.25914 = D.25906 - D.25907;
  D.25910 = (gint) D.25914;
  return D.25910;
}


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

  D.25917 = __builtin_object_size (__dest, 0);
  D.25916 = __builtin___memcpy_chk (__dest, __src, __len, D.25917);
  return D.25916;
}


il_offset_from_address (struct MonoMethod * method, struct MonoDebugMethodJitInfo * jit, guint32 native_offset)
{
  struct MonoDebugLineNumberEntry * D.25919;
  gint32 D.25922;
  unsigned int D.25923;
  unsigned int D.25924;
  unsigned int i.34;
  unsigned int D.25926;
  struct MonoDebugLineNumberEntry * D.25927;
  unsigned int D.25928;
  unsigned int D.25931;
  int i;

  D.25919 = jit->line_numbers;
  if (D.25919 == 0B) goto <D.25920>; else goto <D.25921>;
  <D.25920>:
  D.25922 = -1;
  return D.25922;
  <D.25921>:
  D.25923 = jit->num_line_numbers;
  D.25924 = D.25923 + 4294967295;
  i = (int) D.25924;
  goto <D.25448>;
  <D.25447>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.25919 = jit->line_numbers;
        i.34 = (unsigned int) i;
        D.25926 = i.34 * 8;
        D.25927 = D.25919 + D.25926;
        lne = *D.25927;
        D.25928 = lne.native_offset;
        if (D.25928 <= native_offset) goto <D.25929>; else goto <D.25930>;
        <D.25929>:
        D.25931 = lne.il_offset;
        D.25922 = (gint32) D.25931;
        return D.25922;
        <D.25930>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.25448>:
  if (i >= 0) goto <D.25447>; else goto <D.25449>;
  <D.25449>:
  D.25922 = -1;
  return D.25922;
}


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

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


get_line_number_file_name (struct MonoDwarfWriter * w, const char * name)
{
  struct GHashTable * D.25936;
  _Bool D.25937;
  long int D.25938;
  long int D.25939;
  void * D.25942;
  _Bool D.25943;
  long int D.25944;
  long int D.25945;
  int D.25948;
  int index;

  D.25936 = w->file_to_index;
  D.25937 = D.25936 == 0B;
  D.25938 = (long int) D.25937;
  D.25939 = __builtin_expect (D.25938, 0);
  if (D.25939 != 0) goto <D.25940>; else goto <D.25941>;
  <D.25940>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 648, "w->file_to_index");
  <D.25941>:
  D.25936 = w->file_to_index;
  D.25942 = monoeg_g_hash_table_lookup (D.25936, name);
  index = (int) D.25942;
  D.25943 = index <= 0;
  D.25944 = (long int) D.25943;
  D.25945 = __builtin_expect (D.25944, 0);
  if (D.25945 != 0) goto <D.25946>; else goto <D.25947>;
  <D.25946>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 650, "index > 0");
  <D.25947>:
  D.25948 = index + -1;
  return D.25948;
}


emit_line_number_file_name (struct MonoDwarfWriter * w, const char * name, gint64 last_mod_time, gint64 file_size)
{
  struct GHashTable * D.25950;
  struct GHashTable * D.25953;
  void * D.25954;
  int D.25957;
  int D.25958;
  struct GHashTable * D.25961;
  struct GHashTable * D.25964;
  void * D.25965;
  int D.25968;
  int D.25969;
  gchar * D.25970;
  void * dir_index.35;
  unsigned int dir_index.36;
  int D.25979;
  int D.25980;
  gchar * D.25981;
  void * index.37;
  int index;
  int dir_index;
  char * basename;

  basename = 0B;
  D.25950 = w->file_to_index;
  if (D.25950 == 0B) goto <D.25951>; else goto <D.25952>;
  <D.25951>:
  D.25953 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  w->file_to_index = D.25953;
  <D.25952>:
  D.25950 = w->file_to_index;
  D.25954 = monoeg_g_hash_table_lookup (D.25950, name);
  index = (int) D.25954;
  if (index > 0) goto <D.25955>; else goto <D.25956>;
  <D.25955>:
  D.25957 = index;
  return D.25957;
  <D.25956>:
  D.25958 = monoeg_g_path_is_absolute (name);
  if (D.25958 != 0) goto <D.25959>; else goto <D.25960>;
  <D.25959>:
  {
    char * dir;

    dir = monoeg_g_path_get_dirname (name);
    D.25961 = w->dir_to_index;
    if (D.25961 == 0B) goto <D.25962>; else goto <D.25963>;
    <D.25962>:
    D.25964 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
    w->dir_to_index = D.25964;
    <D.25963>:
    D.25961 = w->dir_to_index;
    D.25965 = monoeg_g_hash_table_lookup (D.25961, dir);
    dir_index = (int) D.25965;
    if (dir_index == 0) goto <D.25966>; else goto <D.25967>;
    <D.25966>:
    emit_section_change (w, ".debug_line", 2);
    emit_string (w, dir);
    D.25968 = w->line_number_dir_index;
    D.25969 = D.25968 + 1;
    w->line_number_dir_index = D.25969;
    dir_index = w->line_number_dir_index;
    D.25961 = w->dir_to_index;
    D.25970 = monoeg_strdup (dir);
    dir_index.35 = (void *) dir_index;
    monoeg_g_hash_table_insert_replace (D.25961, D.25970, dir_index.35, 0);
    <D.25967>:
    monoeg_g_free (dir);
    basename = monoeg_g_path_get_basename (name);
  }
  goto <D.25972>;
  <D.25960>:
  dir_index = 0;
  <D.25972>:
  emit_section_change (w, ".debug_line", 3);
  if (basename != 0B) goto <D.25973>; else goto <D.25974>;
  <D.25973>:
  emit_string (w, basename);
  goto <D.25975>;
  <D.25974>:
  emit_string (w, name);
  <D.25975>:
  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.25977>; else goto <D.25978>;
  <D.25977>:
  monoeg_g_free (basename);
  <D.25978>:
  D.25979 = w->line_number_file_index;
  D.25980 = D.25979 + 1;
  w->line_number_file_index = D.25980;
  index = w->line_number_file_index;
  D.25950 = w->file_to_index;
  D.25981 = monoeg_strdup (name);
  index.37 = (void *) index;
  monoeg_g_hash_table_insert_replace (D.25950, D.25981, index.37, 0);
  D.25957 = index;
  return D.25957;
}


disasm_ins (struct MonoMethod * method, const guchar * ip, const guint8 * * endip)
{
  const guchar * ip.38;
  unsigned char D.25985;
  const guchar * D.25988;
  unsigned char D.25989;
  int D.25990;
  const unsigned char * D.25991;
  _Bool D.25992;
  long int D.25993;
  long int D.25994;
  int ip.39;
  const unsigned char * D.25998;
  int D.25999;
  int D.26000;
  const char * D.26001;
  const guchar * ip.40;
  const char * D.26003;
  char * D.26005;
  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.25985 = *ip.38;
      if (D.25985 == 240) goto <D.25986>; else goto <D.25987>;
      <D.25986>:
      {
        guint32 token;
        void * data;

        ip.38 = ip;
        D.25988 = ip.38 + 1;
        D.25989 = *D.25988;
        D.25990 = (int) D.25989;
        switch (D.25990) <default: <D.25439>, case 0: <D.25435>, case 11: <D.25438>>
        <D.25435>:
        {
          struct MonoJitICallInfo * info;

          ip.38 = ip;
          D.25991 = ip.38 + 2;
          token = mono_read32 (D.25991);
          data = mono_method_get_wrapper_data (method, token);
          info = mono_find_jit_icall_by_addr (data);
          D.25992 = info == 0B;
          D.25993 = (long int) D.25992;
          D.25994 = __builtin_expect (D.25993, 0);
          if (D.25994 != 0) goto <D.25995>; else goto <D.25996>;
          <D.25995>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1470, "info");
          <D.25996>:
          ip.38 = ip;
          ip.39 = (int) ip.38;
          D.25998 = header->code;
          D.25999 = (int) D.25998;
          D.26000 = ip.39 - D.25999;
          D.26001 = info->name;
          dis = monoeg_g_strdup_printf ("IL_%04x: mono_icall <%s>", D.26000, D.26001);
          ip.38 = ip;
          ip.40 = ip.38 + 6;
          ip = ip.40;
          goto <D.25437>;
        }
        <D.25438>:
        ip.38 = ip;
        D.25991 = ip.38 + 2;
        token = mono_read32 (D.25991);
        data = mono_method_get_wrapper_data (method, token);
        ip.38 = ip;
        ip.39 = (int) ip.38;
        D.25998 = header->code;
        D.25999 = (int) D.25998;
        D.26000 = ip.39 - D.25999;
        D.26003 = MEM[(struct MonoClass *)data].name;
        dis = monoeg_g_strdup_printf ("IL_%04x: mono_classconst <%s>", D.26000, D.26003);
        ip.38 = ip;
        ip.40 = ip.38 + 6;
        ip = ip.40;
        goto <D.25437>;
        <D.25439>:
        ip.38 = ip;
        dis = mono_disasm_code_one (&dh, method, ip.38, &ip);
        <D.25437>:
      }
      goto <D.26004>;
      <D.25987>:
      ip.38 = ip;
      dis = mono_disasm_code_one (&dh, method, ip.38, &ip);
      <D.26004>:
      token_handler_ip = 0B;
      ip.38 = ip;
      *endip = ip.38;
      mono_metadata_free_mh (header);
      D.26005 = dis;
      return D.26005;
    }
  finally
    {
      dh = {CLOBBER};
    }
}


token_handler (struct MonoDisHelper * dh, struct MonoMethod * method, guint32 token)
{
  unsigned char D.26008;
  unsigned char D.26009;
  const guint8 * token_handler_ip.41;
  unsigned char D.26013;
  int D.26014;
  struct MonoClass * D.26018;
  struct MonoImage * D.26019;
  struct MonoClass * klass.42;
  struct MonoClass * klass.43;
  const char * D.26022;
  char * D.26032;
  char * res;
  char * desc;
  struct MonoMethod * cmethod;
  struct MonoClass * klass;
  struct MonoClassField * field;
  void * data;

  try
    {
      data = 0B;
      D.26008 = BIT_FIELD_REF <*method, 8, 160>;
      D.26009 = D.26008 & 124;
      if (D.26009 != 0) goto <D.26010>; else goto <D.26011>;
      <D.26010>:
      data = mono_method_get_wrapper_data (method, token);
      <D.26011>:
      token_handler_ip.41 = token_handler_ip;
      D.26013 = *token_handler_ip.41;
      D.26014 = (int) D.26013;
      switch (D.26014) <default: <D.25424>, case 40: <D.25417>, case 41: <D.25419>, case 111: <D.25418>, case 115: <D.25416>, case 116: <D.25413>, case 117: <D.25412>, case 123: <D.25420>, case 125: <D.25422>, case 126: <D.25421>, case 128: <D.25423>, case 143: <D.25414>>
      <D.25412>:
      <D.25413>:
      <D.25414>:
      D.26008 = BIT_FIELD_REF <*method, 8, 160>;
      D.26009 = D.26008 & 124;
      if (D.26009 != 0) goto <D.26015>; else goto <D.26016>;
      <D.26015>:
      klass = data;
      goto <D.26017>;
      <D.26016>:
      D.26018 = method->klass;
      D.26019 = D.26018->image;
      klass.42 = mono_class_get_full (D.26019, token, 0B);
      klass = klass.42;
      <D.26017>:
      klass.43 = klass;
      D.26022 = klass.43->name;
      res = monoeg_g_strdup_printf ("<%s>", D.26022);
      goto <D.25415>;
      <D.25416>:
      <D.25417>:
      <D.25418>:
      D.26008 = BIT_FIELD_REF <*method, 8, 160>;
      D.26009 = D.26008 & 124;
      if (D.26009 != 0) goto <D.26023>; else goto <D.26024>;
      <D.26023>:
      cmethod = data;
      goto <D.26025>;
      <D.26024>:
      D.26018 = method->klass;
      D.26019 = D.26018->image;
      cmethod = mono_get_method_full (D.26019, token, 0B, 0B);
      <D.26025>:
      desc = mono_method_full_name (cmethod, 1);
      res = monoeg_g_strdup_printf ("<%s>", desc);
      monoeg_g_free (desc);
      goto <D.25415>;
      <D.25419>:
      D.26008 = BIT_FIELD_REF <*method, 8, 160>;
      D.26009 = D.26008 & 124;
      if (D.26009 != 0) goto <D.26026>; else goto <D.26027>;
      <D.26026>:
      desc = mono_signature_get_desc (data, 0);
      res = monoeg_g_strdup_printf ("<%s>", desc);
      monoeg_g_free (desc);
      goto <D.26028>;
      <D.26027>:
      res = monoeg_g_strdup_printf ("<0x%08x>", token);
      <D.26028>:
      goto <D.25415>;
      <D.25420>:
      <D.25421>:
      <D.25422>:
      <D.25423>:
      D.26008 = BIT_FIELD_REF <*method, 8, 160>;
      D.26009 = D.26008 & 124;
      if (D.26009 != 0) goto <D.26029>; else goto <D.26030>;
      <D.26029>:
      field = data;
      goto <D.26031>;
      <D.26030>:
      D.26018 = method->klass;
      D.26019 = D.26018->image;
      field = mono_field_from_token (D.26019, token, &klass, 0B);
      <D.26031>:
      desc = mono_field_full_name (field);
      res = monoeg_g_strdup_printf ("<%s>", desc);
      monoeg_g_free (desc);
      goto <D.25415>;
      <D.25424>:
      res = monoeg_g_strdup_printf ("<0x%08x>", token);
      goto <D.25415>;
      <D.25415>:
      D.26032 = res;
      return D.26032;
    }
  finally
    {
      klass = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.26037;
  int D.26042;
  void * D.26044;
  unsigned int D.26045;

  D.26037 = __builtin_constant_p (__len);
  if (D.26037 != 0) goto <D.26038>; else goto <D.26039>;
  <D.26038>:
  if (__len == 0) goto <D.26040>; else goto <D.26041>;
  <D.26040>:
  D.26042 = __builtin_constant_p (__ch);
  if (D.26042 == 0) goto <D.26035>; else goto <D.26043>;
  <D.26043>:
  if (__ch != 0) goto <D.26035>; else goto <D.26036>;
  <D.26035>:
  __warn_memset_zero_len ();
  D.26044 = __dest;
  return D.26044;
  <D.26036>:
  <D.26041>:
  <D.26039>:
  D.26045 = __builtin_object_size (__dest, 0);
  D.26044 = __builtin___memset_chk (__dest, __ch, __len, D.26045);
  return D.26044;
}


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

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


emit_advance_op (struct MonoDwarfWriter * w, int line_diff, int addr_diff)
{
  unsigned int line_diff.44;
  unsigned int D.26050;
  int max_special_addr_diff.45;
  int D.26058;
  int D.26061;
  int D.26062;
  int D.26063;
  int D.26064;
  unsigned char D.26069;
  long long int D.26071;
  long long int D.26072;
  gint64 opcode;

  opcode = 0;
  line_diff.44 = (unsigned int) line_diff;
  D.26050 = line_diff.44 + 5;
  if (D.26050 <= 13) goto <D.26051>; else goto <D.26052>;
  <D.26051>:
  max_special_addr_diff.45 = max_special_addr_diff;
  if (max_special_addr_diff.45 == 0) goto <D.26054>; else goto <D.26055>;
  <D.26054>:
  max_special_addr_diff = 17;
  <D.26055>:
  max_special_addr_diff.45 = max_special_addr_diff;
  if (addr_diff > max_special_addr_diff.45) goto <D.26056>; else goto <D.26057>;
  <D.26056>:
  max_special_addr_diff.45 = max_special_addr_diff;
  D.26058 = max_special_addr_diff.45 * 2;
  if (D.26058 > addr_diff) goto <D.26059>; else goto <D.26060>;
  <D.26059>:
  emit_byte (w, 8);
  max_special_addr_diff.45 = max_special_addr_diff;
  addr_diff = addr_diff - max_special_addr_diff.45;
  <D.26060>:
  <D.26057>:
  D.26061 = line_diff + 5;
  D.26062 = addr_diff * 14;
  D.26063 = D.26061 + D.26062;
  D.26064 = D.26063 + 13;
  opcode = (gint64) D.26064;
  if (opcode > 255) goto <D.26065>; else goto <D.26066>;
  <D.26065>:
  opcode = 0;
  <D.26066>:
  <D.26052>:
  if (opcode != 0) goto <D.26067>; else goto <D.26068>;
  <D.26067>:
  D.26069 = (unsigned char) opcode;
  emit_byte (w, D.26069);
  goto <D.26070>;
  <D.26068>:
  emit_byte (w, 3);
  D.26071 = (long long int) line_diff;
  emit_sleb128 (w, D.26071);
  emit_byte (w, 2);
  D.26072 = (long long int) addr_diff;
  emit_sleb128 (w, D.26072);
  emit_byte (w, 1);
  <D.26070>:
}


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 char D.26076;
  unsigned char D.26077;
  struct MonoClass * D.26079;
  unsigned char D.26080;
  unsigned char D.26081;
  <unnamed-unsigned:1> D.26085;
  int D.26086;
  int D.26087;
  short unsigned int D.26088;
  int D.26089;
  int D.26090;
  struct MonoType * D.26091;
  short unsigned int D.26092;
  int D.26093;
  unsigned int D.26094;
  unsigned int D.26095;
  void * D.26099;
  struct MonoInst * iftmp.46;
  unsigned int i.47;
  unsigned int D.26104;
  struct MonoInst * * D.26105;
  _Bool D.26109;
  _Bool D.26110;
  _Bool D.26111;
  int D.26114;
  int D.26116;
  unsigned int D.26124;
  unsigned int D.26125;
  char * * D.26126;
  guint32 iftmp.48;
  char D.26131;
  unsigned char D.26138;
  int D.26139;
  int D.26140;
  struct MonoClass * D.26141;
  struct MonoType * D.26142;
  guint8 * p.49;
  int code_size.50;
  sizetype D.26149;
  guint8 * D.26150;
  sizetype D.26151;
  guint8 * D.26152;
  int p.51;
  int buf.52;
  int D.26155;
  unsigned int D.26156;
  unsigned char D.26158;
  struct MonoInst * * D.26159;
  _Bool D.26160;
  _Bool D.26161;
  int D.26164;
  guint32 iftmp.53;
  struct MonoDebugLocalVar * D.26173;
  unsigned int j.54;
  unsigned int D.26175;
  struct MonoDebugLocalVar * D.26176;
  int D.26177;
  int D.26179;
  unsigned char D.26189;
  int D.26190;
  int D.26191;
  int D.26194;
  sizetype D.26197;
  guint8 * D.26198;
  sizetype D.26199;
  guint8 * D.26200;
  int D.26206;
  int D.26207;
  const mono_byte * D.26210;
  int D.26213;
  gchar * D.26216;
  gchar * D.26217;
  struct GSList * D.26218;
  struct GSList * D.26219;
  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.25560>;
      <D.25559>:
      {
        struct MonoType * t;

        if (i == 0) goto <D.26075>; else goto <D.26073>;
        <D.26075>:
        D.26076 = BIT_FIELD_REF <*sig, 8, 80>;
        D.26077 = D.26076 & 64;
        if (D.26077 != 0) goto <D.26078>; else goto <D.26073>;
        <D.26078>:
        D.26079 = method->klass;
        D.26080 = BIT_FIELD_REF <*D.26079, 8, 160>;
        D.26081 = D.26080 & 8;
        if (D.26081 != 0) goto <D.26082>; else goto <D.26083>;
        <D.26082>:
        D.26079 = method->klass;
        t = &D.26079->this_arg;
        goto <D.26084>;
        <D.26083>:
        D.26079 = method->klass;
        t = &D.26079->byval_arg;
        <D.26084>:
        goto <D.26074>;
        <D.26073>:
        D.26085 = sig->hasthis;
        D.26086 = (int) D.26085;
        D.26087 = i - D.26086;
        t = sig->params[D.26087];
        <D.26074>:
        emit_type (w, t);
      }
      i = i + 1;
      <D.25560>:
      D.26088 = sig->param_count;
      D.26089 = (int) D.26088;
      D.26085 = sig->hasthis;
      D.26086 = (int) D.26085;
      D.26090 = D.26089 + D.26086;
      if (D.26090 > i) goto <D.25559>; else goto <D.25561>;
      <D.25561>:
      i = 0;
      goto <D.25563>;
      <D.25562>:
      D.26091 = header->locals[i];
      emit_type (w, D.26091);
      i = i + 1;
      <D.25563>:
      D.26092 = header->num_locals;
      D.26093 = (int) D.26092;
      if (D.26093 > i) goto <D.25562>; else goto <D.25564>;
      <D.25564>:
      D.26088 = sig->param_count;
      D.26094 = (unsigned int) D.26088;
      D.26095 = D.26094 * 4;
      names = monoeg_malloc0 (D.26095);
      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.26096>; else goto <D.26097>;
      <D.26096>:
      emit_pointer_unaligned (w, start_symbol);
      emit_pointer_unaligned (w, end_symbol);
      goto <D.26098>;
      <D.26097>:
      emit_pointer_value (w, code);
      D.26099 = code + code_size;
      emit_pointer_value (w, D.26099);
      <D.26098>:
      emit_byte (w, 2);
      emit_byte (w, 118);
      emit_byte (w, 16);
      i = 0;
      goto <D.25572>;
      <D.25571>:
      {
        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.26101>; else goto <D.26102>;
            <D.26101>:
            i.47 = (unsigned int) i;
            D.26104 = i.47 * 4;
            D.26105 = args + D.26104;
            iftmp.46 = *D.26105;
            goto <D.26106>;
            <D.26102>:
            iftmp.46 = 0B;
            <D.26106>:
            arg = iftmp.46;
            vmv = 0B;
            need_loclist = 0;
            vmv = find_vmv (cfg, arg);
            D.26109 = code != 0B;
            D.26110 = vmv != 0B;
            D.26111 = D.26109 & D.26110;
            if (D.26111 != 0) goto <D.26112>; else goto <D.26113>;
            <D.26112>:
            D.26114 = vmv->live_range_start;
            if (D.26114 != 0) goto <D.26107>; else goto <D.26115>;
            <D.26115>:
            D.26116 = vmv->live_range_end;
            if (D.26116 != 0) goto <D.26107>; else goto <D.26108>;
            <D.26107>:
            need_loclist = 1;
            <D.26108>:
            <D.26113>:
            if (i == 0) goto <D.26119>; else goto <D.26117>;
            <D.26119>:
            D.26076 = BIT_FIELD_REF <*sig, 8, 80>;
            D.26077 = D.26076 & 64;
            if (D.26077 != 0) goto <D.26120>; else goto <D.26117>;
            <D.26120>:
            D.26079 = method->klass;
            D.26080 = BIT_FIELD_REF <*D.26079, 8, 160>;
            D.26081 = D.26080 & 8;
            if (D.26081 != 0) goto <D.26121>; else goto <D.26122>;
            <D.26121>:
            D.26079 = method->klass;
            t = &D.26079->this_arg;
            goto <D.26123>;
            <D.26122>:
            D.26079 = method->klass;
            t = &D.26079->byval_arg;
            <D.26123>:
            pname = "this";
            goto <D.26118>;
            <D.26117>:
            D.26085 = sig->hasthis;
            D.26086 = (int) D.26085;
            D.26087 = i - D.26086;
            t = sig->params[D.26087];
            D.26085 = sig->hasthis;
            D.26086 = (int) D.26085;
            D.26087 = i - D.26086;
            D.26124 = (unsigned int) D.26087;
            D.26125 = D.26124 * 4;
            D.26126 = names + D.26125;
            pname = *D.26126;
            <D.26118>:
            if (need_loclist != 0) goto <D.26128>; else goto <D.26129>;
            <D.26128>:
            iftmp.48 = 15;
            goto <D.26130>;
            <D.26129>:
            iftmp.48 = 3;
            <D.26130>:
            emit_uleb128 (w, iftmp.48);
            D.26131 = *pname;
            if (D.26131 == 0) goto <D.26132>; else goto <D.26133>;
            <D.26132>:
            D.26085 = sig->hasthis;
            D.26086 = (int) D.26085;
            D.26087 = i - D.26086;
            sprintf (&pname_buf, "param%d", D.26087);
            pname = &pname_buf;
            <D.26133>:
            emit_string (w, pname);
            if (arg == 0B) goto <D.26134>; else goto <D.26137>;
            <D.26137>:
            D.26138 = arg->flags;
            D.26139 = (int) D.26138;
            D.26140 = D.26139 & 2;
            if (D.26140 != 0) goto <D.26134>; else goto <D.26135>;
            <D.26134>:
            D.26141 = mono_defaults.int32_class;
            D.26142 = &D.26141->byval_arg;
            emit_var_type (w, D.26142);
            goto <D.26136>;
            <D.26135>:
            emit_var_type (w, t);
            <D.26136>:
            p = &buf;
            p.49 = p;
            encode_var_location (w, arg, p.49, &p);
            if (need_loclist != 0) goto <D.26144>; else goto <D.26145>;
            <D.26144>:
            vmv->live_range_start = 0;
            D.26116 = vmv->live_range_end;
            if (D.26116 == 0) goto <D.26146>; else goto <D.26147>;
            <D.26146>:
            code_size.50 = (int) code_size;
            vmv->live_range_end = code_size.50;
            <D.26147>:
            D.26114 = vmv->live_range_start;
            D.26149 = (sizetype) D.26114;
            D.26150 = code + D.26149;
            D.26116 = vmv->live_range_end;
            D.26151 = (sizetype) D.26116;
            D.26152 = code + D.26151;
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.26155 = p.51 - buf.52;
            D.26156 = (unsigned int) D.26155;
            emit_loclist (w, arg, D.26150, D.26152, &buf, D.26156);
            goto <D.26157>;
            <D.26145>:
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.26155 = p.51 - buf.52;
            D.26158 = (unsigned char) D.26155;
            emit_byte (w, D.26158);
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.26155 = p.51 - buf.52;
            emit_bytes (w, &buf, D.26155);
            <D.26157>:
          }
        finally
          {
            pname_buf = {CLOBBER};
          }
      }
      i = i + 1;
      <D.25572>:
      D.26088 = sig->param_count;
      D.26089 = (int) D.26088;
      D.26085 = sig->hasthis;
      D.26086 = (int) D.26085;
      D.26090 = D.26089 + D.26086;
      if (D.26090 > i) goto <D.25571>; else goto <D.25573>;
      <D.25573>:
      monoeg_g_free (names);
      locals_info = mono_debug_lookup_locals (method);
      i = 0;
      goto <D.25584>;
      <D.25583>:
      {
        struct MonoInst * ins;
        char name_buf[128];
        int j;
        struct MonoMethodVar * vmv;
        gboolean need_loclist;
        char * lname;

        try
          {
            i.47 = (unsigned int) i;
            D.26104 = i.47 * 4;
            D.26159 = locals + D.26104;
            ins = *D.26159;
            vmv = 0B;
            need_loclist = 0;
            vmv = find_vmv (cfg, ins);
            D.26109 = code != 0B;
            D.26160 = vmv != 0B;
            D.26161 = D.26109 & D.26160;
            if (D.26161 != 0) goto <D.26162>; else goto <D.26163>;
            <D.26162>:
            D.26164 = vmv->live_range_start;
            if (D.26164 != 0) goto <D.26165>; else goto <D.26166>;
            <D.26165>:
            need_loclist = 1;
            <D.26166>:
            <D.26163>:
            if (need_loclist != 0) goto <D.26168>; else goto <D.26169>;
            <D.26168>:
            iftmp.53 = 12;
            goto <D.26170>;
            <D.26169>:
            iftmp.53 = 11;
            <D.26170>:
            emit_uleb128 (w, iftmp.53);
            lname = 0B;
            if (locals_info != 0B) goto <D.26171>; else goto <D.26172>;
            <D.26171>:
            j = 0;
            goto <D.25582>;
            <D.25581>:
            D.26173 = locals_info->locals;
            j.54 = (unsigned int) j;
            D.26175 = j.54 * 12;
            D.26176 = D.26173 + D.26175;
            D.26177 = D.26176->index;
            if (D.26177 == i) goto <D.25580>; else goto <D.26178>;
            <D.26178>:
            j = j + 1;
            <D.25582>:
            D.26179 = locals_info->num_locals;
            if (D.26179 > j) goto <D.25581>; else goto <D.25580>;
            <D.25580>:
            D.26179 = locals_info->num_locals;
            if (D.26179 > j) goto <D.26180>; else goto <D.26181>;
            <D.26180>:
            D.26173 = locals_info->locals;
            j.54 = (unsigned int) j;
            D.26175 = j.54 * 12;
            D.26176 = D.26173 + D.26175;
            lname = D.26176->name;
            <D.26181>:
            <D.26172>:
            if (lname != 0B) goto <D.26182>; else goto <D.26183>;
            <D.26182>:
            emit_string (w, lname);
            goto <D.26184>;
            <D.26183>:
            sprintf (&name_buf, "V_%d", i);
            emit_string (w, &name_buf);
            <D.26184>:
            if (ins == 0B) goto <D.26185>; else goto <D.26188>;
            <D.26188>:
            D.26189 = ins->flags;
            D.26190 = (int) D.26189;
            D.26191 = D.26190 & 2;
            if (D.26191 != 0) goto <D.26185>; else goto <D.26186>;
            <D.26185>:
            D.26141 = mono_defaults.int32_class;
            D.26142 = &D.26141->byval_arg;
            emit_var_type (w, D.26142);
            goto <D.26187>;
            <D.26186>:
            D.26091 = header->locals[i];
            emit_var_type (w, D.26091);
            <D.26187>:
            p = &buf;
            p.49 = p;
            encode_var_location (w, ins, p.49, &p);
            if (need_loclist != 0) goto <D.26192>; else goto <D.26193>;
            <D.26192>:
            D.26194 = vmv->live_range_end;
            if (D.26194 == 0) goto <D.26195>; else goto <D.26196>;
            <D.26195>:
            code_size.50 = (int) code_size;
            vmv->live_range_end = code_size.50;
            <D.26196>:
            D.26164 = vmv->live_range_start;
            D.26197 = (sizetype) D.26164;
            D.26198 = code + D.26197;
            D.26194 = vmv->live_range_end;
            D.26199 = (sizetype) D.26194;
            D.26200 = code + D.26199;
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.26155 = p.51 - buf.52;
            D.26156 = (unsigned int) D.26155;
            emit_loclist (w, ins, D.26198, D.26200, &buf, D.26156);
            goto <D.26201>;
            <D.26193>:
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.26155 = p.51 - buf.52;
            D.26158 = (unsigned char) D.26155;
            emit_byte (w, D.26158);
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.26155 = p.51 - buf.52;
            emit_bytes (w, &buf, D.26155);
            <D.26201>:
          }
        finally
          {
            name_buf = {CLOBBER};
          }
      }
      i = i + 1;
      <D.25584>:
      D.26092 = header->num_locals;
      D.26093 = (int) D.26092;
      if (D.26093 > i) goto <D.25583>; else goto <D.25585>;
      <D.25585>:
      if (locals_info != 0B) goto <D.26202>; else goto <D.26203>;
      <D.26202>:
      mono_debug_symfile_free_locals (locals_info);
      <D.26203>:
      emit_uleb128 (w, 0);
      emit_line (w);
      emit_debug_info_end (w);
      if (unwind_info != 0B) goto <D.26204>; else goto <D.26205>;
      <D.26204>:
      D.26206 = w->fde_index;
      emit_fde (w, D.26206, start_symbol, end_symbol, code, code_size, unwind_info, 1);
      D.26206 = w->fde_index;
      D.26207 = D.26206 + 1;
      w->fde_index = D.26207;
      <D.26205>:
      if (debug_info != 0B) goto <D.26208>; else goto <D.26209>;
      <D.26208>:
      D.26210 = debug_info->code_start;
      if (D.26210 == code) goto <D.26211>; else goto <D.26212>;
      <D.26211>:
      D.26213 = w->collect_line_info;
      if (D.26213 != 0) goto <D.26214>; else goto <D.26215>;
      <D.26214>:
      {
        struct MethodLineNumberInfo * info;

        info = monoeg_malloc0 (20);
        info->method = method;
        D.26216 = monoeg_strdup (start_symbol);
        info->start_symbol = D.26216;
        D.26217 = monoeg_strdup (end_symbol);
        info->end_symbol = D.26217;
        info->code = code;
        info->code_size = code_size;
        D.26218 = w->line_info;
        D.26219 = monoeg_g_slist_prepend (D.26218, info);
        w->line_info = D.26219;
      }
      goto <D.26220>;
      <D.26215>:
      emit_line_number_info (w, method, start_symbol, end_symbol, code, code_size, debug_info);
      <D.26220>:
      <D.26212>:
      <D.26209>:
      emit_line (w);
      mono_metadata_free_mh (header);
    }
  finally
    {
      buf = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_type (struct MonoDwarfWriter * w, struct MonoType * t)
{
  unsigned char D.26221;
  unsigned char D.26222;
  unsigned char D.26225;
  struct MonoClass * D.26231;
  int D.26232;
  int D.26233;
  unsigned int j.55;
  int D.26240;
  unsigned char D.26244;
  unsigned char D.26245;
  int D.26248;
  struct MonoClass * klass;
  int j;
  const char * tdie;

  klass = mono_class_from_mono_type (t);
  D.26221 = BIT_FIELD_REF <*t, 8, 56>;
  D.26222 = D.26221 & 64;
  if (D.26222 != 0) goto <D.26223>; else goto <D.26224>;
  <D.26223>:
  D.26225 = t->type;
  if (D.26225 == 17) goto <D.26226>; else goto <D.26227>;
  <D.26226>:
  tdie = emit_class_dwarf_info (w, klass, 1);
  if (tdie != 0B) goto <D.26228>; else goto <D.26229>;
  <D.26228>:
  return;
  <D.26229>:
  goto <D.26230>;
  <D.26227>:
  emit_class_dwarf_info (w, klass, 0);
  <D.26230>:
  D.26231 = mono_defaults.int_class;
  t = &D.26231->byval_arg;
  <D.26224>:
  j = 0;
  goto <D.25372>;
  <D.25371>:
  D.26232 = basic_types[j].type;
  D.26225 = t->type;
  D.26233 = (int) D.26225;
  if (D.26232 == D.26233) goto <D.25370>; else goto <D.26234>;
  <D.26234>:
  j = j + 1;
  <D.25372>:
  j.55 = (unsigned int) j;
  if (j.55 <= 16) goto <D.25371>; else goto <D.25370>;
  <D.25370>:
  j.55 = (unsigned int) j;
  if (j.55 <= 16) goto <D.26236>; else goto <D.26237>;
  <D.26236>:
  if (j <= 63) goto <D.26238>; else goto <D.26239>;
  <D.26238>:
  D.26240 = base_types_emitted[j];
  if (D.26240 == 0) goto <D.26241>; else goto <D.26242>;
  <D.26241>:
  emit_class_dwarf_info (w, klass, 0);
  base_types_emitted[j] = 1;
  <D.26242>:
  <D.26239>:
  goto <D.26243>;
  <D.26237>:
  D.26225 = t->type;
  D.26233 = (int) D.26225;
  switch (D.26233) <default: <D.25379>, case 15: <D.25378>, case 17: <D.25376>, case 18: <D.25373>, case 20: <D.25375>, case 21: <D.25377>>
  <D.25373>:
  emit_class_dwarf_info (w, klass, 0);
  goto <D.25374>;
  <D.25375>:
  goto <D.25374>;
  <D.25376>:
  D.26244 = BIT_FIELD_REF <*klass, 8, 160>;
  D.26245 = D.26244 & 16;
  if (D.26245 != 0) goto <D.26246>; else goto <D.26247>;
  <D.26246>:
  emit_class_dwarf_info (w, klass, 0);
  <D.26247>:
  goto <D.25374>;
  <D.25377>:
  D.26248 = mono_type_is_struct (t);
  if (D.26248 == 0) goto <D.26249>; else goto <D.26250>;
  <D.26249>:
  emit_class_dwarf_info (w, klass, 0);
  <D.26250>:
  goto <D.25374>;
  <D.25378>:
  goto <D.25374>;
  <D.25379>:
  goto <D.25374>;
  <D.25374>:
  <D.26243>:
}


emit_class_dwarf_info (struct MonoDwarfWriter * w, struct MonoClass * klass, gboolean vtype)
{
  char * D.26258;
  unsigned char D.26262;
  _Bool D.26263;
  _Bool D.26264;
  _Bool D.26265;
  unsigned char D.26268;
  unsigned char D.26271;
  unsigned char D.26272;
  unsigned char D.26276;
  const char * D.26280;
  const char * iftmp.56;
  const char * D.26285;
  char D.26286;
  int D.26289;
  int D.26290;
  struct GHashTable * D.26291;
  struct GHashTable * D.26292;
  struct MonoType * D.26295;
  struct MonoClass * D.26296;
  unsigned int size.57;
  int D.26298;
  struct MonoType * D.26299;
  unsigned char D.26300;
  int D.26301;
  unsigned int k.58;
  _Bool D.26304;
  long int D.26305;
  long int D.26306;
  const char * D.26309;
  int D.25309;
  int iftmp.59;
  int D.25305;
  const char[8] * D.26313;
  unsigned char D.26314;
  int D.26315;
  unsigned char D.26316;
  int D.26317;
  _Bool D.26318;
  _Bool D.26319;
  _Bool D.26320;
  const unsigned char * D.26323;
  unsigned char D.26324;
  int D.26325;
  const unsigned char * D.26326;
  unsigned char D.26327;
  int D.26328;
  _Bool D.26329;
  _Bool D.26330;
  const unsigned char * D.26333;
  unsigned char D.26334;
  int D.26335;
  const unsigned char * D.26336;
  unsigned char D.26337;
  int D.26338;
  _Bool D.26339;
  _Bool D.26340;
  const unsigned char * D.26343;
  unsigned char D.26344;
  int D.26345;
  const unsigned char * D.26346;
  unsigned char D.26347;
  int D.26348;
  const char * D.26350;
  struct MonoType * D.26353;
  short unsigned int D.26354;
  int D.26355;
  int D.26356;
  int D.25319;
  int iftmp.60;
  int D.25318;
  const char[9] * D.26362;
  unsigned char D.26363;
  int D.26364;
  unsigned char D.26365;
  int D.26366;
  _Bool D.26367;
  _Bool D.26368;
  _Bool D.26369;
  const unsigned char * D.26372;
  unsigned char D.26373;
  int D.26374;
  const unsigned char * D.26375;
  unsigned char D.26376;
  int D.26377;
  _Bool D.26378;
  _Bool D.26379;
  const unsigned char * D.26382;
  unsigned char D.26383;
  int D.26384;
  const unsigned char * D.26385;
  unsigned char D.26386;
  int D.26387;
  _Bool D.26388;
  _Bool D.26389;
  const unsigned char * D.26392;
  unsigned char D.26393;
  int D.26394;
  const unsigned char * D.26395;
  unsigned char D.26396;
  int D.26397;
  const char * D.26399;
  const char * D.26402;
  const char * p.61;
  const char * p.62;
  unsigned int D.26405;
  struct MonoType * D.26406;
  unsigned char D.26407;
  int D.26408;
  char D.26409;
  long long int D.26410;
  short unsigned int D.26411;
  long long int D.26412;
  unsigned int D.26413;
  long long int D.26414;
  long long unsigned int D.26415;
  long long int D.26416;
  unsigned int D.26417;
  long long int D.26418;
  struct MonoClass * D.26420;
  int D.26424;
  int iftmp.63;
  struct MonoClassField * D.26432;
  guint32 iftmp.64;
  int D.26437;
  unsigned int D.26438;
  guint8 * p.65;
  guint8 * p.66;
  guint8 * p.67;
  int p.68;
  int buf.69;
  int D.26446;
  unsigned char D.26447;
  const char * D.26452;
  guint8 * p.70;
  guint8 * p.71;
  unsigned char D.26457;
  int D.26460;
  unsigned int D.26461;
  unsigned int D.26462;
  unsigned int D.26463;
  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.26253>; else goto <D.26254>;
      <D.26253>:
      cache = w->class_to_vtype_die;
      goto <D.26255>;
      <D.26254>:
      cache = w->class_to_die;
      <D.26255>:
      die = monoeg_g_hash_table_lookup (cache, klass);
      if (die != 0B) goto <D.26256>; else goto <D.26257>;
      <D.26256>:
      D.26258 = die;
      return D.26258;
      <D.26257>:
      D.26262 = klass->byval_arg.type;
      D.26263 = D.26262 != 18;
      D.26264 = D.26262 != 28;
      D.26265 = D.26263 & D.26264;
      if (D.26265 != 0) goto <D.26266>; else goto <D.26267>;
      <D.26266>:
      D.26268 = klass->byval_arg.type;
      if (D.26268 != 21) goto <D.26269>; else goto <D.26270>;
      <D.26269>:
      D.26271 = BIT_FIELD_REF <*klass, 8, 160>;
      D.26272 = D.26271 & 16;
      if (D.26272 == 0) goto <D.26273>; else goto <D.26274>;
      <D.26273>:
      D.26268 = klass->byval_arg.type;
      if (D.26268 != 17) goto <D.26261>; else goto <D.26275>;
      <D.26275>:
      if (vtype == 0) goto <D.26261>; else goto <D.26260>;
      <D.26261>:
      D.26268 = klass->byval_arg.type;
      D.26276 = D.26268 + 254;
      if (D.26276 > 11) goto <D.26259>; else goto <D.26277>;
      <D.26277>:
      if (vtype != 0) goto <D.26259>; else goto <D.26260>;
      <D.26259>:
      D.26258 = 0B;
      return D.26258;
      <D.26260>:
      <D.26274>:
      <D.26270>:
      <D.26267>:
      if (emit_namespace != 0) goto <D.26278>; else goto <D.26279>;
      <D.26278>:
      emit_uleb128 (w, 10);
      D.26280 = klass->name_space;
      emit_string (w, D.26280);
      <D.26279>:
      D.26280 = klass->name_space;
      D.26280 = klass->name_space;
      if (D.26280 != 0B) goto <D.26282>; else goto <D.26283>;
      <D.26282>:
      iftmp.56 = ".";
      goto <D.26284>;
      <D.26283>:
      iftmp.56 = "";
      <D.26284>:
      D.26285 = klass->name;
      full_name = monoeg_g_strdup_printf ("%s%s%s", D.26280, iftmp.56, D.26285);
      p = full_name;
      goto <D.25292>;
      <D.25291>:
      D.26286 = *p;
      if (D.26286 == 46) goto <D.26287>; else goto <D.26288>;
      <D.26287>:
      *p = 95;
      <D.26288>:
      p = p + 1;
      <D.25292>:
      D.26286 = *p;
      if (D.26286 != 0) goto <D.25291>; else goto <D.25293>;
      <D.25293>:
      D.26289 = w->tdie_index;
      die = monoeg_g_strdup_printf (".LTDIE_%d", D.26289);
      D.26289 = w->tdie_index;
      pointer_die = monoeg_g_strdup_printf (".LTDIE_%d_POINTER", D.26289);
      D.26289 = w->tdie_index;
      reference_die = monoeg_g_strdup_printf (".LTDIE_%d_REFERENCE", D.26289);
      D.26289 = w->tdie_index;
      D.26290 = D.26289 + 1;
      w->tdie_index = D.26290;
      D.26291 = w->class_to_pointer_die;
      monoeg_g_hash_table_insert_replace (D.26291, klass, pointer_die, 0);
      D.26292 = w->class_to_reference_die;
      monoeg_g_hash_table_insert_replace (D.26292, klass, reference_die, 0);
      monoeg_g_hash_table_insert_replace (cache, klass, die, 0);
      D.26271 = BIT_FIELD_REF <*klass, 8, 160>;
      D.26272 = D.26271 & 16;
      if (D.26272 != 0) goto <D.26293>; else goto <D.26294>;
      <D.26293>:
      {
        int size;

        D.26295 = mono_class_enum_basetype (klass);
        D.26296 = mono_class_from_mono_type (D.26295);
        size = mono_class_value_size (D.26296, 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.25297>;
        <D.25296>:
        D.26298 = basic_types[k].type;
        D.26299 = mono_class_enum_basetype (klass);
        D.26300 = D.26299->type;
        D.26301 = (int) D.26300;
        if (D.26298 == D.26301) goto <D.25295>; else goto <D.26302>;
        <D.26302>:
        k = k + 1;
        <D.25297>:
        k.58 = (unsigned int) k;
        if (k.58 <= 16) goto <D.25296>; else goto <D.25295>;
        <D.25295>:
        k.58 = (unsigned int) k;
        D.26304 = k.58 > 16;
        D.26305 = (long int) D.26304;
        D.26306 = __builtin_expect (D.26305, 0);
        if (D.26306 != 0) goto <D.26307>; else goto <D.26308>;
        <D.26307>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1055, "k < G_N_ELEMENTS (basic_types)");
        <D.26308>:
        D.26309 = basic_types[k].die_name;
        emit_symbol_diff (w, D.26309, ".Ldebug_info_start", 0);
        iter = 0B;
        goto <D.25310>;
        <D.25334>:
        {
          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.26311>; else goto <D.26312>;
                <D.26311>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = mono_field_get_name (field);
                  D.26313 = "value__";
                  D.26314 = MEM[(const unsigned char *)D.26313];
                  D.26315 = (int) D.26314;
                  D.26316 = *__s2;
                  D.26317 = (int) D.26316;
                  __result = D.26315 - D.26317;
                  {
                    D.26318 = __s1_len != 0;
                    D.26319 = __result == 0;
                    D.26320 = D.26318 & D.26319;
                    if (D.26320 != 0) goto <D.26321>; else goto <D.26322>;
                    <D.26321>:
                    D.26323 = &MEM[(void *)"value__" + 1B];
                    D.26324 = *D.26323;
                    D.26325 = (int) D.26324;
                    D.26326 = __s2 + 1;
                    D.26327 = *D.26326;
                    D.26328 = (int) D.26327;
                    __result = D.26325 - D.26328;
                    D.26329 = __s1_len > 1;
                    D.26319 = __result == 0;
                    D.26330 = D.26329 & D.26319;
                    if (D.26330 != 0) goto <D.26331>; else goto <D.26332>;
                    <D.26331>:
                    D.26333 = &MEM[(void *)"value__" + 2B];
                    D.26334 = *D.26333;
                    D.26335 = (int) D.26334;
                    D.26336 = __s2 + 2;
                    D.26337 = *D.26336;
                    D.26338 = (int) D.26337;
                    __result = D.26335 - D.26338;
                    D.26339 = __s1_len > 2;
                    D.26319 = __result == 0;
                    D.26340 = D.26339 & D.26319;
                    if (D.26340 != 0) goto <D.26341>; else goto <D.26342>;
                    <D.26341>:
                    D.26343 = &MEM[(void *)"value__" + 3B];
                    D.26344 = *D.26343;
                    D.26345 = (int) D.26344;
                    D.26346 = __s2 + 3;
                    D.26347 = *D.26346;
                    D.26348 = (int) D.26347;
                    __result = D.26345 - D.26348;
                    <D.26342>:
                    <D.26332>:
                    <D.26322>:
                  }
                  D.25305 = __result;
                }
                iftmp.59 = D.25305;
                goto <D.26349>;
                <D.26312>:
                D.26350 = mono_field_get_name (field);
                iftmp.59 = __builtin_strcmp ("value__", D.26350);
                <D.26349>:
                D.25309 = iftmp.59;
              }
              if (D.25309 == 0) goto <D.26351>; else goto <D.26352>;
              <D.26351>:
              // predicted unlikely by continue predictor.
              goto <D.25310>;
              <D.26352>:
              D.26353 = field->type;
              D.26354 = D.26353->attrs;
              D.26355 = (int) D.26354;
              D.26356 = D.26355 & 1536;
              if (D.26356 != 0) goto <D.26357>; else goto <D.26358>;
              <D.26357>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = mono_field_get_name (field);
                  D.26362 = "_Deleted";
                  D.26363 = MEM[(const unsigned char *)D.26362];
                  D.26364 = (int) D.26363;
                  D.26365 = *__s2;
                  D.26366 = (int) D.26365;
                  __result = D.26364 - D.26366;
                  {
                    D.26367 = __s2_len != 0;
                    D.26368 = __result == 0;
                    D.26369 = D.26367 & D.26368;
                    if (D.26369 != 0) goto <D.26370>; else goto <D.26371>;
                    <D.26370>:
                    D.26372 = &MEM[(void *)"_Deleted" + 1B];
                    D.26373 = *D.26372;
                    D.26374 = (int) D.26373;
                    D.26375 = __s2 + 1;
                    D.26376 = *D.26375;
                    D.26377 = (int) D.26376;
                    __result = D.26374 - D.26377;
                    D.26378 = __s2_len > 1;
                    D.26368 = __result == 0;
                    D.26379 = D.26378 & D.26368;
                    if (D.26379 != 0) goto <D.26380>; else goto <D.26381>;
                    <D.26380>:
                    D.26382 = &MEM[(void *)"_Deleted" + 2B];
                    D.26383 = *D.26382;
                    D.26384 = (int) D.26383;
                    D.26385 = __s2 + 2;
                    D.26386 = *D.26385;
                    D.26387 = (int) D.26386;
                    __result = D.26384 - D.26387;
                    D.26388 = __s2_len > 2;
                    D.26368 = __result == 0;
                    D.26389 = D.26388 & D.26368;
                    if (D.26389 != 0) goto <D.26390>; else goto <D.26391>;
                    <D.26390>:
                    D.26392 = &MEM[(void *)"_Deleted" + 3B];
                    D.26393 = *D.26392;
                    D.26394 = (int) D.26393;
                    D.26395 = __s2 + 3;
                    D.26396 = *D.26395;
                    D.26397 = (int) D.26396;
                    __result = D.26394 - D.26397;
                    <D.26391>:
                    <D.26381>:
                    <D.26371>:
                  }
                  D.25318 = __result;
                }
                iftmp.60 = -D.25318;
                goto <D.26398>;
                <D.26361>:
                D.26399 = mono_field_get_name (field);
                iftmp.60 = __builtin_strcmp (D.26399, "_Deleted");
                <D.26398>:
                D.25319 = iftmp.60;
              }
              if (D.25319 == 0) goto <D.26400>; else goto <D.26401>;
              <D.26400>:
              // predicted unlikely by continue predictor.
              goto <D.25310>;
              <D.26401>:
              <D.26358>:
              emit_uleb128 (w, 9);
              D.26402 = mono_field_get_name (field);
              emit_string (w, D.26402);
              p.61 = mono_class_get_field_default_value (field, &def_type);
              p = p.61;
              p.62 = p;
              D.26405 = mono_metadata_decode_blob_size (p.62, &p);
              len = (int) D.26405;
              D.26406 = mono_class_enum_basetype (klass);
              D.26407 = D.26406->type;
              D.26408 = (int) D.26407;
              switch (D.26408) <default: <D.25333>, case 2: <D.25322>, case 3: <D.25326>, case 4: <D.25321>, case 5: <D.25320>, case 6: <D.25325>, case 7: <D.25324>, case 8: <D.25328>, case 9: <D.25327>, case 10: <D.25330>, case 11: <D.25329>, case 24: <D.25331>, case 25: <D.25332>>
              <D.25320>:
              <D.25321>:
              <D.25322>:
              p.62 = p;
              D.26409 = *p.62;
              D.26410 = (long long int) D.26409;
              emit_sleb128 (w, D.26410);
              goto <D.25323>;
              <D.25324>:
              <D.25325>:
              <D.25326>:
              p.62 = p;
              D.26411 = mono_read16 (p.62);
              D.26412 = (long long int) D.26411;
              emit_sleb128 (w, D.26412);
              goto <D.25323>;
              <D.25327>:
              <D.25328>:
              p.62 = p;
              D.26413 = mono_read32 (p.62);
              D.26414 = (long long int) D.26413;
              emit_sleb128 (w, D.26414);
              goto <D.25323>;
              <D.25329>:
              <D.25330>:
              p.62 = p;
              D.26415 = mono_read64 (p.62);
              D.26416 = (long long int) D.26415;
              emit_sleb128 (w, D.26416);
              goto <D.25323>;
              <D.25331>:
              <D.25332>:
              p.62 = p;
              D.26417 = mono_read32 (p.62);
              D.26418 = (long long int) D.26417;
              emit_sleb128 (w, D.26418);
              goto <D.25323>;
              <D.25333>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "dwarfwriter.c", 1103);
              <D.25323>:
            }
          finally
            {
              p = {CLOBBER};
              def_type = {CLOBBER};
            }
        }
        <D.25310>:
        field = mono_class_get_fields (klass, &iter);
        if (field != 0B) goto <D.25334>; else goto <D.25335>;
        <D.25335>:
        has_children = 1;
      }
      goto <D.26419>;
      <D.26294>:
      {
        guint8 buf[128];
        guint8 * p;
        char * parent_die;

        try
          {
            D.26420 = klass->parent;
            if (D.26420 != 0B) goto <D.26421>; else goto <D.26422>;
            <D.26421>:
            D.26420 = klass->parent;
            parent_die = emit_class_dwarf_info (w, D.26420, 0);
            goto <D.26423>;
            <D.26422>:
            parent_die = 0B;
            <D.26423>:
            iter = 0B;
            goto <D.25339>;
            <D.25340>:
            D.26353 = field->type;
            D.26354 = D.26353->attrs;
            D.26355 = (int) D.26354;
            D.26424 = D.26355 & 16;
            if (D.26424 != 0) goto <D.26425>; else goto <D.26426>;
            <D.26425>:
            // predicted unlikely by continue predictor.
            goto <D.25339>;
            <D.26426>:
            D.26353 = field->type;
            emit_type (w, D.26353);
            <D.25339>:
            field = mono_class_get_fields (klass, &iter);
            if (field != 0B) goto <D.25340>; else goto <D.25341>;
            <D.25341>:
            iter = 0B;
            if (parent_die != 0B) goto <D.26428>; else goto <D.26431>;
            <D.26431>:
            D.26432 = mono_class_get_fields (klass, &iter);
            if (D.26432 != 0B) goto <D.26428>; else goto <D.26429>;
            <D.26428>:
            iftmp.63 = 1;
            goto <D.26430>;
            <D.26429>:
            iftmp.63 = 0;
            <D.26430>:
            has_children = iftmp.63;
            emit_label (w, die);
            if (has_children != 0) goto <D.26434>; else goto <D.26435>;
            <D.26434>:
            iftmp.64 = 5;
            goto <D.26436>;
            <D.26435>:
            iftmp.64 = 17;
            <D.26436>:
            emit_uleb128 (w, iftmp.64);
            emit_string (w, full_name);
            D.26437 = klass->instance_size;
            D.26438 = (unsigned int) D.26437;
            emit_uleb128 (w, D.26438);
            if (parent_die != 0B) goto <D.26439>; else goto <D.26440>;
            <D.26439>:
            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.26446 = p.68 - buf.69;
            D.26447 = (unsigned char) D.26446;
            emit_byte (w, D.26447);
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.26446 = p.68 - buf.69;
            emit_bytes (w, &buf, D.26446);
            <D.26440>:
            iter = 0B;
            goto <D.25342>;
            <D.25343>:
            D.26353 = field->type;
            D.26354 = D.26353->attrs;
            D.26355 = (int) D.26354;
            D.26424 = D.26355 & 16;
            if (D.26424 != 0) goto <D.26448>; else goto <D.26449>;
            <D.26448>:
            // predicted unlikely by continue predictor.
            goto <D.25342>;
            <D.26449>:
            D.26353 = field->type;
            fdie = get_type_die (w, D.26353);
            if (fdie != 0B) goto <D.26450>; else goto <D.26451>;
            <D.26450>:
            emit_uleb128 (w, 6);
            D.26452 = field->name;
            emit_string (w, D.26452);
            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.26271 = BIT_FIELD_REF <*klass, 8, 160>;
            D.26457 = D.26271 & 8;
            if (D.26457 != 0) goto <D.26458>; else goto <D.26455>;
            <D.26458>:
            if (vtype != 0) goto <D.26459>; else goto <D.26455>;
            <D.26459>:
            D.26460 = field->offset;
            D.26461 = (unsigned int) D.26460;
            D.26462 = D.26461 + 4294967288;
            p.65 = p;
            encode_uleb128 (D.26462, p.65, &p);
            goto <D.26456>;
            <D.26455>:
            D.26460 = field->offset;
            D.26463 = (unsigned int) D.26460;
            p.65 = p;
            encode_uleb128 (D.26463, p.65, &p);
            <D.26456>:
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.26446 = p.68 - buf.69;
            D.26447 = (unsigned char) D.26446;
            emit_byte (w, D.26447);
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.26446 = p.68 - buf.69;
            emit_bytes (w, &buf, D.26446);
            <D.26451>:
            <D.25342>:
            field = mono_class_get_fields (klass, &iter);
            if (field != 0B) goto <D.25343>; else goto <D.25344>;
            <D.25344>:
          }
        finally
          {
            buf = {CLOBBER};
            p = {CLOBBER};
          }
      }
      <D.26419>:
      if (has_children != 0) goto <D.26464>; else goto <D.26465>;
      <D.26464>:
      emit_uleb128 (w, 0);
      <D.26465>:
      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.26466>; else goto <D.26467>;
      <D.26466>:
      emit_uleb128 (w, 0);
      <D.26467>:
      D.26258 = die;
      return D.26258;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_type_die (struct MonoDwarfWriter * w, struct MonoType * t)
{
  unsigned char D.26472;
  unsigned char D.26473;
  unsigned char D.26476;
  struct GHashTable * D.26479;
  struct MonoClass * D.26481;
  int D.26482;
  int D.26483;
  unsigned int j.72;
  struct GHashTable * D.26489;
  unsigned char D.26490;
  unsigned char D.26491;
  int D.26495;
  _Bool D.26499;
  long int D.26500;
  long int D.26501;
  const char * D.26504;
  struct MonoClass * klass;
  int j;
  const char * tdie;

  klass = mono_class_from_mono_type (t);
  D.26472 = BIT_FIELD_REF <*t, 8, 56>;
  D.26473 = D.26472 & 64;
  if (D.26473 != 0) goto <D.26474>; else goto <D.26475>;
  <D.26474>:
  D.26476 = t->type;
  if (D.26476 == 17) goto <D.26477>; else goto <D.26478>;
  <D.26477>:
  D.26479 = w->class_to_pointer_die;
  tdie = monoeg_g_hash_table_lookup (D.26479, klass);
  goto <D.26480>;
  <D.26478>:
  tdie = get_class_die (w, klass, 0);
  <D.26480>:
  D.26481 = mono_defaults.int_class;
  t = &D.26481->byval_arg;
  <D.26475>:
  j = 0;
  goto <D.25355>;
  <D.25354>:
  D.26482 = basic_types[j].type;
  D.26476 = t->type;
  D.26483 = (int) D.26476;
  if (D.26482 == D.26483) goto <D.25353>; else goto <D.26484>;
  <D.26484>:
  j = j + 1;
  <D.25355>:
  j.72 = (unsigned int) j;
  if (j.72 <= 16) goto <D.25354>; else goto <D.25353>;
  <D.25353>:
  j.72 = (unsigned int) j;
  if (j.72 <= 16) goto <D.26486>; else goto <D.26487>;
  <D.26486>:
  tdie = basic_types[j].die_name;
  goto <D.26488>;
  <D.26487>:
  D.26476 = t->type;
  D.26483 = (int) D.26476;
  switch (D.26483) <default: <D.25362>, case 15: <D.25361>, case 17: <D.25359>, case 18: <D.25356>, case 20: <D.25358>, case 21: <D.25360>>
  <D.25356>:
  D.26489 = w->class_to_reference_die;
  tdie = monoeg_g_hash_table_lookup (D.26489, klass);
  goto <D.25357>;
  <D.25358>:
  tdie = ".LDIE_OBJECT";
  goto <D.25357>;
  <D.25359>:
  D.26490 = BIT_FIELD_REF <*klass, 8, 160>;
  D.26491 = D.26490 & 16;
  if (D.26491 != 0) goto <D.26492>; else goto <D.26493>;
  <D.26492>:
  tdie = get_class_die (w, klass, 0);
  goto <D.26494>;
  <D.26493>:
  tdie = ".LDIE_I4";
  <D.26494>:
  goto <D.25357>;
  <D.25360>:
  D.26495 = mono_type_is_struct (t);
  if (D.26495 == 0) goto <D.26496>; else goto <D.26497>;
  <D.26496>:
  D.26489 = w->class_to_reference_die;
  tdie = monoeg_g_hash_table_lookup (D.26489, klass);
  goto <D.26498>;
  <D.26497>:
  tdie = ".LDIE_I4";
  <D.26498>:
  goto <D.25357>;
  <D.25361>:
  tdie = ".LDIE_I";
  goto <D.25357>;
  <D.25362>:
  tdie = ".LDIE_I4";
  goto <D.25357>;
  <D.25357>:
  <D.26488>:
  D.26499 = tdie == 0B;
  D.26500 = (long int) D.26499;
  D.26501 = __builtin_expect (D.26500, 0);
  if (D.26501 != 0) goto <D.26502>; else goto <D.26503>;
  <D.26502>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1259, "tdie");
  <D.26503>:
  D.26504 = tdie;
  return D.26504;
}


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

  if (vtype != 0) goto <D.26506>; else goto <D.26507>;
  <D.26506>:
  cache = w->class_to_vtype_die;
  goto <D.26508>;
  <D.26507>:
  cache = w->class_to_die;
  <D.26508>:
  D.26509 = monoeg_g_hash_table_lookup (cache, klass);
  return D.26509;
}


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

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

    D.26511 = (unsigned char) value;
    b = D.26511 & 127;
    value = value >> 7;
    if (value != 0) goto <D.26512>; else goto <D.26513>;
    <D.26512>:
    b = b | 128;
    <D.26513>:
    p.73 = p;
    p = p.73 + 1;
    *p.73 = b;
  }
  if (value != 0) goto <D.25088>; else goto <D.25089>;
  <D.25089>:
  *endbuf = p;
}


find_vmv (struct MonoCompile * cfg, struct MonoInst * ins)
{
  struct MonoInst * * D.26515;
  unsigned int j.74;
  unsigned int D.26519;
  struct MonoInst * * D.26520;
  struct MonoInst * D.26521;
  unsigned int j.75;
  unsigned int D.26524;
  struct MonoMethodVar * D.26527;
  struct MonoMethodVar * D.26528;
  unsigned int D.26529;
  int j;

  D.26515 = cfg->varinfo;
  if (D.26515 != 0B) goto <D.26516>; else goto <D.26517>;
  <D.26516>:
  j = 0;
  goto <D.25536>;
  <D.25535>:
  D.26515 = cfg->varinfo;
  j.74 = (unsigned int) j;
  D.26519 = j.74 * 4;
  D.26520 = D.26515 + D.26519;
  D.26521 = *D.26520;
  if (D.26521 == ins) goto <D.25534>; else goto <D.26522>;
  <D.26522>:
  j = j + 1;
  <D.25536>:
  j.75 = (unsigned int) j;
  D.26524 = cfg->num_varinfo;
  if (j.75 < D.26524) goto <D.25535>; else goto <D.25534>;
  <D.25534>:
  j.75 = (unsigned int) j;
  D.26524 = cfg->num_varinfo;
  if (j.75 < D.26524) goto <D.26525>; else goto <D.26526>;
  <D.26525>:
  D.26528 = cfg->vars;
  j.74 = (unsigned int) j;
  D.26529 = j.74 * 56;
  D.26527 = D.26528 + D.26529;
  return D.26527;
  <D.26526>:
  <D.26517>:
  D.26527 = 0B;
  return D.26527;
}


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

  D.26532 = __builtin_object_size (__s, 1);
  D.26531 = __builtin___sprintf_chk (__s, 1, D.26532, __fmt, __builtin_va_arg_pack ());
  return D.26531;
}


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.26536;
  int D.26537;
  int D.26538;
  short unsigned int D.26542;
  guint8 * p.76;
  int D.26546;
  int D.26547;
  unsigned char D.26548;
  unsigned char D.26549;
  guint8 * p.77;
  guint8 * p.78;
  guint8 * p.79;
  int D.26556;
  int D.26557;
  unsigned char D.26558;
  unsigned char D.26559;
  int D.26560;
  guint8 * p.80;
  guint8 * p.81;

  if (ins == 0B) goto <D.26534>; else goto <D.26535>;
  <D.26535>:
  D.26536 = ins->flags;
  D.26537 = (int) D.26536;
  D.26538 = D.26537 & 2;
  if (D.26538 != 0) goto <D.26539>; else goto <D.26540>;
  <D.26539>:
  goto <D.26541>;
  <D.26540>:
  D.26542 = ins->opcode;
  if (D.26542 == 366) goto <D.26543>; else goto <D.26544>;
  <D.26543>:
  p.76 = p;
  D.26546 = ins->dreg;
  D.26547 = mono_hw_reg_to_dwarf_reg (D.26546);
  D.26548 = (unsigned char) D.26547;
  D.26549 = D.26548 + 80;
  *p.76 = D.26549;
  p.76 = p;
  p.77 = p.76 + 1;
  p = p.77;
  goto <D.26551>;
  <D.26544>:
  D.26542 = ins->opcode;
  if (D.26542 == 367) goto <D.26552>; else goto <D.26553>;
  <D.26552>:
  p.76 = p;
  p.78 = p.76;
  p.79 = p.78 + 1;
  p = p.79;
  D.26556 = ins->sreg1;
  D.26557 = mono_hw_reg_to_dwarf_reg (D.26556);
  D.26558 = (unsigned char) D.26557;
  D.26559 = D.26558 + 112;
  *p.78 = D.26559;
  D.26560 = ins->data.op[0].const_val;
  p.76 = p;
  encode_sleb128 (D.26560, p.76, &p);
  goto <D.26561>;
  <D.26553>:
  p.76 = p;
  p.80 = p.76;
  p.81 = p.80 + 1;
  p = p.81;
  *p.80 = 80;
  <D.26561>:
  <D.26551>:
  <D.26541>:
  <D.26534>:
  p.76 = p;
  *endp = p.76;
}


encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  _Bool D.26564;
  unsigned char D.26565;
  unsigned int D.26568;
  int D.26569;
  int D.26570;
  int D.26571;
  int D.26577;
  int D.26578;
  guint8 * p.82;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;
  guint8 * p;

  more = 1;
  D.26564 = value < 0;
  negative = (gboolean) D.26564;
  size = 32;
  p = buf;
  goto <D.25101>;
  <D.25100>:
  D.26565 = (unsigned char) value;
  byte = D.26565 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.26566>; else goto <D.26567>;
  <D.26566>:
  D.26568 = size + 4294967289;
  D.26569 = (int) D.26568;
  D.26570 = 1 << D.26569;
  D.26571 = -D.26570;
  value = D.26571 | value;
  <D.26567>:
  if (value == 0) goto <D.26576>; else goto <D.26572>;
  <D.26576>:
  D.26577 = (int) byte;
  D.26578 = D.26577 & 64;
  if (D.26578 == 0) goto <D.26573>; else goto <D.26572>;
  <D.26572>:
  if (value == -1) goto <D.26579>; else goto <D.26574>;
  <D.26579>:
  D.26577 = (int) byte;
  D.26578 = D.26577 & 64;
  if (D.26578 != 0) goto <D.26573>; else goto <D.26574>;
  <D.26573>:
  more = 0;
  goto <D.26575>;
  <D.26574>:
  byte = byte | 128;
  <D.26575>:
  p.82 = p;
  p = p.82 + 1;
  *p.82 = byte;
  <D.25101>:
  if (more != 0) goto <D.25100>; else goto <D.25102>;
  <D.25102>:
  *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.26581;
  int D.26582;
  int D.26583;
  unsigned char D.26584;
  unsigned int D.26585;
  unsigned char D.26586;
  int expr_len.83;
  char label[128];

  try
    {
      emit_push_section (w, ".debug_loc", 0);
      D.26581 = w->loclist_index;
      D.26582 = D.26581;
      D.26583 = D.26582 + 1;
      w->loclist_index = D.26583;
      sprintf (&label, ".Lloclist_%d", D.26582);
      emit_label (w, &label);
      emit_pointer_value (w, loclist_begin_addr);
      emit_pointer_value (w, loclist_end_addr);
      D.26584 = (unsigned char) expr_len;
      emit_byte (w, D.26584);
      D.26585 = expr_len / 256;
      D.26586 = (unsigned char) D.26585;
      emit_byte (w, D.26586);
      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.26588;

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


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

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


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.26595;
  long int D.26596;
  long int D.26597;
  int code_size.84;
  struct GSList * D.26602;
  unsigned int i.85;
  unsigned int D.26608;
  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.26590>; else goto <D.26591>;
      <D.26590>:
      emit_pointer (w, start_symbol);
      if (end_symbol != 0B) goto <D.26592>; else goto <D.26593>;
      <D.26592>:
      emit_symbol_diff (w, end_symbol, start_symbol, 0);
      goto <D.26594>;
      <D.26593>:
      D.26595 = code_size == 0;
      D.26596 = (long int) D.26595;
      D.26597 = __builtin_expect (D.26596, 0);
      if (D.26597 != 0) goto <D.26598>; else goto <D.26599>;
      <D.26598>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 395, "code_size");
      <D.26599>:
      code_size.84 = (int) code_size;
      emit_int32 (w, code_size.84);
      <D.26594>:
      goto <D.26601>;
      <D.26591>:
      emit_pointer_value (w, code);
      code_size.84 = (int) code_size;
      emit_int32 (w, code_size.84);
      <D.26601>:
      l = unwind_ops;
      D.26602 = w->cie_program;
      if (D.26602 != 0B) goto <D.26603>; else goto <D.26604>;
      <D.26603>:
      {
        int i;

        i = 0;
        goto <D.25142>;
        <D.25141>:
        if (l != 0B) goto <D.26605>; else goto <D.26606>;
        <D.26605>:
        l = l->next;
        <D.26606>:
        i = i + 1;
        <D.25142>:
        i.85 = (unsigned int) i;
        D.26602 = w->cie_program;
        D.26608 = monoeg_g_slist_length (D.26602);
        if (i.85 < D.26608) goto <D.25141>; else goto <D.25143>;
        <D.25143>:
      }
      <D.26604>:
      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.26611;

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


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

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


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.26613;
  int D.26614;
  int D.26615;

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