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.23081;
  int D.23082;
  _Bool D.23083;
  long int D.23084;
  long int D.23085;
  int D.23090;
  struct FILE * D.23096;
  const char * D.23097;
  struct GHashTable * D.23098;
  struct GHashTable * D.23099;
  struct GHashTable * D.23100;
  struct GHashTable * D.23101;
  struct MonoDwarfWriter * D.23102;
  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.23079>; else goto <D.23080>;
  <D.23079>:
  D.23081 = w->w;
  D.23082 = img_writer_subsections_supported (D.23081);
  D.23083 = D.23082 == 0;
  D.23084 = (long int) D.23083;
  D.23085 = __builtin_expect (D.23084, 0);
  if (D.23085 != 0) goto <D.23086>; else goto <D.23087>;
  <D.23086>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 94, "img_writer_subsections_supported (w->w)");
  <D.23087>:
  <D.23080>:
  w->emit_line = 1;
  if (appending != 0) goto <D.23088>; else goto <D.23089>;
  <D.23088>:
  D.23081 = w->w;
  D.23090 = img_writer_subsections_supported (D.23081);
  if (D.23090 == 0) goto <D.23091>; else goto <D.23092>;
  <D.23091>:
  w->emit_line = 0;
  <D.23092>:
  goto <D.23093>;
  <D.23089>:
  w->collect_line_info = 1;
  <D.23093>:
  if (emit_line_numbers == 0) goto <D.23094>; else goto <D.23095>;
  <D.23094>:
  w->emit_line = 0;
  w->collect_line_info = 0;
  <D.23095>:
  D.23081 = w->w;
  D.23096 = img_writer_get_fp (D.23081);
  w->fp = D.23096;
  D.23081 = w->w;
  D.23097 = img_writer_get_temp_label_prefix (D.23081);
  w->temp_prefix = D.23097;
  D.23098 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_die = D.23098;
  D.23099 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_vtype_die = D.23099;
  D.23100 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_pointer_die = D.23100;
  D.23101 = monoeg_g_hash_table_new (0B, 0B);
  w->class_to_reference_die = D.23101;
  w->cur_file_index = -1;
  D.23102 = w;
  return D.23102;
}


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


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

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


mono_dwarf_escape_path (const char * name)
{
  char * D.23106;
  unsigned int D.23109;
  int D.23110;
  int D.23111;
  unsigned int D.23112;
  sizetype i.0;
  const char * D.23114;
  char D.23115;
  int j.1;
  sizetype j.2;
  char * D.23120;
  int j.3;
  sizetype j.4;
  char * D.23123;
  int j.5;
  sizetype j.6;
  char * D.23127;
  char * D.23128;

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

    D.23109 = strlen (name);
    len = (int) D.23109;
    D.23110 = len + 1;
    D.23111 = D.23110 * 2;
    D.23112 = (unsigned int) D.23111;
    s = monoeg_malloc0 (D.23112);
    j = 0;
    i = 0;
    goto <D.22682>;
    <D.22681>:
    i.0 = (sizetype) i;
    D.23114 = name + i.0;
    D.23115 = *D.23114;
    if (D.23115 == 92) goto <D.23116>; else goto <D.23117>;
    <D.23116>:
    j.1 = j;
    j = j.1 + 1;
    j.2 = (sizetype) j.1;
    D.23120 = s + j.2;
    *D.23120 = 92;
    j.3 = j;
    j = j.3 + 1;
    j.4 = (sizetype) j.3;
    D.23123 = s + j.4;
    *D.23123 = 92;
    goto <D.23124>;
    <D.23117>:
    j.5 = j;
    j = j.5 + 1;
    j.6 = (sizetype) j.5;
    D.23127 = s + j.6;
    i.0 = (sizetype) i;
    D.23114 = name + i.0;
    D.23115 = *D.23114;
    *D.23127 = D.23115;
    <D.23124>:
    i = i + 1;
    <D.22682>:
    if (i < len) goto <D.22681>; else goto <D.22683>;
    <D.22683>:
    D.23128 = s;
    return D.23128;
  }
  <D.23108>:
  D.23128 = monoeg_strdup (name);
  return D.23128;
}


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

  if (str != 0B) goto <D.23130>; else goto <D.23131>;
  <D.23130>:
  D.23132 = __strdup (str);
  return D.23132;
  <D.23131>:
  D.23132 = 0B;
  return D.23132;
}


mono_dwarf_writer_emit_base_info (struct MonoDwarfWriter * w, const char * cu_name, struct GSList * base_unwind_program)
{
  struct MonoImageWriter * D.23134;
  int D.23135;
  int D.23138;
  int D.23141;
  const char * D.23145;
  int D.23146;
  unsigned char D.23147;
  int D.23148;
  int D.23149;
  unsigned char D.23150;
  int D.23151;
  const char * D.23152;
  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.23134 = w->w;
  D.23135 = img_writer_subsections_supported (D.23134);
  if (D.23135 != 0) goto <D.23136>; else goto <D.23137>;
  <D.23136>:
  D.23138 = w->appending;
  if (D.23138 != 0) goto <D.23139>; else goto <D.23140>;
  <D.23139>:
  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.23140>:
  <D.23137>:
  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.23141 = w->emit_line;
  if (D.23141 != 0) goto <D.23142>; else goto <D.23143>;
  <D.23142>:
  emit_symbol_diff (w, ".Ldebug_line_start", ".Ldebug_line_section_start", 0);
  goto <D.23144>;
  <D.23143>:
  emit_pointer_value (w, 0B);
  <D.23144>:
  i = 0;
  goto <D.22739>;
  <D.22738>:
  D.23145 = basic_types[i].die_name;
  emit_label (w, D.23145);
  emit_uleb128 (w, 4);
  D.23146 = basic_types[i].size;
  D.23147 = (unsigned char) D.23146;
  D.23148 = (int) D.23147;
  emit_byte (w, D.23148);
  D.23149 = basic_types[i].encoding;
  D.23150 = (unsigned char) D.23149;
  D.23151 = (int) D.23150;
  emit_byte (w, D.23151);
  D.23152 = basic_types[i].name;
  emit_string (w, D.23152);
  i = i + 1;
  <D.22739>:
  i.7 = (unsigned int) i;
  if (i.7 <= 16) goto <D.22738>; else goto <D.22740>;
  <D.22740>:
  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.23156;
  int D.23157;
  unsigned int i.10;
  unsigned int D.23159;
  int * D.23160;
  int D.23161;
  unsigned int D.23162;
  int i;

  code.8 = (unsigned int) code;
  emit_uleb128 (w, code.8);
  tag.9 = (unsigned int) tag;
  emit_uleb128 (w, tag.9);
  D.23156 = (unsigned char) has_child;
  D.23157 = (int) D.23156;
  emit_byte (w, D.23157);
  i = 0;
  goto <D.22595>;
  <D.22594>:
  i.10 = (unsigned int) i;
  D.23159 = i.10 * 4;
  D.23160 = attrs + D.23159;
  D.23161 = *D.23160;
  D.23162 = (unsigned int) D.23161;
  emit_uleb128 (w, D.23162);
  i = i + 1;
  <D.22595>:
  if (i < attrs_len) goto <D.22594>; else goto <D.22596>;
  <D.22596>:
  emit_uleb128 (w, 0);
  emit_uleb128 (w, 0);
}


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

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


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

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


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

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

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


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

  <D.22550>:
  {
    guint8 b;

    D.23168 = (unsigned char) value;
    b = D.23168 & 127;
    value = value >> 7;
    if (value != 0) goto <D.23169>; else goto <D.23170>;
    <D.23169>:
    b = b | 128;
    <D.23170>:
    D.23171 = (int) b;
    emit_byte (w, D.23171);
  }
  if (value != 0) goto <D.22550>; else goto <D.22551>;
  <D.22551>:
}


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

  D.23172 = (int) val;
  D.23173 = w->w;
  img_writer_emit_byte (D.23173, D.23172);
}


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

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


emit_debug_info_end (struct MonoDwarfWriter * w)
{

}


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

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


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

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


emit_cie (struct MonoDwarfWriter * w)
{
  int D.23177;
  long long int D.23178;
  int D.23179;
  unsigned int D.23180;
  struct GSList * D.23181;
  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.23177 = mono_unwind_get_dwarf_data_align ();
  D.23178 = (long long int) D.23177;
  emit_sleb128 (w, D.23178);
  D.23179 = mono_unwind_get_dwarf_pc_reg ();
  D.23180 = (unsigned int) D.23179;
  emit_uleb128 (w, D.23180);
  D.23181 = w->cie_program;
  w->cie_program = D.23181;
  D.23181 = w->cie_program;
  if (D.23181 != 0B) goto <D.23182>; else goto <D.23183>;
  <D.23182>:
  {
    guint32 uw_info_len;
    guint8 * uw_info;

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


emit_sleb128 (struct MonoDwarfWriter * w, gint64 value)
{
  _Bool D.23186;
  unsigned char D.23187;
  unsigned int D.23190;
  int D.23191;
  long long int D.23192;
  long long int D.23193;
  int D.23199;
  int D.23200;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;

  more = 1;
  D.23186 = value < 0;
  negative = (gboolean) D.23186;
  size = 64;
  goto <D.22561>;
  <D.22560>:
  D.23187 = (unsigned char) value;
  byte = D.23187 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.23188>; else goto <D.23189>;
  <D.23188>:
  D.23190 = size + 4294967289;
  D.23191 = (int) D.23190;
  D.23192 = 1 << D.23191;
  D.23193 = -D.23192;
  value = D.23193 | value;
  <D.23189>:
  if (value == 0) goto <D.23198>; else goto <D.23194>;
  <D.23198>:
  D.23199 = (int) byte;
  D.23200 = D.23199 & 64;
  if (D.23200 == 0) goto <D.23195>; else goto <D.23194>;
  <D.23194>:
  if (value == -1) goto <D.23201>; else goto <D.23196>;
  <D.23201>:
  D.23199 = (int) byte;
  D.23200 = D.23199 & 64;
  if (D.23200 != 0) goto <D.23195>; else goto <D.23196>;
  <D.23195>:
  more = 0;
  goto <D.23197>;
  <D.23196>:
  byte = byte | 128;
  <D.23197>:
  D.23199 = (int) byte;
  emit_byte (w, D.23199);
  <D.22561>:
  if (more != 0) goto <D.22560>; else goto <D.22562>;
  <D.22562>:
}


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

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


mono_dwarf_writer_close (struct MonoDwarfWriter * w)
{
  int D.23203;
  int D.23206;

  D.23203 = w->appending;
  if (D.23203 == 0) goto <D.23204>; else goto <D.23205>;
  <D.23204>:
  emit_section_change (w, ".debug_info", 0);
  emit_byte (w, 0);
  emit_label (w, ".Ldebug_info_end");
  <D.23205>:
  D.23206 = w->collect_line_info;
  if (D.23206 != 0) goto <D.23207>; else goto <D.23208>;
  <D.23207>:
  emit_all_line_number_info (w);
  <D.23208>:
}


emit_all_line_number_info (struct MonoDwarfWriter * w)
{
  int D.23209;
  _Bool D.23210;
  long int D.23211;
  long int D.23212;
  struct GSList * D.23215;
  struct MonoMethod * D.23216;
  struct GPtrArray * source_file_list.14;
  void * * D.23220;
  unsigned int i.15;
  unsigned int D.23222;
  void * * D.23223;
  char * D.23224;
  unsigned int i.16;
  unsigned int D.23226;
  int D.23227;
  const void * D.23228;
  struct GHashTable * D.23229;
  int D.23230;
  void * D.23233;
  int D.23236;
  int D.23237;
  int D.23238;
  void * D.23239;
  int D.23241;
  char * D.23242;
  int D.23243;
  void * D.23246;
  char * D.23250;
  unsigned int dir_index.17;
  struct MonoDomain * D.23252;
  struct MonoMethod * D.23253;
  unsigned int D.23254;
  guint8 * D.23255;
  char * D.23256;
  char * D.23257;
  int i;
  struct GHashTable * dir_to_index;
  struct GHashTable * index_to_dir;
  struct GSList * l;
  struct GSList * info_list;

  D.23209 = w->collect_line_info;
  D.23210 = D.23209 == 0;
  D.23211 = (long int) D.23210;
  D.23212 = __builtin_expect (D.23211, 0);
  if (D.23212 != 0) goto <D.23213>; else goto <D.23214>;
  <D.23213>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 709, "w->collect_line_info");
  <D.23214>:
  add_line_number_file_name (w, "<unknown>", 0, 0);
  D.23215 = w->line_info;
  info_list = monoeg_g_slist_reverse (D.23215);
  l = info_list;
  goto <D.22702>;
  <D.22701>:
  {
    struct MethodLineNumberInfo * info;
    struct MonoDebugMethodInfo * minfo;
    char * source_file;
    struct GPtrArray * source_file_list;

    try
      {
        info = l->data;
        D.23216 = info->method;
        minfo = mono_debug_lookup_method (D.23216);
        if (minfo == 0B) goto <D.23217>; else goto <D.23218>;
        <D.23217>:
        // predicted unlikely by continue predictor.
        goto <D.22696>;
        <D.23218>:
        mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B);
        i = 0;
        goto <D.22699>;
        <D.22698>:
        {
          struct MonoDebugSourceInfo * sinfo;

          source_file_list.14 = source_file_list;
          D.23220 = source_file_list.14->pdata;
          i.15 = (unsigned int) i;
          D.23222 = i.15 * 4;
          D.23223 = D.23220 + D.23222;
          sinfo = *D.23223;
          D.23224 = sinfo->source_file;
          add_line_number_file_name (w, D.23224, 0, 0);
        }
        i = i + 1;
        <D.22699>:
        i.16 = (unsigned int) i;
        source_file_list.14 = source_file_list;
        D.23226 = source_file_list.14->len;
        if (i.16 < D.23226) goto <D.22698>; else goto <D.22700>;
        <D.22700>:
      }
    finally
      {
        source_file = {CLOBBER};
        source_file_list = {CLOBBER};
      }
  }
  <D.22696>:
  l = l->next;
  <D.22702>:
  if (l != 0B) goto <D.22701>; else goto <D.22703>;
  <D.22703>:
  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.22709>;
  <D.22708>:
  {
    char * name;
    char * copy;
    int dir_index;

    D.23227 = i + 1;
    D.23228 = (const void *) D.23227;
    D.23229 = w->index_to_file;
    name = monoeg_g_hash_table_lookup (D.23229, D.23228);
    dir_index = 0;
    D.23230 = monoeg_g_path_is_absolute (name);
    if (D.23230 != 0) goto <D.23231>; else goto <D.23232>;
    <D.23231>:
    {
      char * dir;

      dir = monoeg_g_path_get_dirname (name);
      D.23233 = monoeg_g_hash_table_lookup (dir_to_index, dir);
      dir_index = (int) D.23233;
      if (dir_index == 0) goto <D.23234>; else goto <D.23235>;
      <D.23234>:
      dir_index = w->line_number_dir_index;
      D.23236 = w->line_number_dir_index;
      D.23237 = D.23236 + 1;
      w->line_number_dir_index = D.23237;
      copy = monoeg_strdup (dir);
      D.23238 = dir_index + 1;
      D.23239 = (void *) D.23238;
      monoeg_g_hash_table_insert_replace (dir_to_index, copy, D.23239, 0);
      D.23238 = dir_index + 1;
      D.23239 = (void *) D.23238;
      monoeg_g_hash_table_insert_replace (index_to_dir, D.23239, copy, 0);
      goto <D.23240>;
      <D.23235>:
      dir_index = dir_index + -1;
      <D.23240>:
      monoeg_g_free (dir);
    }
    <D.23232>:
  }
  i = i + 1;
  <D.22709>:
  D.23241 = w->line_number_file_index;
  if (D.23241 > i) goto <D.22708>; else goto <D.22710>;
  <D.22710>:
  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.22713>;
  <D.22712>:
  {
    char * dir;

    D.23227 = i + 1;
    D.23228 = (const void *) D.23227;
    dir = monoeg_g_hash_table_lookup (index_to_dir, D.23228);
    D.23242 = mono_dwarf_escape_path (dir);
    emit_string (w, D.23242);
  }
  i = i + 1;
  <D.22713>:
  D.23236 = w->line_number_dir_index;
  if (D.23236 > i) goto <D.22712>; else goto <D.22714>;
  <D.22714>:
  emit_byte (w, 0);
  i = 0;
  goto <D.22720>;
  <D.22719>:
  {
    char * name;
    char * basename;
    char * dir;
    int dir_index;

    D.23227 = i + 1;
    D.23228 = (const void *) D.23227;
    D.23229 = w->index_to_file;
    name = monoeg_g_hash_table_lookup (D.23229, D.23228);
    basename = 0B;
    dir_index = 0;
    D.23243 = monoeg_g_path_is_absolute (name);
    if (D.23243 != 0) goto <D.23244>; else goto <D.23245>;
    <D.23244>:
    dir = monoeg_g_path_get_dirname (name);
    D.23246 = monoeg_g_hash_table_lookup (dir_to_index, dir);
    dir_index = (int) D.23246;
    basename = monoeg_g_path_get_basename (name);
    <D.23245>:
    if (basename != 0B) goto <D.23247>; else goto <D.23248>;
    <D.23247>:
    emit_string (w, basename);
    goto <D.23249>;
    <D.23248>:
    D.23250 = mono_dwarf_escape_path (name);
    emit_string (w, D.23250);
    <D.23249>:
    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.22720>:
  D.23241 = w->line_number_file_index;
  if (D.23241 > i) goto <D.22719>; else goto <D.22721>;
  <D.22721>:
  emit_byte (w, 0);
  emit_label (w, ".Ldebug_line_header_end");
  l = info_list;
  goto <D.22725>;
  <D.22724>:
  {
    struct MethodLineNumberInfo * info;
    struct MonoDebugMethodJitInfo * dmji;

    info = l->data;
    D.23252 = mono_domain_get ();
    D.23253 = info->method;
    dmji = mono_debug_find_method (D.23253, D.23252);
    D.23254 = info->code_size;
    D.23255 = info->code;
    D.23256 = info->end_symbol;
    D.23257 = info->start_symbol;
    D.23253 = info->method;
    emit_line_number_info (w, D.23253, D.23257, D.23256, D.23255, D.23254, dmji);
    mono_debug_free_method_jit_info (dmji);
  }
  l = l->next;
  <D.22725>:
  if (l != 0B) goto <D.22724>; else goto <D.22726>;
  <D.22726>:
  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.23260;
  struct GHashTable * D.23263;
  struct GHashTable * D.23264;
  void * D.23265;
  int D.23268;
  int D.23269;
  int D.23270;
  int D.23271;
  void * D.23272;
  struct GHashTable * D.23273;
  int index;
  char * copy;

  D.23260 = w->file_to_index;
  if (D.23260 == 0B) goto <D.23261>; else goto <D.23262>;
  <D.23261>:
  D.23263 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  w->file_to_index = D.23263;
  D.23264 = monoeg_g_hash_table_new (0B, 0B);
  w->index_to_file = D.23264;
  <D.23262>:
  D.23260 = w->file_to_index;
  D.23265 = monoeg_g_hash_table_lookup (D.23260, name);
  index = (int) D.23265;
  if (index > 0) goto <D.23266>; else goto <D.23267>;
  <D.23266>:
  D.23268 = index + -1;
  return D.23268;
  <D.23267>:
  index = w->line_number_file_index;
  D.23269 = w->line_number_file_index;
  D.23270 = D.23269 + 1;
  w->line_number_file_index = D.23270;
  copy = monoeg_strdup (name);
  D.23271 = index + 1;
  D.23272 = (void *) D.23271;
  D.23260 = w->file_to_index;
  monoeg_g_hash_table_insert_replace (D.23260, copy, D.23272, 0);
  D.23271 = index + 1;
  D.23272 = (void *) D.23271;
  D.23273 = w->index_to_file;
  monoeg_g_hash_table_insert_replace (D.23273, D.23272, copy, 0);
  D.23268 = index;
  return D.23268;
}


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.23275;
  _Bool D.23278;
  long int D.23279;
  long int D.23280;
  unsigned int D.23283;
  unsigned int D.23284;
  unsigned int D.23285;
  struct MonoDebugLineNumberEntry * D.23286;
  unsigned int D.23287;
  unsigned int D.23288;
  unsigned int i.18;
  unsigned int D.23290;
  unsigned int j.19;
  unsigned int D.23294;
  int * D.23295;
  unsigned int j.20;
  unsigned int D.23297;
  unsigned int i.21;
  unsigned int D.23299;
  sizetype i.22;
  sizetype D.23303;
  sizetype D.23304;
  unsigned int D.23305;
  int D.23306;
  unsigned int D.23307;
  unsigned int j.23;
  unsigned int D.23316;
  int * D.23317;
  unsigned int i.24;
  unsigned int il_offset.25;
  char * D.23328;
  unsigned int D.23329;
  int D.23330;
  int prev_line.26;
  unsigned int D.23332;
  int D.23338;
  long long int D.23339;
  int D.22991;
  int D.23345;
  int D.23348;
  int D.23350;
  unsigned int file_index.27;
  unsigned int D.23356;
  long long int D.23357;
  const unsigned char * ip.28;
  struct FILE * D.23362;
  int D.23363;
  int D.23364;
  unsigned int D.23365;
  unsigned int D.23366;
  const guint8 * ip.29;
  int ip.30;
  int ip.31;
  unsigned int il_offset.32;
  unsigned int D.23371;
  int * D.23372;
  const unsigned char * D.23373;
  unsigned int D.23374;
  unsigned int D.23377;
  int * D.23378;
  unsigned int D.23383;
  int D.23384;
  int D.23385;
  int D.23386;
  unsigned int prev_native_offset.33;
  unsigned int D.23388;
  long long int D.23389;
  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.23275 = w->emit_line;
  if (D.23275 == 0) goto <D.23276>; else goto <D.23277>;
  <D.23276>:
  mono_metadata_free_mh (header);
  return;
  <D.23277>:
  minfo = mono_debug_lookup_method (method);
  D.23278 = code_size == 0;
  D.23279 = (long int) D.23278;
  D.23280 = __builtin_expect (D.23279, 0);
  if (D.23280 != 0) goto <D.23281>; else goto <D.23282>;
  <D.23281>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1585, "code_size");
  <D.23282>:
  D.23283 = debug_info->num_line_numbers;
  D.23284 = D.23283 * 8;
  ln_array = monoeg_malloc0 (D.23284);
  D.23283 = debug_info->num_line_numbers;
  D.23285 = D.23283 * 8;
  D.23286 = debug_info->line_numbers;
  memcpy (ln_array, D.23286, D.23285);
  D.23283 = debug_info->num_line_numbers;
  qsort (ln_array, D.23283, 8, compare_lne);
  D.23287 = code_size + 1;
  D.23288 = D.23287 * 4;
  native_to_il_offset = monoeg_malloc0 (D.23288);
  i = 0;
  goto <D.22978>;
  <D.22977>:
  {
    int j;
    struct MonoDebugLineNumberEntry * lne;

    i.18 = (unsigned int) i;
    D.23290 = i.18 * 8;
    lne = ln_array + D.23290;
    if (i == 0) goto <D.23291>; else goto <D.23292>;
    <D.23291>:
    j = 0;
    goto <D.22968>;
    <D.22967>:
    j.19 = (unsigned int) j;
    D.23294 = j.19 * 4;
    D.23295 = native_to_il_offset + D.23294;
    *D.23295 = -1;
    j = j + 1;
    <D.22968>:
    j.20 = (unsigned int) j;
    D.23297 = lne->native_offset;
    if (j.20 < D.23297) goto <D.22967>; else goto <D.22969>;
    <D.22969>:
    <D.23292>:
    i.21 = (unsigned int) i;
    D.23283 = debug_info->num_line_numbers;
    D.23299 = D.23283 + 4294967295;
    if (i.21 < D.23299) goto <D.23300>; else goto <D.23301>;
    <D.23300>:
    {
      struct MonoDebugLineNumberEntry * lne_next;

      i.22 = (sizetype) i;
      D.23303 = i.22 + 1;
      D.23304 = D.23303 * 8;
      lne_next = ln_array + D.23304;
      D.23297 = lne->native_offset;
      j = (int) D.23297;
      goto <D.22972>;
      <D.22971>:
      j.19 = (unsigned int) j;
      D.23294 = j.19 * 4;
      D.23295 = native_to_il_offset + D.23294;
      D.23305 = lne->il_offset;
      D.23306 = (int) D.23305;
      *D.23295 = D.23306;
      j = j + 1;
      <D.22972>:
      j.20 = (unsigned int) j;
      D.23307 = lne_next->native_offset;
      if (j.20 < D.23307) goto <D.22971>; else goto <D.22973>;
      <D.22973>:
    }
    goto <D.23308>;
    <D.23301>:
    D.23297 = lne->native_offset;
    j = (int) D.23297;
    goto <D.22975>;
    <D.22974>:
    j.19 = (unsigned int) j;
    D.23294 = j.19 * 4;
    D.23295 = native_to_il_offset + D.23294;
    D.23305 = lne->il_offset;
    D.23306 = (int) D.23305;
    *D.23295 = D.23306;
    j = j + 1;
    <D.22975>:
    j.23 = (unsigned int) j;
    if (j.23 < code_size) goto <D.22974>; else goto <D.22976>;
    <D.22976>:
    <D.23308>:
  }
  i = i + 1;
  <D.22978>:
  i.21 = (unsigned int) i;
  D.23283 = debug_info->num_line_numbers;
  if (i.21 < D.23283) goto <D.22977>; else goto <D.22979>;
  <D.22979>:
  monoeg_g_free (ln_array);
  prev_line = 1;
  prev_il_offset = -1;
  i = 0;
  goto <D.22993>;
  <D.22992>:
  {
    int line_diff;
    int addr_diff;

    if (minfo == 0B) goto <D.23310>; else goto <D.23311>;
    <D.23310>:
    // predicted unlikely by continue predictor.
    goto <D.22982>;
    <D.23311>:
    D.23286 = debug_info->line_numbers;
    if (D.23286 == 0B) goto <D.23312>; else goto <D.23313>;
    <D.23312>:
    // predicted unlikely by continue predictor.
    goto <D.22982>;
    <D.23313>:
    if (native_to_il_offset != 0B) goto <D.23314>; else goto <D.23315>;
    <D.23314>:
    i.18 = (unsigned int) i;
    D.23316 = i.18 * 4;
    D.23317 = native_to_il_offset + D.23316;
    il_offset = *D.23317;
    goto <D.23318>;
    <D.23315>:
    i.24 = (unsigned int) i;
    il_offset = il_offset_from_address (method, debug_info, i.24);
    <D.23318>:
    i.18 = (unsigned int) i;
    D.23316 = i.18 * 4;
    D.23317 = native_to_il_offset + D.23316;
    il_offset = *D.23317;
    if (il_offset < 0) goto <D.23320>; else goto <D.23321>;
    <D.23320>:
    // predicted unlikely by continue predictor.
    goto <D.22982>;
    <D.23321>:
    if (il_offset == prev_il_offset) goto <D.23322>; else goto <D.23323>;
    <D.23322>:
    // predicted unlikely by continue predictor.
    goto <D.22982>;
    <D.23323>:
    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.23325>; else goto <D.23327>;
    <D.23327>:
    D.23328 = loc->source_file;
    if (D.23328 == 0B) goto <D.23325>; else goto <D.23326>;
    <D.23325>:
    // predicted unlikely by continue predictor.
    goto <D.22982>;
    <D.23326>:
    D.23329 = loc->row;
    D.23330 = (int) D.23329;
    prev_line.26 = (int) prev_line;
    line_diff = D.23330 - prev_line.26;
    i.24 = (unsigned int) i;
    D.23332 = i.24 - prev_native_offset;
    addr_diff = (int) D.23332;
    if (first != 0) goto <D.23333>; else goto <D.23334>;
    <D.23333>:
    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.23335>; else goto <D.23336>;
    <D.23335>:
    emit_pointer_unaligned (w, start_symbol);
    goto <D.23337>;
    <D.23336>:
    emit_pointer_value (w, code);
    <D.23337>:
    emit_byte (w, 3);
    D.23329 = loc->row;
    D.23330 = (int) D.23329;
    prev_line.26 = (int) prev_line;
    D.23338 = D.23330 - prev_line.26;
    D.23339 = (long long int) D.23338;
    emit_sleb128 (w, D.23339);
    prev_line = loc->row;
    prev_native_offset = (guint32) i;
    first = 0;
    <D.23334>:
    D.23329 = loc->row;
    if (D.23329 != prev_line) goto <D.23340>; else goto <D.23341>;
    <D.23340>:
    if (prev_file_name == 0B) goto <D.23342>; else goto <D.23344>;
    <D.23344>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.23328 = loc->source_file;
      D.22991 = __builtin_strcmp (D.23328, prev_file_name);
    }
    if (D.22991 != 0) goto <D.23342>; else goto <D.23343>;
    <D.23342>:
    D.23345 = w->collect_line_info;
    if (D.23345 != 0) goto <D.23346>; else goto <D.23347>;
    <D.23346>:
    D.23328 = loc->source_file;
    D.23348 = get_line_number_file_name (w, D.23328);
    file_index = D.23348 + 1;
    goto <D.23349>;
    <D.23347>:
    D.23328 = loc->source_file;
    file_index = emit_line_number_file_name (w, D.23328, 0, 0);
    <D.23349>:
    monoeg_g_free (prev_file_name);
    D.23328 = loc->source_file;
    prev_file_name = monoeg_strdup (D.23328);
    D.23350 = w->cur_file_index;
    if (D.23350 != file_index) goto <D.23351>; else goto <D.23352>;
    <D.23351>:
    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.23352>:
    <D.23343>:
    emit_advance_op (w, line_diff, addr_diff);
    prev_line = loc->row;
    prev_native_offset = (guint32) i;
    <D.23341>:
    mono_debug_symfile_free_location (loc);
  }
  <D.22982>:
  i = i + 1;
  <D.22993>:
  i.24 = (unsigned int) i;
  if (i.24 < code_size) goto <D.22992>; else goto <D.22994>;
  <D.22994>:
  monoeg_g_free (native_to_il_offset);
  monoeg_g_free (prev_file_name);
  if (first == 0) goto <D.23354>; else goto <D.23355>;
  <D.23354>:
  emit_byte (w, 2);
  D.23356 = code_size - prev_native_offset;
  D.23357 = (long long int) D.23356;
  emit_sleb128 (w, D.23357);
  emit_byte (w, 1);
  emit_byte (w, 0);
  emit_byte (w, 1);
  emit_byte (w, 1);
  goto <D.23358>;
  <D.23355>:
  if (start_symbol == 0B) goto <D.23359>; else goto <D.23360>;
  <D.23359>:
  {
    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.23362 = w->il_file;
        fprintf (D.23362, "// %s\n", name);
        D.23363 = w->il_file_line_index;
        D.23364 = D.23363 + 1;
        w->il_file_line_index = D.23364;
        monoeg_g_free (name);
        D.23365 = header->code_size;
        D.23366 = D.23365 * 4;
        il_to_line = monoeg_malloc0 (D.23366);
        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.23003>;
        <D.23002>:
        {
          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.23363 = w->il_file_line_index;
          D.23364 = D.23363 + 1;
          w->il_file_line_index = D.23364;
          ip.29 = ip;
          dis = disasm_ins (method, ip.29, &ip);
          D.23362 = w->il_file;
          fprintf (D.23362, "%s\n", dis);
          monoeg_g_free (dis);
          il_offset.32 = (unsigned int) il_offset;
          D.23371 = il_offset.32 * 4;
          D.23372 = il_to_line + D.23371;
          D.23363 = w->il_file_line_index;
          *D.23372 = D.23363;
        }
        <D.23003>:
        ip.28 = header->code;
        D.23365 = header->code_size;
        D.23373 = ip.28 + D.23365;
        ip.29 = ip;
        if (D.23373 > ip.29) goto <D.23002>; else goto <D.23004>;
        <D.23004>:
        prev_line = 1;
        prev_native_offset = 0;
        i = 0;
        goto <D.23009>;
        <D.23008>:
        {
          struct MonoDebugLineNumberEntry * lne;
          int line;

          D.23286 = debug_info->line_numbers;
          i.18 = (unsigned int) i;
          D.23290 = i.18 * 8;
          lne = D.23286 + D.23290;
          D.23374 = lne->il_offset;
          D.23365 = header->code_size;
          if (D.23374 >= D.23365) goto <D.23375>; else goto <D.23376>;
          <D.23375>:
          // predicted unlikely by continue predictor.
          goto <D.23007>;
          <D.23376>:
          D.23374 = lne->il_offset;
          D.23377 = D.23374 * 4;
          D.23378 = il_to_line + D.23377;
          line = *D.23378;
          if (line == 0) goto <D.23379>; else goto <D.23380>;
          <D.23379>:
          // predicted unlikely by continue predictor.
          goto <D.23007>;
          <D.23380>:
          if (line != prev_line) goto <D.23381>; else goto <D.23382>;
          <D.23381>:
          D.23383 = lne->native_offset;
          D.23384 = (int) D.23383;
          D.23385 = D.23384 - prev_native_offset;
          D.23386 = line - prev_line;
          emit_advance_op (w, D.23386, D.23385);
          prev_line = line;
          D.23383 = lne->native_offset;
          prev_native_offset = (int) D.23383;
          <D.23382>:
        }
        <D.23007>:
        i = i + 1;
        <D.23009>:
        i.21 = (unsigned int) i;
        D.23283 = debug_info->num_line_numbers;
        if (i.21 < D.23283) goto <D.23008>; else goto <D.23010>;
        <D.23010>:
        emit_byte (w, 2);
        prev_native_offset.33 = (unsigned int) prev_native_offset;
        D.23388 = code_size - prev_native_offset.33;
        D.23389 = (long long int) D.23388;
        emit_sleb128 (w, D.23389);
        emit_byte (w, 1);
        emit_byte (w, 0);
        emit_byte (w, 1);
        emit_byte (w, 1);
        D.23362 = w->il_file;
        fflush (D.23362);
        monoeg_g_free (il_to_line);
      }
    finally
      {
        ip = {CLOBBER};
      }
  }
  <D.23360>:
  <D.23358>:
  mono_metadata_free_mh (header);
}


compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b)
{
  unsigned int D.23391;
  unsigned int D.23392;
  gint D.23395;
  unsigned int D.23396;
  unsigned int D.23397;
  unsigned int D.23398;
  unsigned int D.23399;

  D.23391 = a->native_offset;
  D.23392 = b->native_offset;
  if (D.23391 == D.23392) goto <D.23393>; else goto <D.23394>;
  <D.23393>:
  D.23396 = a->il_offset;
  D.23397 = b->il_offset;
  D.23398 = D.23396 - D.23397;
  D.23395 = (gint) D.23398;
  return D.23395;
  <D.23394>:
  D.23391 = a->native_offset;
  D.23392 = b->native_offset;
  D.23399 = D.23391 - D.23392;
  D.23395 = (gint) D.23399;
  return D.23395;
}


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

  D.23402 = __builtin_object_size (__dest, 0);
  D.23401 = __builtin___memcpy_chk (__dest, __src, __len, D.23402);
  return D.23401;
}


il_offset_from_address (struct MonoMethod * method, struct MonoDebugMethodJitInfo * jit, guint32 native_offset)
{
  struct MonoDebugLineNumberEntry * D.23404;
  gint32 D.23407;
  unsigned int D.23408;
  unsigned int D.23409;
  unsigned int i.34;
  unsigned int D.23411;
  struct MonoDebugLineNumberEntry * D.23412;
  unsigned int D.23413;
  unsigned int D.23416;
  int i;

  D.23404 = jit->line_numbers;
  if (D.23404 == 0B) goto <D.23405>; else goto <D.23406>;
  <D.23405>:
  D.23407 = -1;
  return D.23407;
  <D.23406>:
  D.23408 = jit->num_line_numbers;
  D.23409 = D.23408 + 4294967295;
  i = (int) D.23409;
  goto <D.22930>;
  <D.22929>:
  {
    struct MonoDebugLineNumberEntry lne;

    try
      {
        D.23404 = jit->line_numbers;
        i.34 = (unsigned int) i;
        D.23411 = i.34 * 8;
        D.23412 = D.23404 + D.23411;
        lne = *D.23412;
        D.23413 = lne.native_offset;
        if (D.23413 <= native_offset) goto <D.23414>; else goto <D.23415>;
        <D.23414>:
        D.23416 = lne.il_offset;
        D.23407 = (gint32) D.23416;
        return D.23407;
        <D.23415>:
      }
    finally
      {
        lne = {CLOBBER};
      }
  }
  i = i + -1;
  <D.22930>:
  if (i >= 0) goto <D.22929>; else goto <D.22931>;
  <D.22931>:
  D.23407 = -1;
  return D.23407;
}


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

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


get_line_number_file_name (struct MonoDwarfWriter * w, const char * name)
{
  struct GHashTable * D.23421;
  _Bool D.23422;
  long int D.23423;
  long int D.23424;
  void * D.23427;
  _Bool D.23428;
  long int D.23429;
  long int D.23430;
  int D.23433;
  int index;

  D.23421 = w->file_to_index;
  D.23422 = D.23421 == 0B;
  D.23423 = (long int) D.23422;
  D.23424 = __builtin_expect (D.23423, 0);
  if (D.23424 != 0) goto <D.23425>; else goto <D.23426>;
  <D.23425>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 648, "w->file_to_index");
  <D.23426>:
  D.23421 = w->file_to_index;
  D.23427 = monoeg_g_hash_table_lookup (D.23421, name);
  index = (int) D.23427;
  D.23428 = index <= 0;
  D.23429 = (long int) D.23428;
  D.23430 = __builtin_expect (D.23429, 0);
  if (D.23430 != 0) goto <D.23431>; else goto <D.23432>;
  <D.23431>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 650, "index > 0");
  <D.23432>:
  D.23433 = index + -1;
  return D.23433;
}


emit_line_number_file_name (struct MonoDwarfWriter * w, const char * name, gint64 last_mod_time, gint64 file_size)
{
  struct GHashTable * D.23435;
  struct GHashTable * D.23438;
  void * D.23439;
  int D.23442;
  int D.23443;
  struct GHashTable * D.23446;
  struct GHashTable * D.23449;
  void * D.23450;
  int D.23453;
  int D.23454;
  void * dir_index.35;
  gchar * D.23456;
  unsigned int dir_index.36;
  int D.23464;
  int D.23465;
  void * index.37;
  gchar * D.23467;
  int index;
  int dir_index;
  char * basename;

  basename = 0B;
  D.23435 = w->file_to_index;
  if (D.23435 == 0B) goto <D.23436>; else goto <D.23437>;
  <D.23436>:
  D.23438 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  w->file_to_index = D.23438;
  <D.23437>:
  D.23435 = w->file_to_index;
  D.23439 = monoeg_g_hash_table_lookup (D.23435, name);
  index = (int) D.23439;
  if (index > 0) goto <D.23440>; else goto <D.23441>;
  <D.23440>:
  D.23442 = index;
  return D.23442;
  <D.23441>:
  D.23443 = monoeg_g_path_is_absolute (name);
  if (D.23443 != 0) goto <D.23444>; else goto <D.23445>;
  <D.23444>:
  {
    char * dir;

    dir = monoeg_g_path_get_dirname (name);
    D.23446 = w->dir_to_index;
    if (D.23446 == 0B) goto <D.23447>; else goto <D.23448>;
    <D.23447>:
    D.23449 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
    w->dir_to_index = D.23449;
    <D.23448>:
    D.23446 = w->dir_to_index;
    D.23450 = monoeg_g_hash_table_lookup (D.23446, dir);
    dir_index = (int) D.23450;
    if (dir_index == 0) goto <D.23451>; else goto <D.23452>;
    <D.23451>:
    emit_section_change (w, ".debug_line", 2);
    emit_string (w, dir);
    D.23453 = w->line_number_dir_index;
    D.23454 = D.23453 + 1;
    w->line_number_dir_index = D.23454;
    dir_index = w->line_number_dir_index;
    dir_index.35 = (void *) dir_index;
    D.23456 = monoeg_strdup (dir);
    D.23446 = w->dir_to_index;
    monoeg_g_hash_table_insert_replace (D.23446, D.23456, dir_index.35, 0);
    <D.23452>:
    monoeg_g_free (dir);
    basename = monoeg_g_path_get_basename (name);
  }
  goto <D.23457>;
  <D.23445>:
  dir_index = 0;
  <D.23457>:
  emit_section_change (w, ".debug_line", 3);
  if (basename != 0B) goto <D.23458>; else goto <D.23459>;
  <D.23458>:
  emit_string (w, basename);
  goto <D.23460>;
  <D.23459>:
  emit_string (w, name);
  <D.23460>:
  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.23462>; else goto <D.23463>;
  <D.23462>:
  monoeg_g_free (basename);
  <D.23463>:
  D.23464 = w->line_number_file_index;
  D.23465 = D.23464 + 1;
  w->line_number_file_index = D.23465;
  index = w->line_number_file_index;
  index.37 = (void *) index;
  D.23467 = monoeg_strdup (name);
  D.23435 = w->file_to_index;
  monoeg_g_hash_table_insert_replace (D.23435, D.23467, index.37, 0);
  D.23442 = index;
  return D.23442;
}


disasm_ins (struct MonoMethod * method, const guchar * ip, const guint8 * * endip)
{
  const guchar * ip.38;
  unsigned char D.23470;
  const guchar * D.23473;
  unsigned char D.23474;
  int D.23475;
  _Bool D.23476;
  long int D.23477;
  long int D.23478;
  const char * D.23481;
  int ip.39;
  const unsigned char * D.23483;
  int D.23484;
  int D.23485;
  const guchar * ip.40;
  const char * D.23487;
  char * D.23489;
  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.23470 = *ip.38;
      if (D.23470 == 240) goto <D.23471>; else goto <D.23472>;
      <D.23471>:
      {
        guint32 token;
        void * data;

        ip.38 = ip;
        D.23473 = ip.38 + 1;
        D.23474 = *D.23473;
        D.23475 = (int) D.23474;
        switch (D.23475) <default: <D.22921>, case 0: <D.22917>, case 11: <D.22920>>
        <D.22917>:
        {
          struct MonoJitICallInfo * info;

          ip.38 = ip;
          token = MEM[(const guint32 *)ip.38 + 2B];
          data = mono_method_get_wrapper_data (method, token);
          info = mono_find_jit_icall_by_addr (data);
          D.23476 = info == 0B;
          D.23477 = (long int) D.23476;
          D.23478 = __builtin_expect (D.23477, 0);
          if (D.23478 != 0) goto <D.23479>; else goto <D.23480>;
          <D.23479>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1470, "info");
          <D.23480>:
          D.23481 = info->name;
          ip.38 = ip;
          ip.39 = (int) ip.38;
          D.23483 = header->code;
          D.23484 = (int) D.23483;
          D.23485 = ip.39 - D.23484;
          dis = monoeg_g_strdup_printf ("IL_%04x: mono_icall <%s>", D.23485, D.23481);
          ip.38 = ip;
          ip.40 = ip.38 + 6;
          ip = ip.40;
          goto <D.22919>;
        }
        <D.22920>:
        ip.38 = ip;
        token = MEM[(const guint32 *)ip.38 + 2B];
        data = mono_method_get_wrapper_data (method, token);
        D.23487 = MEM[(struct MonoClass *)data].name;
        ip.38 = ip;
        ip.39 = (int) ip.38;
        D.23483 = header->code;
        D.23484 = (int) D.23483;
        D.23485 = ip.39 - D.23484;
        dis = monoeg_g_strdup_printf ("IL_%04x: mono_classconst <%s>", D.23485, D.23487);
        ip.38 = ip;
        ip.40 = ip.38 + 6;
        ip = ip.40;
        goto <D.22919>;
        <D.22921>:
        ip.38 = ip;
        dis = mono_disasm_code_one (&dh, method, ip.38, &ip);
        <D.22919>:
      }
      goto <D.23488>;
      <D.23472>:
      ip.38 = ip;
      dis = mono_disasm_code_one (&dh, method, ip.38, &ip);
      <D.23488>:
      token_handler_ip = 0B;
      ip.38 = ip;
      *endip = ip.38;
      mono_metadata_free_mh (header);
      D.23489 = dis;
      return D.23489;
    }
  finally
    {
      dh = {CLOBBER};
    }
}


token_handler (struct MonoDisHelper * dh, struct MonoMethod * method, guint32 token)
{
  unsigned char D.23492;
  unsigned char D.23493;
  const guint8 * token_handler_ip.41;
  unsigned char D.23497;
  int D.23498;
  struct MonoClass * D.23502;
  struct MonoImage * D.23503;
  struct MonoClass * klass.42;
  struct MonoClass * klass.43;
  const char * D.23506;
  char * D.23516;
  char * res;
  char * desc;
  struct MonoMethod * cmethod;
  struct MonoClass * klass;
  struct MonoClassField * field;
  void * data;

  try
    {
      data = 0B;
      D.23492 = BIT_FIELD_REF <*method, 8, 160>;
      D.23493 = D.23492 & 124;
      if (D.23493 != 0) goto <D.23494>; else goto <D.23495>;
      <D.23494>:
      data = mono_method_get_wrapper_data (method, token);
      <D.23495>:
      token_handler_ip.41 = token_handler_ip;
      D.23497 = *token_handler_ip.41;
      D.23498 = (int) D.23497;
      switch (D.23498) <default: <D.22906>, case 40: <D.22899>, case 41: <D.22901>, case 111: <D.22900>, case 115: <D.22898>, case 116: <D.22895>, case 117: <D.22894>, case 123: <D.22902>, case 125: <D.22904>, case 126: <D.22903>, case 128: <D.22905>, case 143: <D.22896>>
      <D.22894>:
      <D.22895>:
      <D.22896>:
      D.23492 = BIT_FIELD_REF <*method, 8, 160>;
      D.23493 = D.23492 & 124;
      if (D.23493 != 0) goto <D.23499>; else goto <D.23500>;
      <D.23499>:
      klass = data;
      goto <D.23501>;
      <D.23500>:
      D.23502 = method->klass;
      D.23503 = D.23502->image;
      klass.42 = mono_class_get_full (D.23503, token, 0B);
      klass = klass.42;
      <D.23501>:
      klass.43 = klass;
      D.23506 = klass.43->name;
      res = monoeg_g_strdup_printf ("<%s>", D.23506);
      goto <D.22897>;
      <D.22898>:
      <D.22899>:
      <D.22900>:
      D.23492 = BIT_FIELD_REF <*method, 8, 160>;
      D.23493 = D.23492 & 124;
      if (D.23493 != 0) goto <D.23507>; else goto <D.23508>;
      <D.23507>:
      cmethod = data;
      goto <D.23509>;
      <D.23508>:
      D.23502 = method->klass;
      D.23503 = D.23502->image;
      cmethod = mono_get_method_full (D.23503, token, 0B, 0B);
      <D.23509>:
      desc = mono_method_full_name (cmethod, 1);
      res = monoeg_g_strdup_printf ("<%s>", desc);
      monoeg_g_free (desc);
      goto <D.22897>;
      <D.22901>:
      D.23492 = BIT_FIELD_REF <*method, 8, 160>;
      D.23493 = D.23492 & 124;
      if (D.23493 != 0) goto <D.23510>; else goto <D.23511>;
      <D.23510>:
      desc = mono_signature_get_desc (data, 0);
      res = monoeg_g_strdup_printf ("<%s>", desc);
      monoeg_g_free (desc);
      goto <D.23512>;
      <D.23511>:
      res = monoeg_g_strdup_printf ("<0x%08x>", token);
      <D.23512>:
      goto <D.22897>;
      <D.22902>:
      <D.22903>:
      <D.22904>:
      <D.22905>:
      D.23492 = BIT_FIELD_REF <*method, 8, 160>;
      D.23493 = D.23492 & 124;
      if (D.23493 != 0) goto <D.23513>; else goto <D.23514>;
      <D.23513>:
      field = data;
      goto <D.23515>;
      <D.23514>:
      D.23502 = method->klass;
      D.23503 = D.23502->image;
      field = mono_field_from_token (D.23503, token, &klass, 0B);
      <D.23515>:
      desc = mono_field_full_name (field);
      res = monoeg_g_strdup_printf ("<%s>", desc);
      monoeg_g_free (desc);
      goto <D.22897>;
      <D.22906>:
      res = monoeg_g_strdup_printf ("<0x%08x>", token);
      goto <D.22897>;
      <D.22897>:
      D.23516 = res;
      return D.23516;
    }
  finally
    {
      klass = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23521;
  int D.23526;
  void * D.23528;
  unsigned int D.23529;

  D.23521 = __builtin_constant_p (__len);
  if (D.23521 != 0) goto <D.23522>; else goto <D.23523>;
  <D.23522>:
  if (__len == 0) goto <D.23524>; else goto <D.23525>;
  <D.23524>:
  D.23526 = __builtin_constant_p (__ch);
  if (D.23526 == 0) goto <D.23519>; else goto <D.23527>;
  <D.23527>:
  if (__ch != 0) goto <D.23519>; else goto <D.23520>;
  <D.23519>:
  __warn_memset_zero_len ();
  D.23528 = __dest;
  return D.23528;
  <D.23520>:
  <D.23525>:
  <D.23523>:
  D.23529 = __builtin_object_size (__dest, 0);
  D.23528 = __builtin___memset_chk (__dest, __ch, __len, D.23529);
  return D.23528;
}


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

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


emit_advance_op (struct MonoDwarfWriter * w, int line_diff, int addr_diff)
{
  unsigned int line_diff.44;
  unsigned int D.23534;
  int max_special_addr_diff.45;
  int D.23542;
  int D.23545;
  int D.23546;
  int D.23547;
  int D.23548;
  unsigned char D.23553;
  int D.23554;
  long long int D.23556;
  long long int D.23557;
  gint64 opcode;

  opcode = 0;
  line_diff.44 = (unsigned int) line_diff;
  D.23534 = line_diff.44 + 5;
  if (D.23534 <= 13) goto <D.23535>; else goto <D.23536>;
  <D.23535>:
  max_special_addr_diff.45 = max_special_addr_diff;
  if (max_special_addr_diff.45 == 0) goto <D.23538>; else goto <D.23539>;
  <D.23538>:
  max_special_addr_diff = 17;
  <D.23539>:
  max_special_addr_diff.45 = max_special_addr_diff;
  if (addr_diff > max_special_addr_diff.45) goto <D.23540>; else goto <D.23541>;
  <D.23540>:
  max_special_addr_diff.45 = max_special_addr_diff;
  D.23542 = max_special_addr_diff.45 * 2;
  if (D.23542 > addr_diff) goto <D.23543>; else goto <D.23544>;
  <D.23543>:
  emit_byte (w, 8);
  max_special_addr_diff.45 = max_special_addr_diff;
  addr_diff = addr_diff - max_special_addr_diff.45;
  <D.23544>:
  <D.23541>:
  D.23545 = line_diff + 5;
  D.23546 = addr_diff * 14;
  D.23547 = D.23545 + D.23546;
  D.23548 = D.23547 + 13;
  opcode = (gint64) D.23548;
  if (opcode > 255) goto <D.23549>; else goto <D.23550>;
  <D.23549>:
  opcode = 0;
  <D.23550>:
  <D.23536>:
  if (opcode != 0) goto <D.23551>; else goto <D.23552>;
  <D.23551>:
  D.23553 = (unsigned char) opcode;
  D.23554 = (int) D.23553;
  emit_byte (w, D.23554);
  goto <D.23555>;
  <D.23552>:
  emit_byte (w, 3);
  D.23556 = (long long int) line_diff;
  emit_sleb128 (w, D.23556);
  emit_byte (w, 2);
  D.23557 = (long long int) addr_diff;
  emit_sleb128 (w, D.23557);
  emit_byte (w, 1);
  <D.23555>:
}


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.23561;
  unsigned char D.23562;
  struct MonoClass * D.23564;
  unsigned char D.23565;
  unsigned char D.23566;
  <unnamed-unsigned:1> D.23570;
  int D.23571;
  int D.23572;
  short unsigned int D.23573;
  int D.23574;
  int D.23575;
  struct MonoType * D.23576;
  short unsigned int D.23577;
  int D.23578;
  unsigned int D.23579;
  unsigned int D.23580;
  void * D.23584;
  struct MonoInst * iftmp.46;
  unsigned int i.47;
  unsigned int D.23589;
  struct MonoInst * * D.23590;
  _Bool D.23594;
  _Bool D.23595;
  _Bool D.23596;
  int D.23599;
  int D.23601;
  unsigned int D.23609;
  unsigned int D.23610;
  char * * D.23611;
  guint32 iftmp.48;
  char D.23616;
  unsigned char D.23623;
  int D.23624;
  int D.23625;
  struct MonoClass * D.23626;
  struct MonoType * D.23627;
  guint8 * p.49;
  int code_size.50;
  int p.51;
  int buf.52;
  int D.23636;
  unsigned int D.23637;
  sizetype D.23638;
  guint8 * D.23639;
  sizetype D.23640;
  guint8 * D.23641;
  unsigned char D.23643;
  int D.23644;
  struct MonoInst * * D.23645;
  _Bool D.23646;
  _Bool D.23647;
  int D.23650;
  guint32 iftmp.53;
  struct MonoDebugLocalVar * D.23659;
  unsigned int j.54;
  unsigned int D.23661;
  struct MonoDebugLocalVar * D.23662;
  int D.23663;
  int D.23665;
  unsigned char D.23675;
  int D.23676;
  int D.23677;
  int D.23680;
  sizetype D.23683;
  guint8 * D.23684;
  sizetype D.23685;
  guint8 * D.23686;
  int D.23692;
  int D.23693;
  const mono_byte * D.23696;
  int D.23699;
  gchar * D.23702;
  gchar * D.23703;
  struct GSList * D.23704;
  struct GSList * D.23705;
  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.23042>;
      <D.23041>:
      {
        struct MonoType * t;

        if (i == 0) goto <D.23560>; else goto <D.23558>;
        <D.23560>:
        D.23561 = BIT_FIELD_REF <*sig, 8, 80>;
        D.23562 = D.23561 & 64;
        if (D.23562 != 0) goto <D.23563>; else goto <D.23558>;
        <D.23563>:
        D.23564 = method->klass;
        D.23565 = BIT_FIELD_REF <*D.23564, 8, 160>;
        D.23566 = D.23565 & 8;
        if (D.23566 != 0) goto <D.23567>; else goto <D.23568>;
        <D.23567>:
        D.23564 = method->klass;
        t = &D.23564->this_arg;
        goto <D.23569>;
        <D.23568>:
        D.23564 = method->klass;
        t = &D.23564->byval_arg;
        <D.23569>:
        goto <D.23559>;
        <D.23558>:
        D.23570 = sig->hasthis;
        D.23571 = (int) D.23570;
        D.23572 = i - D.23571;
        t = sig->params[D.23572];
        <D.23559>:
        emit_type (w, t);
      }
      i = i + 1;
      <D.23042>:
      D.23573 = sig->param_count;
      D.23574 = (int) D.23573;
      D.23570 = sig->hasthis;
      D.23571 = (int) D.23570;
      D.23575 = D.23574 + D.23571;
      if (D.23575 > i) goto <D.23041>; else goto <D.23043>;
      <D.23043>:
      i = 0;
      goto <D.23045>;
      <D.23044>:
      D.23576 = header->locals[i];
      emit_type (w, D.23576);
      i = i + 1;
      <D.23045>:
      D.23577 = header->num_locals;
      D.23578 = (int) D.23577;
      if (D.23578 > i) goto <D.23044>; else goto <D.23046>;
      <D.23046>:
      D.23573 = sig->param_count;
      D.23579 = (unsigned int) D.23573;
      D.23580 = D.23579 * 4;
      names = monoeg_malloc0 (D.23580);
      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.23581>; else goto <D.23582>;
      <D.23581>:
      emit_pointer_unaligned (w, start_symbol);
      emit_pointer_unaligned (w, end_symbol);
      goto <D.23583>;
      <D.23582>:
      emit_pointer_value (w, code);
      D.23584 = code + code_size;
      emit_pointer_value (w, D.23584);
      <D.23583>:
      emit_byte (w, 2);
      emit_byte (w, 118);
      emit_byte (w, 16);
      i = 0;
      goto <D.23054>;
      <D.23053>:
      {
        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.23586>; else goto <D.23587>;
            <D.23586>:
            i.47 = (unsigned int) i;
            D.23589 = i.47 * 4;
            D.23590 = args + D.23589;
            iftmp.46 = *D.23590;
            goto <D.23591>;
            <D.23587>:
            iftmp.46 = 0B;
            <D.23591>:
            arg = iftmp.46;
            vmv = 0B;
            need_loclist = 0;
            vmv = find_vmv (cfg, arg);
            D.23594 = code != 0B;
            D.23595 = vmv != 0B;
            D.23596 = D.23594 & D.23595;
            if (D.23596 != 0) goto <D.23597>; else goto <D.23598>;
            <D.23597>:
            D.23599 = vmv->live_range_start;
            if (D.23599 != 0) goto <D.23592>; else goto <D.23600>;
            <D.23600>:
            D.23601 = vmv->live_range_end;
            if (D.23601 != 0) goto <D.23592>; else goto <D.23593>;
            <D.23592>:
            need_loclist = 1;
            <D.23593>:
            <D.23598>:
            if (i == 0) goto <D.23604>; else goto <D.23602>;
            <D.23604>:
            D.23561 = BIT_FIELD_REF <*sig, 8, 80>;
            D.23562 = D.23561 & 64;
            if (D.23562 != 0) goto <D.23605>; else goto <D.23602>;
            <D.23605>:
            D.23564 = method->klass;
            D.23565 = BIT_FIELD_REF <*D.23564, 8, 160>;
            D.23566 = D.23565 & 8;
            if (D.23566 != 0) goto <D.23606>; else goto <D.23607>;
            <D.23606>:
            D.23564 = method->klass;
            t = &D.23564->this_arg;
            goto <D.23608>;
            <D.23607>:
            D.23564 = method->klass;
            t = &D.23564->byval_arg;
            <D.23608>:
            pname = "this";
            goto <D.23603>;
            <D.23602>:
            D.23570 = sig->hasthis;
            D.23571 = (int) D.23570;
            D.23572 = i - D.23571;
            t = sig->params[D.23572];
            D.23570 = sig->hasthis;
            D.23571 = (int) D.23570;
            D.23572 = i - D.23571;
            D.23609 = (unsigned int) D.23572;
            D.23610 = D.23609 * 4;
            D.23611 = names + D.23610;
            pname = *D.23611;
            <D.23603>:
            if (need_loclist != 0) goto <D.23613>; else goto <D.23614>;
            <D.23613>:
            iftmp.48 = 15;
            goto <D.23615>;
            <D.23614>:
            iftmp.48 = 3;
            <D.23615>:
            emit_uleb128 (w, iftmp.48);
            D.23616 = *pname;
            if (D.23616 == 0) goto <D.23617>; else goto <D.23618>;
            <D.23617>:
            D.23570 = sig->hasthis;
            D.23571 = (int) D.23570;
            D.23572 = i - D.23571;
            sprintf (&pname_buf, "param%d", D.23572);
            pname = &pname_buf;
            <D.23618>:
            emit_string (w, pname);
            if (arg == 0B) goto <D.23619>; else goto <D.23622>;
            <D.23622>:
            D.23623 = arg->flags;
            D.23624 = (int) D.23623;
            D.23625 = D.23624 & 2;
            if (D.23625 != 0) goto <D.23619>; else goto <D.23620>;
            <D.23619>:
            D.23626 = mono_defaults.int32_class;
            D.23627 = &D.23626->byval_arg;
            emit_var_type (w, D.23627);
            goto <D.23621>;
            <D.23620>:
            emit_var_type (w, t);
            <D.23621>:
            p = &buf;
            p.49 = p;
            encode_var_location (w, arg, p.49, &p);
            if (need_loclist != 0) goto <D.23629>; else goto <D.23630>;
            <D.23629>:
            vmv->live_range_start = 0;
            D.23601 = vmv->live_range_end;
            if (D.23601 == 0) goto <D.23631>; else goto <D.23632>;
            <D.23631>:
            code_size.50 = (int) code_size;
            vmv->live_range_end = code_size.50;
            <D.23632>:
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23636 = p.51 - buf.52;
            D.23637 = (unsigned int) D.23636;
            D.23601 = vmv->live_range_end;
            D.23638 = (sizetype) D.23601;
            D.23639 = code + D.23638;
            D.23599 = vmv->live_range_start;
            D.23640 = (sizetype) D.23599;
            D.23641 = code + D.23640;
            emit_loclist (w, arg, D.23641, D.23639, &buf, D.23637);
            goto <D.23642>;
            <D.23630>:
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23636 = p.51 - buf.52;
            D.23643 = (unsigned char) D.23636;
            D.23644 = (int) D.23643;
            emit_byte (w, D.23644);
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23636 = p.51 - buf.52;
            emit_bytes (w, &buf, D.23636);
            <D.23642>:
          }
        finally
          {
            pname_buf = {CLOBBER};
          }
      }
      i = i + 1;
      <D.23054>:
      D.23573 = sig->param_count;
      D.23574 = (int) D.23573;
      D.23570 = sig->hasthis;
      D.23571 = (int) D.23570;
      D.23575 = D.23574 + D.23571;
      if (D.23575 > i) goto <D.23053>; else goto <D.23055>;
      <D.23055>:
      monoeg_g_free (names);
      locals_info = mono_debug_lookup_locals (method);
      i = 0;
      goto <D.23066>;
      <D.23065>:
      {
        struct MonoInst * ins;
        char name_buf[128];
        int j;
        struct MonoMethodVar * vmv;
        gboolean need_loclist;
        char * lname;

        try
          {
            i.47 = (unsigned int) i;
            D.23589 = i.47 * 4;
            D.23645 = locals + D.23589;
            ins = *D.23645;
            vmv = 0B;
            need_loclist = 0;
            vmv = find_vmv (cfg, ins);
            D.23594 = code != 0B;
            D.23646 = vmv != 0B;
            D.23647 = D.23594 & D.23646;
            if (D.23647 != 0) goto <D.23648>; else goto <D.23649>;
            <D.23648>:
            D.23650 = vmv->live_range_start;
            if (D.23650 != 0) goto <D.23651>; else goto <D.23652>;
            <D.23651>:
            need_loclist = 1;
            <D.23652>:
            <D.23649>:
            if (need_loclist != 0) goto <D.23654>; else goto <D.23655>;
            <D.23654>:
            iftmp.53 = 12;
            goto <D.23656>;
            <D.23655>:
            iftmp.53 = 11;
            <D.23656>:
            emit_uleb128 (w, iftmp.53);
            lname = 0B;
            if (locals_info != 0B) goto <D.23657>; else goto <D.23658>;
            <D.23657>:
            j = 0;
            goto <D.23064>;
            <D.23063>:
            D.23659 = locals_info->locals;
            j.54 = (unsigned int) j;
            D.23661 = j.54 * 12;
            D.23662 = D.23659 + D.23661;
            D.23663 = D.23662->index;
            if (D.23663 == i) goto <D.23062>; else goto <D.23664>;
            <D.23664>:
            j = j + 1;
            <D.23064>:
            D.23665 = locals_info->num_locals;
            if (D.23665 > j) goto <D.23063>; else goto <D.23062>;
            <D.23062>:
            D.23665 = locals_info->num_locals;
            if (D.23665 > j) goto <D.23666>; else goto <D.23667>;
            <D.23666>:
            D.23659 = locals_info->locals;
            j.54 = (unsigned int) j;
            D.23661 = j.54 * 12;
            D.23662 = D.23659 + D.23661;
            lname = D.23662->name;
            <D.23667>:
            <D.23658>:
            if (lname != 0B) goto <D.23668>; else goto <D.23669>;
            <D.23668>:
            emit_string (w, lname);
            goto <D.23670>;
            <D.23669>:
            sprintf (&name_buf, "V_%d", i);
            emit_string (w, &name_buf);
            <D.23670>:
            if (ins == 0B) goto <D.23671>; else goto <D.23674>;
            <D.23674>:
            D.23675 = ins->flags;
            D.23676 = (int) D.23675;
            D.23677 = D.23676 & 2;
            if (D.23677 != 0) goto <D.23671>; else goto <D.23672>;
            <D.23671>:
            D.23626 = mono_defaults.int32_class;
            D.23627 = &D.23626->byval_arg;
            emit_var_type (w, D.23627);
            goto <D.23673>;
            <D.23672>:
            D.23576 = header->locals[i];
            emit_var_type (w, D.23576);
            <D.23673>:
            p = &buf;
            p.49 = p;
            encode_var_location (w, ins, p.49, &p);
            if (need_loclist != 0) goto <D.23678>; else goto <D.23679>;
            <D.23678>:
            D.23680 = vmv->live_range_end;
            if (D.23680 == 0) goto <D.23681>; else goto <D.23682>;
            <D.23681>:
            code_size.50 = (int) code_size;
            vmv->live_range_end = code_size.50;
            <D.23682>:
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23636 = p.51 - buf.52;
            D.23637 = (unsigned int) D.23636;
            D.23680 = vmv->live_range_end;
            D.23683 = (sizetype) D.23680;
            D.23684 = code + D.23683;
            D.23650 = vmv->live_range_start;
            D.23685 = (sizetype) D.23650;
            D.23686 = code + D.23685;
            emit_loclist (w, ins, D.23686, D.23684, &buf, D.23637);
            goto <D.23687>;
            <D.23679>:
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23636 = p.51 - buf.52;
            D.23643 = (unsigned char) D.23636;
            D.23644 = (int) D.23643;
            emit_byte (w, D.23644);
            p.49 = p;
            p.51 = (int) p.49;
            buf.52 = (int) &buf;
            D.23636 = p.51 - buf.52;
            emit_bytes (w, &buf, D.23636);
            <D.23687>:
          }
        finally
          {
            name_buf = {CLOBBER};
          }
      }
      i = i + 1;
      <D.23066>:
      D.23577 = header->num_locals;
      D.23578 = (int) D.23577;
      if (D.23578 > i) goto <D.23065>; else goto <D.23067>;
      <D.23067>:
      if (locals_info != 0B) goto <D.23688>; else goto <D.23689>;
      <D.23688>:
      mono_debug_symfile_free_locals (locals_info);
      <D.23689>:
      emit_uleb128 (w, 0);
      emit_line (w);
      emit_debug_info_end (w);
      if (unwind_info != 0B) goto <D.23690>; else goto <D.23691>;
      <D.23690>:
      D.23692 = w->fde_index;
      emit_fde (w, D.23692, start_symbol, end_symbol, code, code_size, unwind_info, 1);
      D.23692 = w->fde_index;
      D.23693 = D.23692 + 1;
      w->fde_index = D.23693;
      <D.23691>:
      if (debug_info != 0B) goto <D.23694>; else goto <D.23695>;
      <D.23694>:
      D.23696 = debug_info->code_start;
      if (D.23696 == code) goto <D.23697>; else goto <D.23698>;
      <D.23697>:
      D.23699 = w->collect_line_info;
      if (D.23699 != 0) goto <D.23700>; else goto <D.23701>;
      <D.23700>:
      {
        struct MethodLineNumberInfo * info;

        info = monoeg_malloc0 (20);
        info->method = method;
        D.23702 = monoeg_strdup (start_symbol);
        info->start_symbol = D.23702;
        D.23703 = monoeg_strdup (end_symbol);
        info->end_symbol = D.23703;
        info->code = code;
        info->code_size = code_size;
        D.23704 = w->line_info;
        D.23705 = monoeg_g_slist_prepend (D.23704, info);
        w->line_info = D.23705;
      }
      goto <D.23706>;
      <D.23701>:
      emit_line_number_info (w, method, start_symbol, end_symbol, code, code_size, debug_info);
      <D.23706>:
      <D.23698>:
      <D.23695>:
      emit_line (w);
      mono_metadata_free_mh (header);
    }
  finally
    {
      buf = {CLOBBER};
      p = {CLOBBER};
    }
}


emit_type (struct MonoDwarfWriter * w, struct MonoType * t)
{
  unsigned char D.23707;
  unsigned char D.23708;
  unsigned char D.23711;
  struct MonoClass * D.23717;
  int D.23718;
  int D.23719;
  unsigned int j.55;
  int D.23726;
  unsigned char D.23730;
  unsigned char D.23731;
  int D.23734;
  struct MonoClass * klass;
  int j;
  const char * tdie;

  klass = mono_class_from_mono_type (t);
  D.23707 = BIT_FIELD_REF <*t, 8, 56>;
  D.23708 = D.23707 & 64;
  if (D.23708 != 0) goto <D.23709>; else goto <D.23710>;
  <D.23709>:
  D.23711 = t->type;
  if (D.23711 == 17) goto <D.23712>; else goto <D.23713>;
  <D.23712>:
  tdie = emit_class_dwarf_info (w, klass, 1);
  if (tdie != 0B) goto <D.23714>; else goto <D.23715>;
  <D.23714>:
  return;
  <D.23715>:
  goto <D.23716>;
  <D.23713>:
  emit_class_dwarf_info (w, klass, 0);
  <D.23716>:
  D.23717 = mono_defaults.int_class;
  t = &D.23717->byval_arg;
  <D.23710>:
  j = 0;
  goto <D.22854>;
  <D.22853>:
  D.23718 = basic_types[j].type;
  D.23711 = t->type;
  D.23719 = (int) D.23711;
  if (D.23718 == D.23719) goto <D.22852>; else goto <D.23720>;
  <D.23720>:
  j = j + 1;
  <D.22854>:
  j.55 = (unsigned int) j;
  if (j.55 <= 16) goto <D.22853>; else goto <D.22852>;
  <D.22852>:
  j.55 = (unsigned int) j;
  if (j.55 <= 16) goto <D.23722>; else goto <D.23723>;
  <D.23722>:
  if (j <= 63) goto <D.23724>; else goto <D.23725>;
  <D.23724>:
  D.23726 = base_types_emitted[j];
  if (D.23726 == 0) goto <D.23727>; else goto <D.23728>;
  <D.23727>:
  emit_class_dwarf_info (w, klass, 0);
  base_types_emitted[j] = 1;
  <D.23728>:
  <D.23725>:
  goto <D.23729>;
  <D.23723>:
  D.23711 = t->type;
  D.23719 = (int) D.23711;
  switch (D.23719) <default: <D.22861>, case 15: <D.22860>, case 17: <D.22858>, case 18: <D.22855>, case 20: <D.22857>, case 21: <D.22859>>
  <D.22855>:
  emit_class_dwarf_info (w, klass, 0);
  goto <D.22856>;
  <D.22857>:
  goto <D.22856>;
  <D.22858>:
  D.23730 = BIT_FIELD_REF <*klass, 8, 160>;
  D.23731 = D.23730 & 16;
  if (D.23731 != 0) goto <D.23732>; else goto <D.23733>;
  <D.23732>:
  emit_class_dwarf_info (w, klass, 0);
  <D.23733>:
  goto <D.22856>;
  <D.22859>:
  D.23734 = mono_type_is_struct (t);
  if (D.23734 == 0) goto <D.23735>; else goto <D.23736>;
  <D.23735>:
  emit_class_dwarf_info (w, klass, 0);
  <D.23736>:
  goto <D.22856>;
  <D.22860>:
  goto <D.22856>;
  <D.22861>:
  goto <D.22856>;
  <D.22856>:
  <D.23729>:
}


emit_class_dwarf_info (struct MonoDwarfWriter * w, struct MonoClass * klass, gboolean vtype)
{
  char * D.23744;
  unsigned char D.23748;
  _Bool D.23749;
  _Bool D.23750;
  _Bool D.23751;
  unsigned char D.23754;
  unsigned char D.23757;
  unsigned char D.23758;
  unsigned char D.23762;
  const char * D.23766;
  const char * D.23767;
  const char * iftmp.56;
  char D.23772;
  int D.23775;
  int D.23776;
  struct GHashTable * D.23777;
  struct GHashTable * D.23778;
  struct MonoType * D.23781;
  struct MonoClass * D.23782;
  unsigned int size.57;
  int D.23784;
  struct MonoType * D.23785;
  unsigned char D.23786;
  int D.23787;
  unsigned int k.58;
  _Bool D.23790;
  long int D.23791;
  long int D.23792;
  const char * D.23795;
  int D.22791;
  int iftmp.59;
  int D.22787;
  const char[8] * D.23799;
  unsigned char D.23800;
  int D.23801;
  unsigned char D.23802;
  int D.23803;
  _Bool D.23804;
  _Bool D.23805;
  _Bool D.23806;
  const unsigned char * D.23809;
  unsigned char D.23810;
  int D.23811;
  const unsigned char * D.23812;
  unsigned char D.23813;
  int D.23814;
  _Bool D.23815;
  _Bool D.23816;
  const unsigned char * D.23819;
  unsigned char D.23820;
  int D.23821;
  const unsigned char * D.23822;
  unsigned char D.23823;
  int D.23824;
  _Bool D.23825;
  _Bool D.23826;
  const unsigned char * D.23829;
  unsigned char D.23830;
  int D.23831;
  const unsigned char * D.23832;
  unsigned char D.23833;
  int D.23834;
  const char * D.23836;
  struct MonoType * D.23839;
  short unsigned int D.23840;
  int D.23841;
  int D.23842;
  int D.22801;
  int iftmp.60;
  int D.22800;
  const char[9] * D.23848;
  unsigned char D.23849;
  int D.23850;
  unsigned char D.23851;
  int D.23852;
  _Bool D.23853;
  _Bool D.23854;
  _Bool D.23855;
  const unsigned char * D.23858;
  unsigned char D.23859;
  int D.23860;
  const unsigned char * D.23861;
  unsigned char D.23862;
  int D.23863;
  _Bool D.23864;
  _Bool D.23865;
  const unsigned char * D.23868;
  unsigned char D.23869;
  int D.23870;
  const unsigned char * D.23871;
  unsigned char D.23872;
  int D.23873;
  _Bool D.23874;
  _Bool D.23875;
  const unsigned char * D.23878;
  unsigned char D.23879;
  int D.23880;
  const unsigned char * D.23881;
  unsigned char D.23882;
  int D.23883;
  const char * D.23885;
  const char * D.23888;
  const char * p.61;
  const char * p.62;
  unsigned int D.23891;
  struct MonoType * D.23892;
  unsigned char D.23893;
  int D.23894;
  char D.23895;
  long long int D.23896;
  short unsigned int D.23897;
  long long int D.23898;
  unsigned int D.23899;
  long long int D.23900;
  long long unsigned int D.23901;
  long long int D.23902;
  struct MonoClass * D.23904;
  int D.23908;
  int iftmp.63;
  struct MonoClassField * D.23916;
  guint32 iftmp.64;
  int D.23921;
  unsigned int D.23922;
  guint8 * p.65;
  guint8 * p.66;
  guint8 * p.67;
  int p.68;
  int buf.69;
  int D.23930;
  unsigned char D.23931;
  int D.23932;
  const char * D.23937;
  guint8 * p.70;
  guint8 * p.71;
  unsigned char D.23942;
  int D.23945;
  unsigned int D.23946;
  unsigned int D.23947;
  unsigned int D.23948;
  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.23739>; else goto <D.23740>;
      <D.23739>:
      cache = w->class_to_vtype_die;
      goto <D.23741>;
      <D.23740>:
      cache = w->class_to_die;
      <D.23741>:
      die = monoeg_g_hash_table_lookup (cache, klass);
      if (die != 0B) goto <D.23742>; else goto <D.23743>;
      <D.23742>:
      D.23744 = die;
      return D.23744;
      <D.23743>:
      D.23748 = klass->byval_arg.type;
      D.23749 = D.23748 != 18;
      D.23750 = D.23748 != 28;
      D.23751 = D.23749 & D.23750;
      if (D.23751 != 0) goto <D.23752>; else goto <D.23753>;
      <D.23752>:
      D.23754 = klass->byval_arg.type;
      if (D.23754 != 21) goto <D.23755>; else goto <D.23756>;
      <D.23755>:
      D.23757 = BIT_FIELD_REF <*klass, 8, 160>;
      D.23758 = D.23757 & 16;
      if (D.23758 == 0) goto <D.23759>; else goto <D.23760>;
      <D.23759>:
      D.23754 = klass->byval_arg.type;
      if (D.23754 != 17) goto <D.23747>; else goto <D.23761>;
      <D.23761>:
      if (vtype == 0) goto <D.23747>; else goto <D.23746>;
      <D.23747>:
      D.23754 = klass->byval_arg.type;
      D.23762 = D.23754 + 254;
      if (D.23762 > 11) goto <D.23745>; else goto <D.23763>;
      <D.23763>:
      if (vtype != 0) goto <D.23745>; else goto <D.23746>;
      <D.23745>:
      D.23744 = 0B;
      return D.23744;
      <D.23746>:
      <D.23760>:
      <D.23756>:
      <D.23753>:
      if (emit_namespace != 0) goto <D.23764>; else goto <D.23765>;
      <D.23764>:
      emit_uleb128 (w, 10);
      D.23766 = klass->name_space;
      emit_string (w, D.23766);
      <D.23765>:
      D.23767 = klass->name;
      D.23766 = klass->name_space;
      if (D.23766 != 0B) goto <D.23769>; else goto <D.23770>;
      <D.23769>:
      iftmp.56 = ".";
      goto <D.23771>;
      <D.23770>:
      iftmp.56 = "";
      <D.23771>:
      D.23766 = klass->name_space;
      full_name = monoeg_g_strdup_printf ("%s%s%s", D.23766, iftmp.56, D.23767);
      p = full_name;
      goto <D.22774>;
      <D.22773>:
      D.23772 = *p;
      if (D.23772 == 46) goto <D.23773>; else goto <D.23774>;
      <D.23773>:
      *p = 95;
      <D.23774>:
      p = p + 1;
      <D.22774>:
      D.23772 = *p;
      if (D.23772 != 0) goto <D.22773>; else goto <D.22775>;
      <D.22775>:
      D.23775 = w->tdie_index;
      die = monoeg_g_strdup_printf (".LTDIE_%d", D.23775);
      D.23775 = w->tdie_index;
      pointer_die = monoeg_g_strdup_printf (".LTDIE_%d_POINTER", D.23775);
      D.23775 = w->tdie_index;
      reference_die = monoeg_g_strdup_printf (".LTDIE_%d_REFERENCE", D.23775);
      D.23775 = w->tdie_index;
      D.23776 = D.23775 + 1;
      w->tdie_index = D.23776;
      D.23777 = w->class_to_pointer_die;
      monoeg_g_hash_table_insert_replace (D.23777, klass, pointer_die, 0);
      D.23778 = w->class_to_reference_die;
      monoeg_g_hash_table_insert_replace (D.23778, klass, reference_die, 0);
      monoeg_g_hash_table_insert_replace (cache, klass, die, 0);
      D.23757 = BIT_FIELD_REF <*klass, 8, 160>;
      D.23758 = D.23757 & 16;
      if (D.23758 != 0) goto <D.23779>; else goto <D.23780>;
      <D.23779>:
      {
        int size;

        D.23781 = mono_class_enum_basetype (klass);
        D.23782 = mono_class_from_mono_type (D.23781);
        size = mono_class_value_size (D.23782, 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.22779>;
        <D.22778>:
        D.23784 = basic_types[k].type;
        D.23785 = mono_class_enum_basetype (klass);
        D.23786 = D.23785->type;
        D.23787 = (int) D.23786;
        if (D.23784 == D.23787) goto <D.22777>; else goto <D.23788>;
        <D.23788>:
        k = k + 1;
        <D.22779>:
        k.58 = (unsigned int) k;
        if (k.58 <= 16) goto <D.22778>; else goto <D.22777>;
        <D.22777>:
        k.58 = (unsigned int) k;
        D.23790 = k.58 > 16;
        D.23791 = (long int) D.23790;
        D.23792 = __builtin_expect (D.23791, 0);
        if (D.23792 != 0) goto <D.23793>; else goto <D.23794>;
        <D.23793>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1055, "k < G_N_ELEMENTS (basic_types)");
        <D.23794>:
        D.23795 = basic_types[k].die_name;
        emit_symbol_diff (w, D.23795, ".Ldebug_info_start", 0);
        iter = 0B;
        goto <D.22792>;
        <D.22816>:
        {
          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.23797>; else goto <D.23798>;
                <D.23797>:
                {
                  const unsigned char * __s2;
                  int __result;

                  __s2 = mono_field_get_name (field);
                  D.23799 = "value__";
                  D.23800 = MEM[(const unsigned char *)D.23799];
                  D.23801 = (int) D.23800;
                  D.23802 = *__s2;
                  D.23803 = (int) D.23802;
                  __result = D.23801 - D.23803;
                  {
                    D.23804 = __s1_len != 0;
                    D.23805 = __result == 0;
                    D.23806 = D.23804 & D.23805;
                    if (D.23806 != 0) goto <D.23807>; else goto <D.23808>;
                    <D.23807>:
                    D.23809 = &MEM[(void *)"value__" + 1B];
                    D.23810 = *D.23809;
                    D.23811 = (int) D.23810;
                    D.23812 = __s2 + 1;
                    D.23813 = *D.23812;
                    D.23814 = (int) D.23813;
                    __result = D.23811 - D.23814;
                    D.23815 = __s1_len > 1;
                    D.23805 = __result == 0;
                    D.23816 = D.23815 & D.23805;
                    if (D.23816 != 0) goto <D.23817>; else goto <D.23818>;
                    <D.23817>:
                    D.23819 = &MEM[(void *)"value__" + 2B];
                    D.23820 = *D.23819;
                    D.23821 = (int) D.23820;
                    D.23822 = __s2 + 2;
                    D.23823 = *D.23822;
                    D.23824 = (int) D.23823;
                    __result = D.23821 - D.23824;
                    D.23825 = __s1_len > 2;
                    D.23805 = __result == 0;
                    D.23826 = D.23825 & D.23805;
                    if (D.23826 != 0) goto <D.23827>; else goto <D.23828>;
                    <D.23827>:
                    D.23829 = &MEM[(void *)"value__" + 3B];
                    D.23830 = *D.23829;
                    D.23831 = (int) D.23830;
                    D.23832 = __s2 + 3;
                    D.23833 = *D.23832;
                    D.23834 = (int) D.23833;
                    __result = D.23831 - D.23834;
                    <D.23828>:
                    <D.23818>:
                    <D.23808>:
                  }
                  D.22787 = __result;
                }
                iftmp.59 = D.22787;
                goto <D.23835>;
                <D.23798>:
                D.23836 = mono_field_get_name (field);
                iftmp.59 = __builtin_strcmp ("value__", D.23836);
                <D.23835>:
                D.22791 = iftmp.59;
              }
              if (D.22791 == 0) goto <D.23837>; else goto <D.23838>;
              <D.23837>:
              // predicted unlikely by continue predictor.
              goto <D.22792>;
              <D.23838>:
              D.23839 = field->type;
              D.23840 = D.23839->attrs;
              D.23841 = (int) D.23840;
              D.23842 = D.23841 & 1536;
              if (D.23842 != 0) goto <D.23843>; else goto <D.23844>;
              <D.23843>:
              {
                size_t __s1_len;
                size_t __s2_len;

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

                  __s2 = mono_field_get_name (field);
                  D.23848 = "_Deleted";
                  D.23849 = MEM[(const unsigned char *)D.23848];
                  D.23850 = (int) D.23849;
                  D.23851 = *__s2;
                  D.23852 = (int) D.23851;
                  __result = D.23850 - D.23852;
                  {
                    D.23853 = __s2_len != 0;
                    D.23854 = __result == 0;
                    D.23855 = D.23853 & D.23854;
                    if (D.23855 != 0) goto <D.23856>; else goto <D.23857>;
                    <D.23856>:
                    D.23858 = &MEM[(void *)"_Deleted" + 1B];
                    D.23859 = *D.23858;
                    D.23860 = (int) D.23859;
                    D.23861 = __s2 + 1;
                    D.23862 = *D.23861;
                    D.23863 = (int) D.23862;
                    __result = D.23860 - D.23863;
                    D.23864 = __s2_len > 1;
                    D.23854 = __result == 0;
                    D.23865 = D.23864 & D.23854;
                    if (D.23865 != 0) goto <D.23866>; else goto <D.23867>;
                    <D.23866>:
                    D.23868 = &MEM[(void *)"_Deleted" + 2B];
                    D.23869 = *D.23868;
                    D.23870 = (int) D.23869;
                    D.23871 = __s2 + 2;
                    D.23872 = *D.23871;
                    D.23873 = (int) D.23872;
                    __result = D.23870 - D.23873;
                    D.23874 = __s2_len > 2;
                    D.23854 = __result == 0;
                    D.23875 = D.23874 & D.23854;
                    if (D.23875 != 0) goto <D.23876>; else goto <D.23877>;
                    <D.23876>:
                    D.23878 = &MEM[(void *)"_Deleted" + 3B];
                    D.23879 = *D.23878;
                    D.23880 = (int) D.23879;
                    D.23881 = __s2 + 3;
                    D.23882 = *D.23881;
                    D.23883 = (int) D.23882;
                    __result = D.23880 - D.23883;
                    <D.23877>:
                    <D.23867>:
                    <D.23857>:
                  }
                  D.22800 = __result;
                }
                iftmp.60 = -D.22800;
                goto <D.23884>;
                <D.23847>:
                D.23885 = mono_field_get_name (field);
                iftmp.60 = __builtin_strcmp (D.23885, "_Deleted");
                <D.23884>:
                D.22801 = iftmp.60;
              }
              if (D.22801 == 0) goto <D.23886>; else goto <D.23887>;
              <D.23886>:
              // predicted unlikely by continue predictor.
              goto <D.22792>;
              <D.23887>:
              <D.23844>:
              emit_uleb128 (w, 9);
              D.23888 = mono_field_get_name (field);
              emit_string (w, D.23888);
              p.61 = mono_class_get_field_default_value (field, &def_type);
              p = p.61;
              p.62 = p;
              D.23891 = mono_metadata_decode_blob_size (p.62, &p);
              len = (int) D.23891;
              D.23892 = mono_class_enum_basetype (klass);
              D.23893 = D.23892->type;
              D.23894 = (int) D.23893;
              switch (D.23894) <default: <D.22815>, case 2: <D.22804>, case 3: <D.22808>, case 4: <D.22803>, case 5: <D.22802>, case 6: <D.22807>, case 7: <D.22806>, case 8: <D.22810>, case 9: <D.22809>, case 10: <D.22812>, case 11: <D.22811>, case 24: <D.22813>, case 25: <D.22814>>
              <D.22802>:
              <D.22803>:
              <D.22804>:
              p.62 = p;
              D.23895 = *p.62;
              D.23896 = (long long int) D.23895;
              emit_sleb128 (w, D.23896);
              goto <D.22805>;
              <D.22806>:
              <D.22807>:
              <D.22808>:
              p.62 = p;
              D.23897 = MEM[(const guint16 *)p.62];
              D.23898 = (long long int) D.23897;
              emit_sleb128 (w, D.23898);
              goto <D.22805>;
              <D.22809>:
              <D.22810>:
              p.62 = p;
              D.23899 = MEM[(const guint32 *)p.62];
              D.23900 = (long long int) D.23899;
              emit_sleb128 (w, D.23900);
              goto <D.22805>;
              <D.22811>:
              <D.22812>:
              p.62 = p;
              D.23901 = MEM[(const guint64 *)p.62];
              D.23902 = (long long int) D.23901;
              emit_sleb128 (w, D.23902);
              goto <D.22805>;
              <D.22813>:
              <D.22814>:
              p.62 = p;
              D.23899 = MEM[(const guint32 *)p.62];
              D.23900 = (long long int) D.23899;
              emit_sleb128 (w, D.23900);
              goto <D.22805>;
              <D.22815>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "dwarfwriter.c", 1103);
              <D.22805>:
            }
          finally
            {
              p = {CLOBBER};
              def_type = {CLOBBER};
            }
        }
        <D.22792>:
        field = mono_class_get_fields (klass, &iter);
        if (field != 0B) goto <D.22816>; else goto <D.22817>;
        <D.22817>:
        has_children = 1;
      }
      goto <D.23903>;
      <D.23780>:
      {
        guint8 buf[128];
        guint8 * p;
        char * parent_die;

        try
          {
            D.23904 = klass->parent;
            if (D.23904 != 0B) goto <D.23905>; else goto <D.23906>;
            <D.23905>:
            D.23904 = klass->parent;
            parent_die = emit_class_dwarf_info (w, D.23904, 0);
            goto <D.23907>;
            <D.23906>:
            parent_die = 0B;
            <D.23907>:
            iter = 0B;
            goto <D.22821>;
            <D.22822>:
            D.23839 = field->type;
            D.23840 = D.23839->attrs;
            D.23841 = (int) D.23840;
            D.23908 = D.23841 & 16;
            if (D.23908 != 0) goto <D.23909>; else goto <D.23910>;
            <D.23909>:
            // predicted unlikely by continue predictor.
            goto <D.22821>;
            <D.23910>:
            D.23839 = field->type;
            emit_type (w, D.23839);
            <D.22821>:
            field = mono_class_get_fields (klass, &iter);
            if (field != 0B) goto <D.22822>; else goto <D.22823>;
            <D.22823>:
            iter = 0B;
            if (parent_die != 0B) goto <D.23912>; else goto <D.23915>;
            <D.23915>:
            D.23916 = mono_class_get_fields (klass, &iter);
            if (D.23916 != 0B) goto <D.23912>; else goto <D.23913>;
            <D.23912>:
            iftmp.63 = 1;
            goto <D.23914>;
            <D.23913>:
            iftmp.63 = 0;
            <D.23914>:
            has_children = iftmp.63;
            emit_label (w, die);
            if (has_children != 0) goto <D.23918>; else goto <D.23919>;
            <D.23918>:
            iftmp.64 = 5;
            goto <D.23920>;
            <D.23919>:
            iftmp.64 = 17;
            <D.23920>:
            emit_uleb128 (w, iftmp.64);
            emit_string (w, full_name);
            D.23921 = klass->instance_size;
            D.23922 = (unsigned int) D.23921;
            emit_uleb128 (w, D.23922);
            if (parent_die != 0B) goto <D.23923>; else goto <D.23924>;
            <D.23923>:
            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.23930 = p.68 - buf.69;
            D.23931 = (unsigned char) D.23930;
            D.23932 = (int) D.23931;
            emit_byte (w, D.23932);
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.23930 = p.68 - buf.69;
            emit_bytes (w, &buf, D.23930);
            <D.23924>:
            iter = 0B;
            goto <D.22824>;
            <D.22825>:
            D.23839 = field->type;
            D.23840 = D.23839->attrs;
            D.23841 = (int) D.23840;
            D.23908 = D.23841 & 16;
            if (D.23908 != 0) goto <D.23933>; else goto <D.23934>;
            <D.23933>:
            // predicted unlikely by continue predictor.
            goto <D.22824>;
            <D.23934>:
            D.23839 = field->type;
            fdie = get_type_die (w, D.23839);
            if (fdie != 0B) goto <D.23935>; else goto <D.23936>;
            <D.23935>:
            emit_uleb128 (w, 6);
            D.23937 = field->name;
            emit_string (w, D.23937);
            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.23757 = BIT_FIELD_REF <*klass, 8, 160>;
            D.23942 = D.23757 & 8;
            if (D.23942 != 0) goto <D.23943>; else goto <D.23940>;
            <D.23943>:
            if (vtype != 0) goto <D.23944>; else goto <D.23940>;
            <D.23944>:
            p.65 = p;
            D.23945 = field->offset;
            D.23946 = (unsigned int) D.23945;
            D.23947 = D.23946 + 4294967288;
            encode_uleb128 (D.23947, p.65, &p);
            goto <D.23941>;
            <D.23940>:
            p.65 = p;
            D.23945 = field->offset;
            D.23948 = (unsigned int) D.23945;
            encode_uleb128 (D.23948, p.65, &p);
            <D.23941>:
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.23930 = p.68 - buf.69;
            D.23931 = (unsigned char) D.23930;
            D.23932 = (int) D.23931;
            emit_byte (w, D.23932);
            p.65 = p;
            p.68 = (int) p.65;
            buf.69 = (int) &buf;
            D.23930 = p.68 - buf.69;
            emit_bytes (w, &buf, D.23930);
            <D.23936>:
            <D.22824>:
            field = mono_class_get_fields (klass, &iter);
            if (field != 0B) goto <D.22825>; else goto <D.22826>;
            <D.22826>:
          }
        finally
          {
            buf = {CLOBBER};
            p = {CLOBBER};
          }
      }
      <D.23903>:
      if (has_children != 0) goto <D.23949>; else goto <D.23950>;
      <D.23949>:
      emit_uleb128 (w, 0);
      <D.23950>:
      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.23951>; else goto <D.23952>;
      <D.23951>:
      emit_uleb128 (w, 0);
      <D.23952>:
      D.23744 = die;
      return D.23744;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


get_type_die (struct MonoDwarfWriter * w, struct MonoType * t)
{
  unsigned char D.23957;
  unsigned char D.23958;
  unsigned char D.23961;
  struct GHashTable * D.23964;
  struct MonoClass * D.23966;
  int D.23967;
  int D.23968;
  unsigned int j.72;
  struct GHashTable * D.23974;
  unsigned char D.23975;
  unsigned char D.23976;
  int D.23980;
  _Bool D.23984;
  long int D.23985;
  long int D.23986;
  const char * D.23989;
  struct MonoClass * klass;
  int j;
  const char * tdie;

  klass = mono_class_from_mono_type (t);
  D.23957 = BIT_FIELD_REF <*t, 8, 56>;
  D.23958 = D.23957 & 64;
  if (D.23958 != 0) goto <D.23959>; else goto <D.23960>;
  <D.23959>:
  D.23961 = t->type;
  if (D.23961 == 17) goto <D.23962>; else goto <D.23963>;
  <D.23962>:
  D.23964 = w->class_to_pointer_die;
  tdie = monoeg_g_hash_table_lookup (D.23964, klass);
  goto <D.23965>;
  <D.23963>:
  tdie = get_class_die (w, klass, 0);
  <D.23965>:
  D.23966 = mono_defaults.int_class;
  t = &D.23966->byval_arg;
  <D.23960>:
  j = 0;
  goto <D.22837>;
  <D.22836>:
  D.23967 = basic_types[j].type;
  D.23961 = t->type;
  D.23968 = (int) D.23961;
  if (D.23967 == D.23968) goto <D.22835>; else goto <D.23969>;
  <D.23969>:
  j = j + 1;
  <D.22837>:
  j.72 = (unsigned int) j;
  if (j.72 <= 16) goto <D.22836>; else goto <D.22835>;
  <D.22835>:
  j.72 = (unsigned int) j;
  if (j.72 <= 16) goto <D.23971>; else goto <D.23972>;
  <D.23971>:
  tdie = basic_types[j].die_name;
  goto <D.23973>;
  <D.23972>:
  D.23961 = t->type;
  D.23968 = (int) D.23961;
  switch (D.23968) <default: <D.22844>, case 15: <D.22843>, case 17: <D.22841>, case 18: <D.22838>, case 20: <D.22840>, case 21: <D.22842>>
  <D.22838>:
  D.23974 = w->class_to_reference_die;
  tdie = monoeg_g_hash_table_lookup (D.23974, klass);
  goto <D.22839>;
  <D.22840>:
  tdie = ".LDIE_OBJECT";
  goto <D.22839>;
  <D.22841>:
  D.23975 = BIT_FIELD_REF <*klass, 8, 160>;
  D.23976 = D.23975 & 16;
  if (D.23976 != 0) goto <D.23977>; else goto <D.23978>;
  <D.23977>:
  tdie = get_class_die (w, klass, 0);
  goto <D.23979>;
  <D.23978>:
  tdie = ".LDIE_I4";
  <D.23979>:
  goto <D.22839>;
  <D.22842>:
  D.23980 = mono_type_is_struct (t);
  if (D.23980 == 0) goto <D.23981>; else goto <D.23982>;
  <D.23981>:
  D.23974 = w->class_to_reference_die;
  tdie = monoeg_g_hash_table_lookup (D.23974, klass);
  goto <D.23983>;
  <D.23982>:
  tdie = ".LDIE_I4";
  <D.23983>:
  goto <D.22839>;
  <D.22843>:
  tdie = ".LDIE_I";
  goto <D.22839>;
  <D.22844>:
  tdie = ".LDIE_I4";
  goto <D.22839>;
  <D.22839>:
  <D.23973>:
  D.23984 = tdie == 0B;
  D.23985 = (long int) D.23984;
  D.23986 = __builtin_expect (D.23985, 0);
  if (D.23986 != 0) goto <D.23987>; else goto <D.23988>;
  <D.23987>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1259, "tdie");
  <D.23988>:
  D.23989 = tdie;
  return D.23989;
}


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

  if (vtype != 0) goto <D.23991>; else goto <D.23992>;
  <D.23991>:
  cache = w->class_to_vtype_die;
  goto <D.23993>;
  <D.23992>:
  cache = w->class_to_die;
  <D.23993>:
  D.23994 = monoeg_g_hash_table_lookup (cache, klass);
  return D.23994;
}


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

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

    D.23996 = (unsigned char) value;
    b = D.23996 & 127;
    value = value >> 7;
    if (value != 0) goto <D.23997>; else goto <D.23998>;
    <D.23997>:
    b = b | 128;
    <D.23998>:
    p.73 = p;
    p = p.73 + 1;
    *p.73 = b;
  }
  if (value != 0) goto <D.22570>; else goto <D.22571>;
  <D.22571>:
  *endbuf = p;
}


find_vmv (struct MonoCompile * cfg, struct MonoInst * ins)
{
  struct MonoInst * * D.24000;
  unsigned int j.74;
  unsigned int D.24004;
  struct MonoInst * * D.24005;
  struct MonoInst * D.24006;
  unsigned int j.75;
  unsigned int D.24009;
  struct MonoMethodVar * D.24012;
  struct MonoMethodVar * D.24013;
  unsigned int D.24014;
  int j;

  D.24000 = cfg->varinfo;
  if (D.24000 != 0B) goto <D.24001>; else goto <D.24002>;
  <D.24001>:
  j = 0;
  goto <D.23018>;
  <D.23017>:
  D.24000 = cfg->varinfo;
  j.74 = (unsigned int) j;
  D.24004 = j.74 * 4;
  D.24005 = D.24000 + D.24004;
  D.24006 = *D.24005;
  if (D.24006 == ins) goto <D.23016>; else goto <D.24007>;
  <D.24007>:
  j = j + 1;
  <D.23018>:
  j.75 = (unsigned int) j;
  D.24009 = cfg->num_varinfo;
  if (j.75 < D.24009) goto <D.23017>; else goto <D.23016>;
  <D.23016>:
  j.75 = (unsigned int) j;
  D.24009 = cfg->num_varinfo;
  if (j.75 < D.24009) goto <D.24010>; else goto <D.24011>;
  <D.24010>:
  D.24013 = cfg->vars;
  j.74 = (unsigned int) j;
  D.24014 = j.74 * 56;
  D.24012 = D.24013 + D.24014;
  return D.24012;
  <D.24011>:
  <D.24002>:
  D.24012 = 0B;
  return D.24012;
}


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

  D.24017 = __builtin_object_size (__s, 1);
  D.24016 = __builtin___sprintf_chk (__s, 1, D.24017, __fmt, __builtin_va_arg_pack ());
  return D.24016;
}


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.24021;
  int D.24022;
  int D.24023;
  short unsigned int D.24027;
  guint8 * p.76;
  int D.24031;
  int D.24032;
  unsigned char D.24033;
  unsigned char D.24034;
  guint8 * p.77;
  guint8 * p.78;
  guint8 * p.79;
  int D.24041;
  int D.24042;
  unsigned char D.24043;
  unsigned char D.24044;
  int D.24045;
  guint8 * p.80;
  guint8 * p.81;

  if (ins == 0B) goto <D.24019>; else goto <D.24020>;
  <D.24020>:
  D.24021 = ins->flags;
  D.24022 = (int) D.24021;
  D.24023 = D.24022 & 2;
  if (D.24023 != 0) goto <D.24024>; else goto <D.24025>;
  <D.24024>:
  goto <D.24026>;
  <D.24025>:
  D.24027 = ins->opcode;
  if (D.24027 == 366) goto <D.24028>; else goto <D.24029>;
  <D.24028>:
  p.76 = p;
  D.24031 = ins->dreg;
  D.24032 = mono_hw_reg_to_dwarf_reg (D.24031);
  D.24033 = (unsigned char) D.24032;
  D.24034 = D.24033 + 80;
  *p.76 = D.24034;
  p.76 = p;
  p.77 = p.76 + 1;
  p = p.77;
  goto <D.24036>;
  <D.24029>:
  D.24027 = ins->opcode;
  if (D.24027 == 367) goto <D.24037>; else goto <D.24038>;
  <D.24037>:
  p.76 = p;
  p.78 = p.76;
  p.79 = p.78 + 1;
  p = p.79;
  D.24041 = ins->sreg1;
  D.24042 = mono_hw_reg_to_dwarf_reg (D.24041);
  D.24043 = (unsigned char) D.24042;
  D.24044 = D.24043 + 112;
  *p.78 = D.24044;
  p.76 = p;
  D.24045 = ins->data.op[0].const_val;
  encode_sleb128 (D.24045, p.76, &p);
  goto <D.24046>;
  <D.24038>:
  p.76 = p;
  p.80 = p.76;
  p.81 = p.80 + 1;
  p = p.81;
  *p.80 = 80;
  <D.24046>:
  <D.24036>:
  <D.24026>:
  <D.24019>:
  p.76 = p;
  *endp = p.76;
}


encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf)
{
  _Bool D.24049;
  unsigned char D.24050;
  unsigned int D.24053;
  int D.24054;
  int D.24055;
  int D.24056;
  int D.24062;
  int D.24063;
  guint8 * p.82;
  gboolean more;
  gboolean negative;
  guint32 size;
  guint8 byte;
  guint8 * p;

  more = 1;
  D.24049 = value < 0;
  negative = (gboolean) D.24049;
  size = 32;
  p = buf;
  goto <D.22583>;
  <D.22582>:
  D.24050 = (unsigned char) value;
  byte = D.24050 & 127;
  value = value >> 7;
  if (negative != 0) goto <D.24051>; else goto <D.24052>;
  <D.24051>:
  D.24053 = size + 4294967289;
  D.24054 = (int) D.24053;
  D.24055 = 1 << D.24054;
  D.24056 = -D.24055;
  value = D.24056 | value;
  <D.24052>:
  if (value == 0) goto <D.24061>; else goto <D.24057>;
  <D.24061>:
  D.24062 = (int) byte;
  D.24063 = D.24062 & 64;
  if (D.24063 == 0) goto <D.24058>; else goto <D.24057>;
  <D.24057>:
  if (value == -1) goto <D.24064>; else goto <D.24059>;
  <D.24064>:
  D.24062 = (int) byte;
  D.24063 = D.24062 & 64;
  if (D.24063 != 0) goto <D.24058>; else goto <D.24059>;
  <D.24058>:
  more = 0;
  goto <D.24060>;
  <D.24059>:
  byte = byte | 128;
  <D.24060>:
  p.82 = p;
  p = p.82 + 1;
  *p.82 = byte;
  <D.22583>:
  if (more != 0) goto <D.22582>; else goto <D.22584>;
  <D.22584>:
  *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.24066;
  int D.24067;
  int D.24068;
  unsigned char D.24069;
  int D.24070;
  unsigned int D.24071;
  unsigned char D.24072;
  int D.24073;
  int expr_len.83;
  char label[128];

  try
    {
      emit_push_section (w, ".debug_loc", 0);
      D.24066 = w->loclist_index;
      D.24067 = D.24066;
      D.24068 = D.24067 + 1;
      w->loclist_index = D.24068;
      sprintf (&label, ".Lloclist_%d", D.24067);
      emit_label (w, &label);
      emit_pointer_value (w, loclist_begin_addr);
      emit_pointer_value (w, loclist_end_addr);
      D.24069 = (unsigned char) expr_len;
      D.24070 = (int) D.24069;
      emit_byte (w, D.24070);
      D.24071 = expr_len / 256;
      D.24072 = (unsigned char) D.24071;
      D.24073 = (int) D.24072;
      emit_byte (w, D.24073);
      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.24075;

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


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

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


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.24082;
  long int D.24083;
  long int D.24084;
  int code_size.84;
  struct GSList * D.24089;
  unsigned int i.85;
  unsigned int D.24095;
  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.24077>; else goto <D.24078>;
      <D.24077>:
      emit_pointer (w, start_symbol);
      if (end_symbol != 0B) goto <D.24079>; else goto <D.24080>;
      <D.24079>:
      emit_symbol_diff (w, end_symbol, start_symbol, 0);
      goto <D.24081>;
      <D.24080>:
      D.24082 = code_size == 0;
      D.24083 = (long int) D.24082;
      D.24084 = __builtin_expect (D.24083, 0);
      if (D.24084 != 0) goto <D.24085>; else goto <D.24086>;
      <D.24085>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 395, "code_size");
      <D.24086>:
      code_size.84 = (int) code_size;
      emit_int32 (w, code_size.84);
      <D.24081>:
      goto <D.24088>;
      <D.24078>:
      emit_pointer_value (w, code);
      code_size.84 = (int) code_size;
      emit_int32 (w, code_size.84);
      <D.24088>:
      l = unwind_ops;
      D.24089 = w->cie_program;
      if (D.24089 != 0B) goto <D.24090>; else goto <D.24091>;
      <D.24090>:
      {
        int i;

        i = 0;
        goto <D.22624>;
        <D.22623>:
        if (l != 0B) goto <D.24092>; else goto <D.24093>;
        <D.24092>:
        l = l->next;
        <D.24093>:
        i = i + 1;
        <D.22624>:
        i.85 = (unsigned int) i;
        D.24089 = w->cie_program;
        D.24095 = monoeg_g_slist_length (D.24089);
        if (i.85 < D.24095) goto <D.22623>; else goto <D.22625>;
        <D.22625>:
      }
      <D.24091>:
      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.24098;

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


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

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


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.24100;
  int D.24101;
  int D.24102;

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