__attribute__((visibility ("hidden"))) 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.23412; int D.23413; _Bool D.23414; long int D.23415; long int D.23416; int D.23421; struct FILE * D.23427; const char * D.23428; struct GHashTable * D.23429; struct GHashTable * D.23430; struct GHashTable * D.23431; struct GHashTable * D.23432; struct MonoDwarfWriter * D.23433; struct MonoDwarfWriter * w; w = monoeg_malloc0 (152); w->w = writer; w->il_file = il_file; w->il_file_line_index = il_file_start_line; w->appending = appending; if (appending != 0) goto ; else goto ; : D.23412 = w->w; D.23413 = img_writer_subsections_supported (D.23412); D.23414 = D.23413 == 0; D.23415 = (long int) D.23414; D.23416 = __builtin_expect (D.23415, 0); if (D.23416 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 94, "img_writer_subsections_supported (w->w)"); : : w->emit_line = 1; if (appending != 0) goto ; else goto ; : D.23412 = w->w; D.23421 = img_writer_subsections_supported (D.23412); if (D.23421 == 0) goto ; else goto ; : w->emit_line = 0; : goto ; : w->collect_line_info = 1; : if (emit_line_numbers == 0) goto ; else goto ; : w->emit_line = 0; w->collect_line_info = 0; : D.23412 = w->w; D.23427 = img_writer_get_fp (D.23412); w->fp = D.23427; D.23412 = w->w; D.23428 = img_writer_get_temp_label_prefix (D.23412); w->temp_prefix = D.23428; D.23429 = monoeg_g_hash_table_new (0B, 0B); w->class_to_die = D.23429; D.23430 = monoeg_g_hash_table_new (0B, 0B); w->class_to_vtype_die = D.23430; D.23431 = monoeg_g_hash_table_new (0B, 0B); w->class_to_pointer_die = D.23431; D.23432 = monoeg_g_hash_table_new (0B, 0B); w->class_to_reference_die = D.23432; w->cur_file_index = -1; D.23433 = w; return D.23433; } __attribute__((visibility ("hidden"))) mono_dwarf_writer_destroy (struct MonoDwarfWriter * w) { monoeg_g_free (w); } __attribute__((visibility ("hidden"))) mono_dwarf_writer_get_il_file_line_index (struct MonoDwarfWriter * w) { int D.23435; D.23435 = w->il_file_line_index; return D.23435; } mono_dwarf_escape_path (const char * name) { char * D.23437; long unsigned int D.23440; int D.23441; int D.23442; long unsigned int D.23443; sizetype D.23444; const char * D.23445; char D.23446; int j.0; sizetype D.23450; char * D.23451; int j.1; sizetype D.23453; char * D.23454; int j.2; sizetype D.23457; char * D.23458; char * D.23459; D.23437 = __builtin_strchr (name, 92); if (D.23437 != 0B) goto ; else goto ; : { char * s; int len; int i; int j; D.23440 = __strlen_g (name); len = (int) D.23440; D.23441 = len + 1; D.23442 = D.23441 * 2; D.23443 = (long unsigned int) D.23442; s = monoeg_malloc0 (D.23443); j = 0; i = 0; goto ; : D.23444 = (sizetype) i; D.23445 = name + D.23444; D.23446 = *D.23445; if (D.23446 == 92) goto ; else goto ; : j.0 = j; j = j.0 + 1; D.23450 = (sizetype) j.0; D.23451 = s + D.23450; *D.23451 = 92; j.1 = j; j = j.1 + 1; D.23453 = (sizetype) j.1; D.23454 = s + D.23453; *D.23454 = 92; goto ; : j.2 = j; j = j.2 + 1; D.23457 = (sizetype) j.2; D.23458 = s + D.23457; D.23444 = (sizetype) i; D.23445 = name + D.23444; D.23446 = *D.23445; *D.23458 = D.23446; : i = i + 1; : if (i < len) goto ; else goto ; : D.23459 = s; return D.23459; } : D.23459 = monoeg_strdup (name); return D.23459; } __attribute__((__gnu_inline__)) __strlen_g (const char * __str) { size_t D.23461; long int __ptr.3; long int __str.4; long int D.23464; char * __ptr; char * __tmp; __ptr = 0B; __tmp = __str; __asm__ __volatile__(" la 0,0 0: srst %0,%1 jo 0b " : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc"); __ptr.3 = (long int) __ptr; __str.4 = (long int) __str; D.23464 = __ptr.3 - __str.4; D.23461 = (size_t) D.23464; return D.23461; } monoeg_strdup (const gchar * str) { gchar * D.23468; if (str != 0B) goto ; else goto ; : D.23468 = __strdup (str); return D.23468; : D.23468 = 0B; return D.23468; } __attribute__((visibility ("hidden"))) mono_dwarf_writer_emit_base_info (struct MonoDwarfWriter * w, const char * cu_name, struct GSList * base_unwind_program) { struct MonoImageWriter * D.23470; int D.23471; int D.23474; int D.23477; const char * D.23481; int D.23482; unsigned char D.23483; int D.23484; unsigned char D.23485; const char * D.23486; unsigned int i.5; 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, ¶m_attr, 6); emit_dwarf_abbrev (w, 15, 5, 0, ¶m_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, 8); D.23470 = w->w; D.23471 = img_writer_subsections_supported (D.23470); if (D.23471 != 0) goto ; else goto ; : D.23474 = w->appending; if (D.23474 != 0) goto ; else goto ; : emit_section_change (w, ".debug_info", 1); emit_byte (w, 0); emit_label (w, ".Ldebug_info_end"); emit_section_change (w, ".debug_info", 0); : : 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.23477 = w->emit_line; if (D.23477 != 0) goto ; else goto ; : emit_symbol_diff (w, ".Ldebug_line_start", ".Ldebug_line_section_start", 0); goto ; : emit_pointer_value (w, 0B); : i = 0; goto ; : D.23481 = basic_types[i].die_name; emit_label (w, D.23481); emit_uleb128 (w, 4); D.23482 = basic_types[i].size; D.23483 = (unsigned char) D.23482; emit_byte (w, D.23483); D.23484 = basic_types[i].encoding; D.23485 = (unsigned char) D.23484; emit_byte (w, D.23485); D.23486 = basic_types[i].name; emit_string (w, D.23486); i = i + 1; : i.5 = (unsigned int) i; if (i.5 <= 16) goto ; else goto ; : 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.6; unsigned int tag.7; unsigned char D.23490; long unsigned int D.23491; long unsigned int D.23492; int * D.23493; int D.23494; unsigned int D.23495; int i; code.6 = (unsigned int) code; emit_uleb128 (w, code.6); tag.7 = (unsigned int) tag; emit_uleb128 (w, tag.7); D.23490 = (unsigned char) has_child; emit_byte (w, D.23490); i = 0; goto ; : D.23491 = (long unsigned int) i; D.23492 = D.23491 * 4; D.23493 = attrs + D.23492; D.23494 = *D.23493; D.23495 = (unsigned int) D.23494; emit_uleb128 (w, D.23495); i = i + 1; : if (i < attrs_len) goto ; else goto ; : emit_uleb128 (w, 0); emit_uleb128 (w, 0); } emit_int16 (struct MonoDwarfWriter * w, int value) { struct MonoImageWriter * D.23496; D.23496 = w->w; img_writer_emit_int16 (D.23496, value); } emit_int32 (struct MonoDwarfWriter * w, int value) { struct MonoImageWriter * D.23497; D.23497 = w->w; img_writer_emit_int32 (D.23497, value); } emit_symbol_diff (struct MonoDwarfWriter * w, const char * end, const char * start, int offset) { struct MonoImageWriter * D.23498; D.23498 = w->w; img_writer_emit_symbol_diff (D.23498, end, start, offset); } emit_pointer_value (struct MonoDwarfWriter * w, void * ptr) { long int ptr.8; gssize val; try { ptr.8 = (long int) ptr; val = ptr.8; emit_bytes (w, &val, 8); } finally { val = {CLOBBER}; } } emit_bytes (struct MonoDwarfWriter * w, const guint8 * buf, int size) { struct MonoImageWriter * D.23500; D.23500 = w->w; img_writer_emit_bytes (D.23500, buf, size); } __attribute__((__unused__)) emit_uleb128 (struct MonoDwarfWriter * w, guint32 value) { unsigned char D.23501; : { guint8 b; D.23501 = (unsigned char) value; b = D.23501 & 127; value = value >> 7; if (value != 0) goto ; else goto ; : b = b | 128; : emit_byte (w, b); } if (value != 0) goto ; else goto ; : } emit_byte (struct MonoDwarfWriter * w, guint8 val) { struct MonoImageWriter * D.23504; D.23504 = w->w; img_writer_emit_byte (D.23504, val); } emit_string (struct MonoDwarfWriter * w, const char * value) { struct MonoImageWriter * D.23505; D.23505 = w->w; img_writer_emit_string (D.23505, value); } emit_debug_info_end (struct MonoDwarfWriter * w) { } emit_section_change (struct MonoDwarfWriter * w, const char * section_name, int subsection_index) { struct MonoImageWriter * D.23506; D.23506 = w->w; img_writer_emit_section_change (D.23506, section_name, subsection_index); } emit_label (struct MonoDwarfWriter * w, const char * name) { struct MonoImageWriter * D.23507; D.23507 = w->w; img_writer_emit_label (D.23507, name); } emit_cie (struct MonoDwarfWriter * w) { int D.23508; long int D.23509; int D.23510; unsigned int D.23511; struct GSList * D.23512; unsigned int uw_info_len.9; int uw_info_len.10; 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.23508 = mono_unwind_get_dwarf_data_align (); D.23509 = (long int) D.23508; emit_sleb128 (w, D.23509); D.23510 = mono_unwind_get_dwarf_pc_reg (); D.23511 = (unsigned int) D.23510; emit_uleb128 (w, D.23511); D.23512 = w->cie_program; w->cie_program = D.23512; D.23512 = w->cie_program; if (D.23512 != 0B) goto ; else goto ; : { guint32 uw_info_len; guint8 * uw_info; try { D.23512 = w->cie_program; uw_info = mono_unwind_ops_encode (D.23512, &uw_info_len); uw_info_len.9 = uw_info_len; uw_info_len.10 = (int) uw_info_len.9; emit_bytes (w, uw_info, uw_info_len.10); monoeg_g_free (uw_info); } finally { uw_info_len = {CLOBBER}; } } : emit_alignment (w, 8); emit_label (w, ".Lcie0_end"); } __attribute__((__unused__)) emit_sleb128 (struct MonoDwarfWriter * w, gint64 value) { _Bool D.23517; unsigned char D.23518; unsigned int D.23521; long int D.23522; long int D.23523; int D.23529; int D.23530; gboolean more; gboolean negative; guint32 size; guint8 byte; more = 1; D.23517 = value < 0; negative = (gboolean) D.23517; size = 64; goto ; : D.23518 = (unsigned char) value; byte = D.23518 & 127; value = value >> 7; if (negative != 0) goto ; else goto ; : D.23521 = size + 4294967289; D.23522 = 1 << D.23521; D.23523 = -D.23522; value = D.23523 | value; : if (value == 0) goto ; else goto ; : D.23529 = (int) byte; D.23530 = D.23529 & 64; if (D.23530 == 0) goto ; else goto ; : if (value == -1) goto ; else goto ; : D.23529 = (int) byte; D.23530 = D.23529 & 64; if (D.23530 != 0) goto ; else goto ; : more = 0; goto ; : byte = byte | 128; : emit_byte (w, byte); : if (more != 0) goto ; else goto ; : } emit_alignment (struct MonoDwarfWriter * w, int size) { struct MonoImageWriter * D.23532; D.23532 = w->w; img_writer_emit_alignment (D.23532, size); } __attribute__((visibility ("hidden"))) mono_dwarf_writer_close (struct MonoDwarfWriter * w) { int D.23533; int D.23536; D.23533 = w->appending; if (D.23533 == 0) goto ; else goto ; : emit_section_change (w, ".debug_info", 0); emit_byte (w, 0); emit_label (w, ".Ldebug_info_end"); : D.23536 = w->collect_line_info; if (D.23536 != 0) goto ; else goto ; : emit_all_line_number_info (w); : } emit_all_line_number_info (struct MonoDwarfWriter * w) { int D.23539; _Bool D.23540; long int D.23541; long int D.23542; struct GSList * D.23545; struct MonoMethod * D.23546; struct GPtrArray * source_file_list.11; void * * D.23550; long unsigned int D.23551; long unsigned int D.23552; void * * D.23553; char * D.23554; unsigned int D.23555; unsigned int i.12; struct GHashTable * D.23557; int D.23558; long unsigned int D.23559; const void * D.23560; int D.23561; void * D.23564; long int D.23565; int D.23568; int D.23569; int D.23570; long unsigned int D.23571; void * D.23572; int D.23574; char * D.23575; int D.23576; void * D.23579; long int D.23580; char * D.23584; unsigned int dir_index.13; struct MonoMethod * D.23586; struct MonoDomain * D.23587; char * D.23588; char * D.23589; guint8 * D.23590; unsigned int D.23591; int i; struct GHashTable * dir_to_index; struct GHashTable * index_to_dir; struct GSList * l; struct GSList * info_list; D.23539 = w->collect_line_info; D.23540 = D.23539 == 0; D.23541 = (long int) D.23540; D.23542 = __builtin_expect (D.23541, 0); if (D.23542 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 709, "w->collect_line_info"); : add_line_number_file_name (w, "", 0, 0); D.23545 = w->line_info; info_list = monoeg_g_slist_reverse (D.23545); l = info_list; goto ; : { struct MethodLineNumberInfo * info; struct MonoDebugMethodInfo * minfo; char * source_file; struct GPtrArray * source_file_list; try { info = l->data; D.23546 = info->method; minfo = mono_debug_lookup_method (D.23546); if (minfo == 0B) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : mono_debug_symfile_get_line_numbers_full (minfo, &source_file, &source_file_list, 0B, 0B, 0B, 0B, 0B); i = 0; goto ; : { struct MonoDebugSourceInfo * sinfo; source_file_list.11 = source_file_list; D.23550 = source_file_list.11->pdata; D.23551 = (long unsigned int) i; D.23552 = D.23551 * 8; D.23553 = D.23550 + D.23552; sinfo = *D.23553; D.23554 = sinfo->source_file; add_line_number_file_name (w, D.23554, 0, 0); } i = i + 1; : source_file_list.11 = source_file_list; D.23555 = source_file_list.11->len; i.12 = (unsigned int) i; if (D.23555 > i.12) goto ; else goto ; : } finally { source_file = {CLOBBER}; source_file_list = {CLOBBER}; } } : l = l->next; : if (l != 0B) goto ; else goto ; : 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 ; : { char * name; char * copy; int dir_index; D.23557 = w->index_to_file; D.23558 = i + 1; D.23559 = (long unsigned int) D.23558; D.23560 = (const void *) D.23559; name = monoeg_g_hash_table_lookup (D.23557, D.23560); dir_index = 0; D.23561 = monoeg_g_path_is_absolute (name); if (D.23561 != 0) goto ; else goto ; : { char * dir; dir = monoeg_g_path_get_dirname (name); D.23564 = monoeg_g_hash_table_lookup (dir_to_index, dir); D.23565 = (long int) D.23564; dir_index = (int) D.23565; if (dir_index == 0) goto ; else goto ; : dir_index = w->line_number_dir_index; D.23568 = w->line_number_dir_index; D.23569 = D.23568 + 1; w->line_number_dir_index = D.23569; copy = monoeg_strdup (dir); D.23570 = dir_index + 1; D.23571 = (long unsigned int) D.23570; D.23572 = (void *) D.23571; monoeg_g_hash_table_insert_replace (dir_to_index, copy, D.23572, 0); D.23570 = dir_index + 1; D.23571 = (long unsigned int) D.23570; D.23572 = (void *) D.23571; monoeg_g_hash_table_insert_replace (index_to_dir, D.23572, copy, 0); goto ; : dir_index = dir_index + -1; : monoeg_g_free (dir); } : } i = i + 1; : D.23574 = w->line_number_file_index; if (D.23574 > i) goto ; else goto ; : 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 ; : { char * dir; D.23558 = i + 1; D.23559 = (long unsigned int) D.23558; D.23560 = (const void *) D.23559; dir = monoeg_g_hash_table_lookup (index_to_dir, D.23560); D.23575 = mono_dwarf_escape_path (dir); emit_string (w, D.23575); } i = i + 1; : D.23568 = w->line_number_dir_index; if (D.23568 > i) goto ; else goto ; : emit_byte (w, 0); i = 0; goto ; : { char * name; char * basename; char * dir; int dir_index; D.23557 = w->index_to_file; D.23558 = i + 1; D.23559 = (long unsigned int) D.23558; D.23560 = (const void *) D.23559; name = monoeg_g_hash_table_lookup (D.23557, D.23560); basename = 0B; dir_index = 0; D.23576 = monoeg_g_path_is_absolute (name); if (D.23576 != 0) goto ; else goto ; : dir = monoeg_g_path_get_dirname (name); D.23579 = monoeg_g_hash_table_lookup (dir_to_index, dir); D.23580 = (long int) D.23579; dir_index = (int) D.23580; basename = monoeg_g_path_get_basename (name); : if (basename != 0B) goto ; else goto ; : emit_string (w, basename); goto ; : D.23584 = mono_dwarf_escape_path (name); emit_string (w, D.23584); : dir_index.13 = (unsigned int) dir_index; emit_uleb128 (w, dir_index.13); emit_byte (w, 0); emit_byte (w, 0); } i = i + 1; : D.23574 = w->line_number_file_index; if (D.23574 > i) goto ; else goto ; : emit_byte (w, 0); emit_label (w, ".Ldebug_line_header_end"); l = info_list; goto ; : { struct MethodLineNumberInfo * info; struct MonoDebugMethodJitInfo * dmji; info = l->data; D.23586 = info->method; D.23587 = mono_domain_get (); dmji = mono_debug_find_method (D.23586, D.23587); D.23586 = info->method; D.23588 = info->start_symbol; D.23589 = info->end_symbol; D.23590 = info->code; D.23591 = info->code_size; emit_line_number_info (w, D.23586, D.23588, D.23589, D.23590, D.23591, dmji); mono_debug_free_method_jit_info (dmji); } l = l->next; : if (l != 0B) goto ; else goto ; : 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.23594; struct GHashTable * D.23597; struct GHashTable * D.23598; void * D.23599; long int D.23600; int D.23603; int D.23604; int D.23605; int D.23606; long unsigned int D.23607; void * D.23608; struct GHashTable * D.23609; int index; char * copy; D.23594 = w->file_to_index; if (D.23594 == 0B) goto ; else goto ; : D.23597 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal); w->file_to_index = D.23597; D.23598 = monoeg_g_hash_table_new (0B, 0B); w->index_to_file = D.23598; : D.23594 = w->file_to_index; D.23599 = monoeg_g_hash_table_lookup (D.23594, name); D.23600 = (long int) D.23599; index = (int) D.23600; if (index > 0) goto ; else goto ; : D.23603 = index + -1; return D.23603; : index = w->line_number_file_index; D.23604 = w->line_number_file_index; D.23605 = D.23604 + 1; w->line_number_file_index = D.23605; copy = monoeg_strdup (name); D.23594 = w->file_to_index; D.23606 = index + 1; D.23607 = (long unsigned int) D.23606; D.23608 = (void *) D.23607; monoeg_g_hash_table_insert_replace (D.23594, copy, D.23608, 0); D.23609 = w->index_to_file; D.23606 = index + 1; D.23607 = (long unsigned int) D.23606; D.23608 = (void *) D.23607; monoeg_g_hash_table_insert_replace (D.23609, D.23608, copy, 0); D.23603 = index; return D.23603; } 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.23611; _Bool D.23614; long int D.23615; long int D.23616; unsigned int D.23619; long unsigned int D.23620; long unsigned int D.23621; struct MonoDebugLineNumberEntry * D.23622; long unsigned int D.23623; unsigned int D.23624; long unsigned int D.23625; long unsigned int D.23626; long unsigned int D.23627; long unsigned int D.23628; long unsigned int D.23631; long unsigned int D.23632; int * D.23633; unsigned int D.23634; unsigned int j.14; unsigned int D.23636; unsigned int i.15; sizetype D.23640; sizetype D.23641; sizetype D.23642; unsigned int D.23643; int D.23644; unsigned int D.23645; unsigned int j.16; long unsigned int D.23654; int * D.23655; unsigned int i.17; unsigned int il_offset.18; char * D.23666; unsigned int D.23667; int D.23668; int prev_line.19; unsigned int D.23670; int D.23676; long int D.23677; int D.23683; int D.23684; int D.23687; int D.23689; unsigned int file_index.20; unsigned int D.23695; long int D.23696; const unsigned char * ip.21; struct FILE * D.23701; int D.23702; int D.23703; unsigned int D.23704; long unsigned int D.23705; long unsigned int D.23706; const guint8 * ip.22; long int ip.23; long int ip.24; long int D.23710; long unsigned int D.23711; long unsigned int D.23712; int * D.23713; sizetype D.23714; const unsigned char * D.23715; unsigned int D.23716; long unsigned int D.23719; long unsigned int D.23720; int * D.23721; int D.23726; unsigned int D.23727; int D.23728; int D.23729; unsigned int prev_native_offset.25; unsigned int D.23731; long int D.23732; 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.23611 = w->emit_line; if (D.23611 == 0) goto ; else goto ; : mono_metadata_free_mh (header); return; : minfo = mono_debug_lookup_method (method); D.23614 = code_size == 0; D.23615 = (long int) D.23614; D.23616 = __builtin_expect (D.23615, 0); if (D.23616 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1585, "code_size"); : D.23619 = debug_info->num_line_numbers; D.23620 = (long unsigned int) D.23619; D.23621 = D.23620 * 8; ln_array = monoeg_malloc0 (D.23621); D.23622 = debug_info->line_numbers; D.23619 = debug_info->num_line_numbers; D.23620 = (long unsigned int) D.23619; D.23621 = D.23620 * 8; memcpy (ln_array, D.23622, D.23621); D.23619 = debug_info->num_line_numbers; D.23623 = (long unsigned int) D.23619; qsort (ln_array, D.23623, 8, compare_lne); D.23624 = code_size + 1; D.23625 = (long unsigned int) D.23624; D.23626 = D.23625 * 4; native_to_il_offset = monoeg_malloc0 (D.23626); i = 0; goto ; : { int j; struct MonoDebugLineNumberEntry * lne; D.23627 = (long unsigned int) i; D.23628 = D.23627 * 8; lne = ln_array + D.23628; if (i == 0) goto ; else goto ; : j = 0; goto ; : D.23631 = (long unsigned int) j; D.23632 = D.23631 * 4; D.23633 = native_to_il_offset + D.23632; *D.23633 = -1; j = j + 1; : D.23634 = lne->native_offset; j.14 = (unsigned int) j; if (D.23634 > j.14) goto ; else goto ; : : D.23619 = debug_info->num_line_numbers; D.23636 = D.23619 + 4294967295; i.15 = (unsigned int) i; if (D.23636 > i.15) goto ; else goto ; : { struct MonoDebugLineNumberEntry * lne_next; D.23640 = (sizetype) i; D.23641 = D.23640 + 1; D.23642 = D.23641 * 8; lne_next = ln_array + D.23642; D.23634 = lne->native_offset; j = (int) D.23634; goto ; : D.23631 = (long unsigned int) j; D.23632 = D.23631 * 4; D.23633 = native_to_il_offset + D.23632; D.23643 = lne->il_offset; D.23644 = (int) D.23643; *D.23633 = D.23644; j = j + 1; : D.23645 = lne_next->native_offset; j.14 = (unsigned int) j; if (D.23645 > j.14) goto ; else goto ; : } goto ; : D.23634 = lne->native_offset; j = (int) D.23634; goto ; : D.23631 = (long unsigned int) j; D.23632 = D.23631 * 4; D.23633 = native_to_il_offset + D.23632; D.23643 = lne->il_offset; D.23644 = (int) D.23643; *D.23633 = D.23644; j = j + 1; : j.16 = (unsigned int) j; if (j.16 < code_size) goto ; else goto ; : : } i = i + 1; : D.23619 = debug_info->num_line_numbers; i.15 = (unsigned int) i; if (D.23619 > i.15) goto ; else goto ; : monoeg_g_free (ln_array); prev_line = 1; prev_il_offset = -1; i = 0; goto ; : { int line_diff; int addr_diff; if (minfo == 0B) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.23622 = debug_info->line_numbers; if (D.23622 == 0B) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : if (native_to_il_offset != 0B) goto ; else goto ; : D.23627 = (long unsigned int) i; D.23654 = D.23627 * 4; D.23655 = native_to_il_offset + D.23654; il_offset = *D.23655; goto ; : i.17 = (unsigned int) i; il_offset = il_offset_from_address (method, debug_info, i.17); : D.23627 = (long unsigned int) i; D.23654 = D.23627 * 4; D.23655 = native_to_il_offset + D.23654; il_offset = *D.23655; if (il_offset < 0) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : if (il_offset == prev_il_offset) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : prev_il_offset = il_offset; il_offset.18 = (unsigned int) il_offset; loc = mono_debug_symfile_lookup_location (minfo, il_offset.18); if (loc == 0B) goto ; else goto ; : D.23666 = loc->source_file; if (D.23666 == 0B) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.23667 = loc->row; D.23668 = (int) D.23667; prev_line.19 = (int) prev_line; line_diff = D.23668 - prev_line.19; i.17 = (unsigned int) i; D.23670 = i.17 - prev_native_offset; addr_diff = (int) D.23670; if (first != 0) goto ; else goto ; : emit_section_change (w, ".debug_line", 4); emit_byte (w, 0); emit_byte (w, 9); emit_byte (w, 2); if (start_symbol != 0B) goto ; else goto ; : emit_pointer_unaligned (w, start_symbol); goto ; : emit_pointer_value (w, code); : emit_byte (w, 3); D.23667 = loc->row; D.23668 = (int) D.23667; prev_line.19 = (int) prev_line; D.23676 = D.23668 - prev_line.19; D.23677 = (long int) D.23676; emit_sleb128 (w, D.23677); prev_line = loc->row; prev_native_offset = (guint32) i; first = 0; : D.23667 = loc->row; if (D.23667 != prev_line) goto ; else goto ; : if (prev_file_name == 0B) goto ; else goto ; : D.23666 = loc->source_file; D.23683 = strcmp (D.23666, prev_file_name); if (D.23683 != 0) goto ; else goto ; : D.23684 = w->collect_line_info; if (D.23684 != 0) goto ; else goto ; : D.23666 = loc->source_file; D.23687 = get_line_number_file_name (w, D.23666); file_index = D.23687 + 1; goto ; : D.23666 = loc->source_file; file_index = emit_line_number_file_name (w, D.23666, 0, 0); : monoeg_g_free (prev_file_name); D.23666 = loc->source_file; prev_file_name = monoeg_strdup (D.23666); D.23689 = w->cur_file_index; if (D.23689 != file_index) goto ; else goto ; : emit_byte (w, 4); file_index.20 = (unsigned int) file_index; emit_uleb128 (w, file_index.20); emit_byte (w, 1); w->cur_file_index = file_index; : : emit_advance_op (w, line_diff, addr_diff); prev_line = loc->row; prev_native_offset = (guint32) i; : mono_debug_symfile_free_location (loc); } : i = i + 1; : i.17 = (unsigned int) i; if (i.17 < code_size) goto ; else goto ; : monoeg_g_free (native_to_il_offset); monoeg_g_free (prev_file_name); if (first == 0) goto ; else goto ; : emit_byte (w, 2); D.23695 = code_size - prev_native_offset; D.23696 = (long int) D.23695; emit_sleb128 (w, D.23696); emit_byte (w, 1); emit_byte (w, 0); emit_byte (w, 1); emit_byte (w, 1); goto ; : if (start_symbol == 0B) goto ; else goto ; : { char * name; char * dis; const guint8 * ip; int prev_line; int prev_native_offset; int * il_to_line; try { ip.21 = header->code; ip = ip.21; name = mono_method_full_name (method, 1); D.23701 = w->il_file; fprintf (D.23701, "// %s\n", name); D.23702 = w->il_file_line_index; D.23703 = D.23702 + 1; w->il_file_line_index = D.23703; monoeg_g_free (name); D.23704 = header->code_size; D.23705 = (long unsigned int) D.23704; D.23706 = D.23705 * 4; il_to_line = monoeg_malloc0 (D.23706); emit_section_change (w, ".debug_line", 4); emit_byte (w, 0); emit_byte (w, 9); emit_byte (w, 2); emit_pointer_value (w, code); goto ; : { int il_offset; ip.22 = ip; ip.23 = (long int) ip.22; ip.21 = header->code; ip.24 = (long int) ip.21; D.23710 = ip.23 - ip.24; il_offset = (int) D.23710; D.23702 = w->il_file_line_index; D.23703 = D.23702 + 1; w->il_file_line_index = D.23703; ip.22 = ip; dis = disasm_ins (method, ip.22, &ip); D.23701 = w->il_file; fprintf (D.23701, "%s\n", dis); monoeg_g_free (dis); D.23711 = (long unsigned int) il_offset; D.23712 = D.23711 * 4; D.23713 = il_to_line + D.23712; D.23702 = w->il_file_line_index; *D.23713 = D.23702; } : ip.21 = header->code; D.23704 = header->code_size; D.23714 = (sizetype) D.23704; D.23715 = ip.21 + D.23714; ip.22 = ip; if (D.23715 > ip.22) goto ; else goto ; : prev_line = 1; prev_native_offset = 0; i = 0; goto ; : { struct MonoDebugLineNumberEntry * lne; int line; D.23622 = debug_info->line_numbers; D.23627 = (long unsigned int) i; D.23628 = D.23627 * 8; lne = D.23622 + D.23628; D.23716 = lne->il_offset; D.23704 = header->code_size; if (D.23716 >= D.23704) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.23716 = lne->il_offset; D.23719 = (long unsigned int) D.23716; D.23720 = D.23719 * 4; D.23721 = il_to_line + D.23720; line = *D.23721; if (line == 0) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : if (line != prev_line) goto ; else goto ; : D.23726 = line - prev_line; D.23727 = lne->native_offset; D.23728 = (int) D.23727; D.23729 = D.23728 - prev_native_offset; emit_advance_op (w, D.23726, D.23729); prev_line = line; D.23727 = lne->native_offset; prev_native_offset = (int) D.23727; : } : i = i + 1; : D.23619 = debug_info->num_line_numbers; i.15 = (unsigned int) i; if (D.23619 > i.15) goto ; else goto ; : emit_byte (w, 2); prev_native_offset.25 = (unsigned int) prev_native_offset; D.23731 = code_size - prev_native_offset.25; D.23732 = (long int) D.23731; emit_sleb128 (w, D.23732); emit_byte (w, 1); emit_byte (w, 0); emit_byte (w, 1); emit_byte (w, 1); D.23701 = w->il_file; fflush (D.23701); monoeg_g_free (il_to_line); } finally { ip = {CLOBBER}; } } : : mono_metadata_free_mh (header); } compare_lne (struct MonoDebugLineNumberEntry * a, struct MonoDebugLineNumberEntry * b) { unsigned int D.23734; unsigned int D.23735; gint D.23738; unsigned int D.23739; unsigned int D.23740; unsigned int D.23741; unsigned int D.23742; D.23734 = a->native_offset; D.23735 = b->native_offset; if (D.23734 == D.23735) goto ; else goto ; : D.23739 = a->il_offset; D.23740 = b->il_offset; D.23741 = D.23739 - D.23740; D.23738 = (gint) D.23741; return D.23738; : D.23734 = a->native_offset; D.23735 = b->native_offset; D.23742 = D.23734 - D.23735; D.23738 = (gint) D.23742; return D.23738; } __attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__)) memcpy (void * restrict __dest, const void * restrict __src, size_t __len) { void * D.23744; long unsigned int D.23745; D.23745 = __builtin_object_size (__dest, 0); D.23744 = __builtin___memcpy_chk (__dest, __src, __len, D.23745); return D.23744; } il_offset_from_address (struct MonoMethod * method, struct MonoDebugMethodJitInfo * jit, guint32 native_offset) { struct MonoDebugLineNumberEntry * D.23747; gint32 D.23750; unsigned int D.23751; unsigned int D.23752; long unsigned int D.23753; long unsigned int D.23754; struct MonoDebugLineNumberEntry * D.23755; unsigned int D.23756; unsigned int D.23759; int i; D.23747 = jit->line_numbers; if (D.23747 == 0B) goto ; else goto ; : D.23750 = -1; return D.23750; : D.23751 = jit->num_line_numbers; D.23752 = D.23751 + 4294967295; i = (int) D.23752; goto ; : { struct MonoDebugLineNumberEntry lne; try { D.23747 = jit->line_numbers; D.23753 = (long unsigned int) i; D.23754 = D.23753 * 8; D.23755 = D.23747 + D.23754; lne = *D.23755; D.23756 = lne.native_offset; if (D.23756 <= native_offset) goto ; else goto ; : D.23759 = lne.il_offset; D.23750 = (gint32) D.23759; return D.23750; : } finally { lne = {CLOBBER}; } } i = i + -1; : if (i >= 0) goto ; else goto ; : D.23750 = -1; return D.23750; } emit_pointer_unaligned (struct MonoDwarfWriter * w, const char * target) { struct MonoImageWriter * D.23763; D.23763 = w->w; img_writer_emit_pointer_unaligned (D.23763, target); } __attribute__((__gnu_inline__, nothrow, leaf, pure)) strcmp (const char * __s1, const char * __s2) { int iftmp.26; int iftmp.27; int D.23772; char * __p1; char * __p2; int __ret; __p1 = __s1; __p2 = __s2; __asm__ __volatile__(" slr 0,0 0: clst %1,%2 jo 0b ipm %0 srl %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc"); if (__ret != 0) goto ; else goto ; : if (__ret == 1) goto ; else goto ; : iftmp.27 = -1; goto ; : iftmp.27 = 1; : iftmp.26 = iftmp.27; goto ; : iftmp.26 = 0; : __ret = iftmp.26; D.23772 = __ret; return D.23772; } get_line_number_file_name (struct MonoDwarfWriter * w, const char * name) { struct GHashTable * D.23774; _Bool D.23775; long int D.23776; long int D.23777; void * D.23780; long int D.23781; _Bool D.23782; long int D.23783; long int D.23784; int D.23787; int index; D.23774 = w->file_to_index; D.23775 = D.23774 == 0B; D.23776 = (long int) D.23775; D.23777 = __builtin_expect (D.23776, 0); if (D.23777 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 648, "w->file_to_index"); : D.23774 = w->file_to_index; D.23780 = monoeg_g_hash_table_lookup (D.23774, name); D.23781 = (long int) D.23780; index = (int) D.23781; D.23782 = index <= 0; D.23783 = (long int) D.23782; D.23784 = __builtin_expect (D.23783, 0); if (D.23784 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 650, "index > 0"); : D.23787 = index + -1; return D.23787; } emit_line_number_file_name (struct MonoDwarfWriter * w, const char * name, gint64 last_mod_time, gint64 file_size) { struct GHashTable * D.23789; struct GHashTable * D.23792; void * D.23793; long int D.23794; int D.23797; int D.23798; struct GHashTable * D.23801; struct GHashTable * D.23804; void * D.23805; long int D.23806; int D.23809; int D.23810; gchar * D.23811; long unsigned int D.23812; void * D.23813; unsigned int dir_index.28; int D.23821; int D.23822; gchar * D.23823; long unsigned int D.23824; void * D.23825; int index; int dir_index; char * basename; basename = 0B; D.23789 = w->file_to_index; if (D.23789 == 0B) goto ; else goto ; : D.23792 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal); w->file_to_index = D.23792; : D.23789 = w->file_to_index; D.23793 = monoeg_g_hash_table_lookup (D.23789, name); D.23794 = (long int) D.23793; index = (int) D.23794; if (index > 0) goto ; else goto ; : D.23797 = index; return D.23797; : D.23798 = monoeg_g_path_is_absolute (name); if (D.23798 != 0) goto ; else goto ; : { char * dir; dir = monoeg_g_path_get_dirname (name); D.23801 = w->dir_to_index; if (D.23801 == 0B) goto ; else goto ; : D.23804 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal); w->dir_to_index = D.23804; : D.23801 = w->dir_to_index; D.23805 = monoeg_g_hash_table_lookup (D.23801, dir); D.23806 = (long int) D.23805; dir_index = (int) D.23806; if (dir_index == 0) goto ; else goto ; : emit_section_change (w, ".debug_line", 2); emit_string (w, dir); D.23809 = w->line_number_dir_index; D.23810 = D.23809 + 1; w->line_number_dir_index = D.23810; dir_index = w->line_number_dir_index; D.23801 = w->dir_to_index; D.23811 = monoeg_strdup (dir); D.23812 = (long unsigned int) dir_index; D.23813 = (void *) D.23812; monoeg_g_hash_table_insert_replace (D.23801, D.23811, D.23813, 0); : monoeg_g_free (dir); basename = monoeg_g_path_get_basename (name); } goto ; : dir_index = 0; : emit_section_change (w, ".debug_line", 3); if (basename != 0B) goto ; else goto ; : emit_string (w, basename); goto ; : emit_string (w, name); : dir_index.28 = (unsigned int) dir_index; emit_uleb128 (w, dir_index.28); emit_byte (w, 0); emit_byte (w, 0); emit_section_change (w, ".debug_line", 4); if (basename != 0B) goto ; else goto ; : monoeg_g_free (basename); : D.23821 = w->line_number_file_index; D.23822 = D.23821 + 1; w->line_number_file_index = D.23822; index = w->line_number_file_index; D.23789 = w->file_to_index; D.23823 = monoeg_strdup (name); D.23824 = (long unsigned int) index; D.23825 = (void *) D.23824; monoeg_g_hash_table_insert_replace (D.23789, D.23823, D.23825, 0); D.23797 = index; return D.23797; } disasm_ins (struct MonoMethod * method, const guchar * ip, const guint8 * * endip) { const guchar * ip.29; unsigned char D.23828; const guchar * D.23831; unsigned char D.23832; int D.23833; const guchar * D.23834; unsigned int D.23835; unsigned int D.23836; unsigned int D.23837; unsigned int D.23838; unsigned int D.23839; unsigned int D.23840; unsigned int D.23841; unsigned int D.23842; unsigned int D.23843; _Bool D.23844; long int D.23845; long int D.23846; long int ip.30; const unsigned char * D.23850; long int D.23851; long int D.23852; int D.23853; const char * D.23854; const guchar * ip.31; const char * D.23856; char * D.23858; char * dis; struct MonoDisHelper dh; struct MonoMethodHeader * header; try { header = mono_method_get_header (method); memset (&dh, 0, 48); dh.newline = ""; dh.label_format = "IL_%04x: "; dh.label_target = "IL_%04x"; dh.tokener = token_handler; ip.29 = ip; token_handler_ip = ip.29; ip.29 = ip; D.23828 = *ip.29; if (D.23828 == 240) goto ; else goto ; : { guint32 token; void * data; ip.29 = ip; D.23831 = ip.29 + 1; D.23832 = *D.23831; D.23833 = (int) D.23832; switch (D.23833) , case 0: , case 11: > : { struct MonoJitICallInfo * info; ip.29 = ip; D.23834 = ip.29 + 2; D.23835 = MEM[(const guint32 *)D.23834]; D.23836 = D.23835 << 24; ip.29 = ip; D.23834 = ip.29 + 2; D.23835 = MEM[(const guint32 *)D.23834]; D.23837 = D.23835 >> 8; D.23838 = D.23837 & 65280; D.23839 = D.23836 | D.23838; ip.29 = ip; D.23834 = ip.29 + 2; D.23835 = MEM[(const guint32 *)D.23834]; D.23840 = D.23835 << 8; D.23841 = D.23840 & 16711680; D.23842 = D.23839 | D.23841; ip.29 = ip; D.23834 = ip.29 + 2; D.23835 = MEM[(const guint32 *)D.23834]; D.23843 = D.23835 >> 24; token = D.23842 | D.23843; data = mono_method_get_wrapper_data (method, token); info = mono_find_jit_icall_by_addr (data); D.23844 = info == 0B; D.23845 = (long int) D.23844; D.23846 = __builtin_expect (D.23845, 0); if (D.23846 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1470, "info"); : ip.29 = ip; ip.30 = (long int) ip.29; D.23850 = header->code; D.23851 = (long int) D.23850; D.23852 = ip.30 - D.23851; D.23853 = (int) D.23852; D.23854 = info->name; dis = monoeg_g_strdup_printf ("IL_%04x: mono_icall <%s>", D.23853, D.23854); ip.29 = ip; ip.31 = ip.29 + 6; ip = ip.31; goto ; } : ip.29 = ip; D.23834 = ip.29 + 2; D.23835 = MEM[(const guint32 *)D.23834]; D.23836 = D.23835 << 24; ip.29 = ip; D.23834 = ip.29 + 2; D.23835 = MEM[(const guint32 *)D.23834]; D.23837 = D.23835 >> 8; D.23838 = D.23837 & 65280; D.23839 = D.23836 | D.23838; ip.29 = ip; D.23834 = ip.29 + 2; D.23835 = MEM[(const guint32 *)D.23834]; D.23840 = D.23835 << 8; D.23841 = D.23840 & 16711680; D.23842 = D.23839 | D.23841; ip.29 = ip; D.23834 = ip.29 + 2; D.23835 = MEM[(const guint32 *)D.23834]; D.23843 = D.23835 >> 24; token = D.23842 | D.23843; data = mono_method_get_wrapper_data (method, token); ip.29 = ip; ip.30 = (long int) ip.29; D.23850 = header->code; D.23851 = (long int) D.23850; D.23852 = ip.30 - D.23851; D.23853 = (int) D.23852; D.23856 = MEM[(struct MonoClass *)data].name; dis = monoeg_g_strdup_printf ("IL_%04x: mono_classconst <%s>", D.23853, D.23856); ip.29 = ip; ip.31 = ip.29 + 6; ip = ip.31; goto ; : ip.29 = ip; dis = mono_disasm_code_one (&dh, method, ip.29, &ip); : } goto ; : ip.29 = ip; dis = mono_disasm_code_one (&dh, method, ip.29, &ip); : token_handler_ip = 0B; ip.29 = ip; *endip = ip.29; mono_metadata_free_mh (header); D.23858 = dis; return D.23858; } finally { dh = {CLOBBER}; } } token_handler (struct MonoDisHelper * dh, struct MonoMethod * method, guint32 token) { long unsigned int D.23861; long unsigned int D.23862; const guint8 * token_handler_ip.32; unsigned char D.23866; int D.23867; struct MonoClass * D.23871; struct MonoImage * D.23872; struct MonoClass * klass.33; struct MonoClass * klass.34; const char * D.23875; char * D.23885; char * res; char * desc; struct MonoMethod * cmethod; struct MonoClass * klass; struct MonoClassField * field; void * data; try { data = 0B; D.23861 = BIT_FIELD_REF <*method, 64, 256>; D.23862 = D.23861 & 4467570830351532032; if (D.23862 != 0) goto ; else goto ; : data = mono_method_get_wrapper_data (method, token); : token_handler_ip.32 = token_handler_ip; D.23866 = *token_handler_ip.32; D.23867 = (int) D.23866; switch (D.23867) , case 40: , case 41: , case 111: , case 115: , case 116: , case 117: , case 123: , case 125: , case 126: , case 128: , case 143: > : : : D.23861 = BIT_FIELD_REF <*method, 64, 256>; D.23862 = D.23861 & 4467570830351532032; if (D.23862 != 0) goto ; else goto ; : klass = data; goto ; : D.23871 = method->klass; D.23872 = D.23871->image; klass.33 = mono_class_get_full (D.23872, token, 0B); klass = klass.33; : klass.34 = klass; D.23875 = klass.34->name; res = monoeg_g_strdup_printf ("<%s>", D.23875); goto ; : : : D.23861 = BIT_FIELD_REF <*method, 64, 256>; D.23862 = D.23861 & 4467570830351532032; if (D.23862 != 0) goto ; else goto ; : cmethod = data; goto ; : D.23871 = method->klass; D.23872 = D.23871->image; cmethod = mono_get_method_full (D.23872, token, 0B, 0B); : desc = mono_method_full_name (cmethod, 1); res = monoeg_g_strdup_printf ("<%s>", desc); monoeg_g_free (desc); goto ; : D.23861 = BIT_FIELD_REF <*method, 64, 256>; D.23862 = D.23861 & 4467570830351532032; if (D.23862 != 0) goto ; else goto ; : desc = mono_signature_get_desc (data, 0); res = monoeg_g_strdup_printf ("<%s>", desc); monoeg_g_free (desc); goto ; : res = monoeg_g_strdup_printf ("<0x%08x>", token); : goto ; : : : : D.23861 = BIT_FIELD_REF <*method, 64, 256>; D.23862 = D.23861 & 4467570830351532032; if (D.23862 != 0) goto ; else goto ; : field = data; goto ; : D.23871 = method->klass; D.23872 = D.23871->image; field = mono_field_from_token (D.23872, token, &klass, 0B); : desc = mono_field_full_name (field); res = monoeg_g_strdup_printf ("<%s>", desc); monoeg_g_free (desc); goto ; : res = monoeg_g_strdup_printf ("<0x%08x>", token); goto ; : D.23885 = res; return D.23885; } finally { klass = {CLOBBER}; } } __attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__)) memset (void * __dest, int __ch, size_t __len) { void * D.23888; long unsigned int D.23889; D.23889 = __builtin_object_size (__dest, 0); D.23888 = __builtin___memset_chk (__dest, __ch, __len, D.23889); return D.23888; } __attribute__((__artificial__, __gnu_inline__, __always_inline__)) fprintf (struct FILE * restrict __stream, const char * restrict __fmt) { int D.23891; D.23891 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ()); return D.23891; } emit_advance_op (struct MonoDwarfWriter * w, int line_diff, int addr_diff) { unsigned int line_diff.35; unsigned int D.23894; int max_special_addr_diff.36; int D.23902; int D.23905; int D.23906; int D.23907; int D.23908; unsigned char D.23913; long int D.23915; long int D.23916; gint64 opcode; opcode = 0; line_diff.35 = (unsigned int) line_diff; D.23894 = line_diff.35 + 5; if (D.23894 <= 13) goto ; else goto ; : max_special_addr_diff.36 = max_special_addr_diff; if (max_special_addr_diff.36 == 0) goto ; else goto ; : max_special_addr_diff = 17; : max_special_addr_diff.36 = max_special_addr_diff; if (addr_diff > max_special_addr_diff.36) goto ; else goto ; : max_special_addr_diff.36 = max_special_addr_diff; D.23902 = max_special_addr_diff.36 * 2; if (D.23902 > addr_diff) goto ; else goto ; : emit_byte (w, 8); max_special_addr_diff.36 = max_special_addr_diff; addr_diff = addr_diff - max_special_addr_diff.36; : : D.23905 = line_diff + 5; D.23906 = addr_diff * 14; D.23907 = D.23905 + D.23906; D.23908 = D.23907 + 13; opcode = (gint64) D.23908; if (opcode > 255) goto ; else goto ; : opcode = 0; : : if (opcode != 0) goto ; else goto ; : D.23913 = (unsigned char) opcode; emit_byte (w, D.23913); goto ; : emit_byte (w, 3); D.23915 = (long int) line_diff; emit_sleb128 (w, D.23915); emit_byte (w, 2); D.23916 = (long int) addr_diff; emit_sleb128 (w, D.23916); emit_byte (w, 1); : } __attribute__((visibility ("hidden"))) 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) { long unsigned int D.23920; long unsigned int D.23921; struct MonoClass * D.23923; long unsigned int D.23924; long unsigned int D.23925; D.23929; int D.23930; int D.23931; short unsigned int D.23932; int D.23933; int D.23934; struct MonoType * D.23935; short unsigned int D.23936; int D.23937; long unsigned int D.23938; long unsigned int D.23939; sizetype D.23943; guint8 * D.23944; struct MonoInst * iftmp.37; long unsigned int D.23948; long unsigned int D.23949; struct MonoInst * * D.23950; int D.23958; int D.23960; long unsigned int D.23968; long unsigned int D.23969; char * * D.23970; guint32 iftmp.38; char D.23975; unsigned char D.23982; int D.23983; int D.23984; struct MonoClass * D.23985; struct MonoType * D.23986; guint8 * p.39; int code_size.40; sizetype D.23993; guint8 * D.23994; sizetype D.23995; guint8 * D.23996; long int p.41; long int buf.42; long int D.23999; unsigned int D.24000; unsigned char D.24002; int D.24003; struct MonoInst * * D.24004; int D.24009; guint32 iftmp.43; struct MonoDebugLocalVar * D.24018; long unsigned int D.24019; long unsigned int D.24020; struct MonoDebugLocalVar * D.24021; int D.24022; int D.24024; unsigned char D.24034; int D.24035; int D.24036; int D.24039; sizetype D.24042; guint8 * D.24043; sizetype D.24044; guint8 * D.24045; int D.24051; int D.24052; const mono_byte * D.24055; int D.24058; gchar * D.24061; gchar * D.24062; struct GSList * D.24063; struct GSList * D.24064; 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 ; : { struct MonoType * t; if (i == 0) goto ; else goto ; : D.23920 = BIT_FIELD_REF <*sig, 64, 64>; D.23921 = D.23920 & 512; if (D.23921 != 0) goto ; else goto ; : D.23923 = method->klass; D.23924 = BIT_FIELD_REF <*D.23923, 64, 256>; D.23925 = D.23924 & 1152921504606846976; if (D.23925 != 0) goto ; else goto ; : D.23923 = method->klass; t = &D.23923->this_arg; goto ; : D.23923 = method->klass; t = &D.23923->byval_arg; : goto ; : D.23929 = sig->hasthis; D.23930 = (int) D.23929; D.23931 = i - D.23930; t = sig->params[D.23931]; : emit_type (w, t); } i = i + 1; : D.23932 = sig->param_count; D.23933 = (int) D.23932; D.23929 = sig->hasthis; D.23930 = (int) D.23929; D.23934 = D.23933 + D.23930; if (D.23934 > i) goto ; else goto ; : i = 0; goto ; : D.23935 = header->locals[i]; emit_type (w, D.23935); i = i + 1; : D.23936 = header->num_locals; D.23937 = (int) D.23936; if (D.23937 > i) goto ; else goto ; : D.23932 = sig->param_count; D.23938 = (long unsigned int) D.23932; D.23939 = D.23938 * 8; names = monoeg_malloc0 (D.23939); 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 ; else goto ; : emit_pointer_unaligned (w, start_symbol); emit_pointer_unaligned (w, end_symbol); goto ; : emit_pointer_value (w, code); D.23943 = (sizetype) code_size; D.23944 = code + D.23943; emit_pointer_value (w, D.23944); : emit_byte (w, 2); emit_byte (w, 118); emit_byte (w, 16); i = 0; goto ; : { struct MonoInst * arg; struct MonoType * t; const char * pname; char pname_buf[128]; struct MonoMethodVar * vmv; gboolean need_loclist; try { if (args != 0B) goto ; else goto ; : D.23948 = (long unsigned int) i; D.23949 = D.23948 * 8; D.23950 = args + D.23949; iftmp.37 = *D.23950; goto ; : iftmp.37 = 0B; : arg = iftmp.37; vmv = 0B; need_loclist = 0; vmv = find_vmv (cfg, arg); if (code != 0B) goto ; else goto ; : if (vmv != 0B) goto ; else goto ; : D.23958 = vmv->live_range_start; if (D.23958 != 0) goto ; else goto ; : D.23960 = vmv->live_range_end; if (D.23960 != 0) goto ; else goto ; : need_loclist = 1; : : : if (i == 0) goto ; else goto ; : D.23920 = BIT_FIELD_REF <*sig, 64, 64>; D.23921 = D.23920 & 512; if (D.23921 != 0) goto ; else goto ; : D.23923 = method->klass; D.23924 = BIT_FIELD_REF <*D.23923, 64, 256>; D.23925 = D.23924 & 1152921504606846976; if (D.23925 != 0) goto ; else goto ; : D.23923 = method->klass; t = &D.23923->this_arg; goto ; : D.23923 = method->klass; t = &D.23923->byval_arg; : pname = "this"; goto ; : D.23929 = sig->hasthis; D.23930 = (int) D.23929; D.23931 = i - D.23930; t = sig->params[D.23931]; D.23929 = sig->hasthis; D.23930 = (int) D.23929; D.23931 = i - D.23930; D.23968 = (long unsigned int) D.23931; D.23969 = D.23968 * 8; D.23970 = names + D.23969; pname = *D.23970; : if (need_loclist != 0) goto ; else goto ; : iftmp.38 = 15; goto ; : iftmp.38 = 3; : emit_uleb128 (w, iftmp.38); D.23975 = *pname; if (D.23975 == 0) goto ; else goto ; : D.23929 = sig->hasthis; D.23930 = (int) D.23929; D.23931 = i - D.23930; sprintf (&pname_buf, "param%d", D.23931); pname = &pname_buf; : emit_string (w, pname); if (arg == 0B) goto ; else goto ; : D.23982 = arg->flags; D.23983 = (int) D.23982; D.23984 = D.23983 & 2; if (D.23984 != 0) goto ; else goto ; : D.23985 = mono_defaults.int32_class; D.23986 = &D.23985->byval_arg; emit_var_type (w, D.23986); goto ; : emit_var_type (w, t); : p = &buf; p.39 = p; encode_var_location (w, arg, p.39, &p); if (need_loclist != 0) goto ; else goto ; : vmv->live_range_start = 0; D.23960 = vmv->live_range_end; if (D.23960 == 0) goto ; else goto ; : code_size.40 = (int) code_size; vmv->live_range_end = code_size.40; : D.23958 = vmv->live_range_start; D.23993 = (sizetype) D.23958; D.23994 = code + D.23993; D.23960 = vmv->live_range_end; D.23995 = (sizetype) D.23960; D.23996 = code + D.23995; p.39 = p; p.41 = (long int) p.39; buf.42 = (long int) &buf; D.23999 = p.41 - buf.42; D.24000 = (unsigned int) D.23999; emit_loclist (w, arg, D.23994, D.23996, &buf, D.24000); goto ; : p.39 = p; p.41 = (long int) p.39; buf.42 = (long int) &buf; D.23999 = p.41 - buf.42; D.24002 = (unsigned char) D.23999; emit_byte (w, D.24002); p.39 = p; p.41 = (long int) p.39; buf.42 = (long int) &buf; D.23999 = p.41 - buf.42; D.24003 = (int) D.23999; emit_bytes (w, &buf, D.24003); : } finally { pname_buf = {CLOBBER}; } } i = i + 1; : D.23932 = sig->param_count; D.23933 = (int) D.23932; D.23929 = sig->hasthis; D.23930 = (int) D.23929; D.23934 = D.23933 + D.23930; if (D.23934 > i) goto ; else goto ; : monoeg_g_free (names); locals_info = mono_debug_lookup_locals (method); i = 0; goto ; : { struct MonoInst * ins; char name_buf[128]; int j; struct MonoMethodVar * vmv; gboolean need_loclist; char * lname; try { D.23948 = (long unsigned int) i; D.23949 = D.23948 * 8; D.24004 = locals + D.23949; ins = *D.24004; vmv = 0B; need_loclist = 0; vmv = find_vmv (cfg, ins); if (code != 0B) goto ; else goto ; : if (vmv != 0B) goto ; else goto ; : D.24009 = vmv->live_range_start; if (D.24009 != 0) goto ; else goto ; : need_loclist = 1; : : : if (need_loclist != 0) goto ; else goto ; : iftmp.43 = 12; goto ; : iftmp.43 = 11; : emit_uleb128 (w, iftmp.43); lname = 0B; if (locals_info != 0B) goto ; else goto ; : j = 0; goto ; : D.24018 = locals_info->locals; D.24019 = (long unsigned int) j; D.24020 = D.24019 * 24; D.24021 = D.24018 + D.24020; D.24022 = D.24021->index; if (D.24022 == i) goto ; else goto ; : j = j + 1; : D.24024 = locals_info->num_locals; if (D.24024 > j) goto ; else goto ; : D.24024 = locals_info->num_locals; if (D.24024 > j) goto ; else goto ; : D.24018 = locals_info->locals; D.24019 = (long unsigned int) j; D.24020 = D.24019 * 24; D.24021 = D.24018 + D.24020; lname = D.24021->name; : : if (lname != 0B) goto ; else goto ; : emit_string (w, lname); goto ; : sprintf (&name_buf, "V_%d", i); emit_string (w, &name_buf); : if (ins == 0B) goto ; else goto ; : D.24034 = ins->flags; D.24035 = (int) D.24034; D.24036 = D.24035 & 2; if (D.24036 != 0) goto ; else goto ; : D.23985 = mono_defaults.int32_class; D.23986 = &D.23985->byval_arg; emit_var_type (w, D.23986); goto ; : D.23935 = header->locals[i]; emit_var_type (w, D.23935); : p = &buf; p.39 = p; encode_var_location (w, ins, p.39, &p); if (need_loclist != 0) goto ; else goto ; : D.24039 = vmv->live_range_end; if (D.24039 == 0) goto ; else goto ; : code_size.40 = (int) code_size; vmv->live_range_end = code_size.40; : D.24009 = vmv->live_range_start; D.24042 = (sizetype) D.24009; D.24043 = code + D.24042; D.24039 = vmv->live_range_end; D.24044 = (sizetype) D.24039; D.24045 = code + D.24044; p.39 = p; p.41 = (long int) p.39; buf.42 = (long int) &buf; D.23999 = p.41 - buf.42; D.24000 = (unsigned int) D.23999; emit_loclist (w, ins, D.24043, D.24045, &buf, D.24000); goto ; : p.39 = p; p.41 = (long int) p.39; buf.42 = (long int) &buf; D.23999 = p.41 - buf.42; D.24002 = (unsigned char) D.23999; emit_byte (w, D.24002); p.39 = p; p.41 = (long int) p.39; buf.42 = (long int) &buf; D.23999 = p.41 - buf.42; D.24003 = (int) D.23999; emit_bytes (w, &buf, D.24003); : } finally { name_buf = {CLOBBER}; } } i = i + 1; : D.23936 = header->num_locals; D.23937 = (int) D.23936; if (D.23937 > i) goto ; else goto ; : if (locals_info != 0B) goto ; else goto ; : mono_debug_symfile_free_locals (locals_info); : emit_uleb128 (w, 0); emit_line (w); emit_debug_info_end (w); if (unwind_info != 0B) goto ; else goto ; : D.24051 = w->fde_index; emit_fde (w, D.24051, start_symbol, end_symbol, code, code_size, unwind_info, 1); D.24051 = w->fde_index; D.24052 = D.24051 + 1; w->fde_index = D.24052; : if (debug_info != 0B) goto ; else goto ; : D.24055 = debug_info->code_start; if (D.24055 == code) goto ; else goto ; : D.24058 = w->collect_line_info; if (D.24058 != 0) goto ; else goto ; : { struct MethodLineNumberInfo * info; info = monoeg_malloc0 (40); info->method = method; D.24061 = monoeg_strdup (start_symbol); info->start_symbol = D.24061; D.24062 = monoeg_strdup (end_symbol); info->end_symbol = D.24062; info->code = code; info->code_size = code_size; D.24063 = w->line_info; D.24064 = monoeg_g_slist_prepend (D.24063, info); w->line_info = D.24064; } goto ; : emit_line_number_info (w, method, start_symbol, end_symbol, code, code_size, debug_info); : : : emit_line (w); mono_metadata_free_mh (header); } finally { buf = {CLOBBER}; p = {CLOBBER}; } } emit_type (struct MonoDwarfWriter * w, struct MonoType * t) { long unsigned int D.24066; long unsigned int D.24067; unsigned char D.24070; struct MonoClass * D.24076; int D.24077; int D.24078; unsigned int j.44; int D.24085; long unsigned int D.24089; long unsigned int D.24090; int D.24093; struct MonoClass * klass; int j; const char * tdie; klass = mono_class_from_mono_type (t); D.24066 = BIT_FIELD_REF <*t, 64, 64>; D.24067 = D.24066 & 8589934592; if (D.24067 != 0) goto ; else goto ; : D.24070 = t->type; if (D.24070 == 17) goto ; else goto ; : tdie = emit_class_dwarf_info (w, klass, 1); if (tdie != 0B) goto ; else goto ; : return; : goto ; : emit_class_dwarf_info (w, klass, 0); : D.24076 = mono_defaults.int_class; t = &D.24076->byval_arg; : j = 0; goto ; : D.24077 = basic_types[j].type; D.24070 = t->type; D.24078 = (int) D.24070; if (D.24077 == D.24078) goto ; else goto ; : j = j + 1; : j.44 = (unsigned int) j; if (j.44 <= 16) goto ; else goto ; : j.44 = (unsigned int) j; if (j.44 <= 16) goto ; else goto ; : if (j <= 63) goto ; else goto ; : D.24085 = base_types_emitted[j]; if (D.24085 == 0) goto ; else goto ; : emit_class_dwarf_info (w, klass, 0); base_types_emitted[j] = 1; : : goto ; : D.24070 = t->type; D.24078 = (int) D.24070; switch (D.24078) , case 15: , case 17: , case 18: , case 20: , case 21: > : emit_class_dwarf_info (w, klass, 0); goto ; : goto ; : D.24089 = BIT_FIELD_REF <*klass, 64, 256>; D.24090 = D.24089 & 576460752303423488; if (D.24090 != 0) goto ; else goto ; : emit_class_dwarf_info (w, klass, 0); : goto ; : D.24093 = mono_type_is_struct (t); if (D.24093 == 0) goto ; else goto ; : emit_class_dwarf_info (w, klass, 0); : goto ; : goto ; : goto ; : : } emit_class_dwarf_info (struct MonoDwarfWriter * w, struct MonoClass * klass, gboolean vtype) { char * D.24103; unsigned char D.24107; long unsigned int D.24114; long unsigned int D.24115; unsigned char D.24119; const char * D.24123; const char * iftmp.45; const char * D.24128; char D.24129; int D.24132; int D.24133; struct GHashTable * D.24134; struct GHashTable * D.24135; struct MonoType * D.24138; struct MonoClass * D.24139; unsigned int size.46; int D.24141; struct MonoType * D.24142; unsigned char D.24143; int D.24144; unsigned int k.47; _Bool D.24147; long int D.24148; long int D.24149; const char * D.24152; const char * D.24153; int D.24154; struct MonoType * D.24157; short unsigned int D.24158; int D.24159; int D.24160; const char * D.24163; int D.24164; const char * D.24167; const char * p.48; const char * p.49; unsigned int D.24170; struct MonoType * D.24171; unsigned char D.24172; int D.24173; char D.24174; long int D.24175; short unsigned int D.24176; short unsigned int D.24177; int D.24178; int D.24179; int D.24180; int D.24181; int D.24182; long int D.24183; unsigned int D.24184; unsigned int D.24185; unsigned int D.24186; unsigned int D.24187; unsigned int D.24188; unsigned int D.24189; unsigned int D.24190; unsigned int D.24191; unsigned int D.24192; unsigned int D.24193; long int D.24194; long unsigned int D.24195; unsigned int D.24196; unsigned int D.24197; unsigned int D.24198; unsigned int D.24199; unsigned int D.24200; unsigned int D.24201; unsigned int D.24202; unsigned int D.24203; unsigned int D.24204; unsigned int D.24205; long unsigned int D.24206; long unsigned int D.24207; long unsigned int D.24208; unsigned int D.24209; unsigned int D.24210; unsigned int D.24211; unsigned int D.24212; unsigned int D.24213; unsigned int D.24214; unsigned int D.24215; unsigned int D.24216; unsigned int D.24217; unsigned int D.24218; long unsigned int D.24219; long unsigned int D.24220; long int D.24221; struct MonoClass * D.24223; int D.24227; int iftmp.50; struct MonoClassField * D.24235; guint32 iftmp.51; int D.24240; unsigned int D.24241; guint8 * p.52; guint8 * p.53; guint8 * p.54; long int p.55; long int buf.56; long int D.24249; unsigned char D.24250; int D.24251; const char * D.24256; guint8 * p.57; guint8 * p.58; long unsigned int D.24261; int D.24264; unsigned int D.24265; unsigned int D.24266; 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 ; else goto ; : cache = w->class_to_vtype_die; goto ; : cache = w->class_to_die; : die = monoeg_g_hash_table_lookup (cache, klass); if (die != 0B) goto ; else goto ; : D.24103 = die; return D.24103; : D.24107 = klass->byval_arg.type; if (D.24107 != 18) goto ; else goto ; : D.24107 = klass->byval_arg.type; if (D.24107 != 28) goto ; else goto ; : D.24107 = klass->byval_arg.type; if (D.24107 != 21) goto ; else goto ; : D.24114 = BIT_FIELD_REF <*klass, 64, 256>; D.24115 = D.24114 & 576460752303423488; if (D.24115 == 0) goto ; else goto ; : D.24107 = klass->byval_arg.type; if (D.24107 != 17) goto ; else goto ; : if (vtype == 0) goto ; else goto ; : D.24107 = klass->byval_arg.type; D.24119 = D.24107 + 254; if (D.24119 > 11) goto ; else goto ; : if (vtype != 0) goto ; else goto ; : D.24103 = 0B; return D.24103; : : : : : if (emit_namespace != 0) goto ; else goto ; : emit_uleb128 (w, 10); D.24123 = klass->name_space; emit_string (w, D.24123); : D.24123 = klass->name_space; D.24123 = klass->name_space; if (D.24123 != 0B) goto ; else goto ; : iftmp.45 = "."; goto ; : iftmp.45 = ""; : D.24128 = klass->name; full_name = monoeg_g_strdup_printf ("%s%s%s", D.24123, iftmp.45, D.24128); p = full_name; goto ; : D.24129 = *p; if (D.24129 == 46) goto ; else goto ; : *p = 95; : p = p + 1; : D.24129 = *p; if (D.24129 != 0) goto ; else goto ; : D.24132 = w->tdie_index; die = monoeg_g_strdup_printf (".LTDIE_%d", D.24132); D.24132 = w->tdie_index; pointer_die = monoeg_g_strdup_printf (".LTDIE_%d_POINTER", D.24132); D.24132 = w->tdie_index; reference_die = monoeg_g_strdup_printf (".LTDIE_%d_REFERENCE", D.24132); D.24132 = w->tdie_index; D.24133 = D.24132 + 1; w->tdie_index = D.24133; D.24134 = w->class_to_pointer_die; monoeg_g_hash_table_insert_replace (D.24134, klass, pointer_die, 0); D.24135 = w->class_to_reference_die; monoeg_g_hash_table_insert_replace (D.24135, klass, reference_die, 0); monoeg_g_hash_table_insert_replace (cache, klass, die, 0); D.24114 = BIT_FIELD_REF <*klass, 64, 256>; D.24115 = D.24114 & 576460752303423488; if (D.24115 != 0) goto ; else goto ; : { int size; D.24138 = mono_class_enum_basetype (klass); D.24139 = mono_class_from_mono_type (D.24138); size = mono_class_value_size (D.24139, 0B); emit_label (w, die); emit_uleb128 (w, 8); emit_string (w, full_name); size.46 = (unsigned int) size; emit_uleb128 (w, size.46); k = 0; goto ; : D.24141 = basic_types[k].type; D.24142 = mono_class_enum_basetype (klass); D.24143 = D.24142->type; D.24144 = (int) D.24143; if (D.24141 == D.24144) goto ; else goto ; : k = k + 1; : k.47 = (unsigned int) k; if (k.47 <= 16) goto ; else goto ; : k.47 = (unsigned int) k; D.24147 = k.47 > 16; D.24148 = (long int) D.24147; D.24149 = __builtin_expect (D.24148, 0); if (D.24149 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1055, "k < G_N_ELEMENTS (basic_types)"); : D.24152 = basic_types[k].die_name; emit_symbol_diff (w, D.24152, ".Ldebug_info_start", 0); iter = 0B; goto ; : { const char * p; int len; MonoTypeEnum def_type; try { D.24153 = mono_field_get_name (field); D.24154 = strcmp ("value__", D.24153); if (D.24154 == 0) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.24157 = field->type; D.24158 = D.24157->attrs; D.24159 = (int) D.24158; D.24160 = D.24159 & 1536; if (D.24160 != 0) goto ; else goto ; : D.24163 = mono_field_get_name (field); D.24164 = strcmp (D.24163, "_Deleted"); if (D.24164 == 0) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : : emit_uleb128 (w, 9); D.24167 = mono_field_get_name (field); emit_string (w, D.24167); p.48 = mono_class_get_field_default_value (field, &def_type); p = p.48; p.49 = p; D.24170 = mono_metadata_decode_blob_size (p.49, &p); len = (int) D.24170; D.24171 = mono_class_enum_basetype (klass); D.24172 = D.24171->type; D.24173 = (int) D.24172; switch (D.24173) , case 2: , case 3: , case 4: , case 5: , case 6: , case 7: , case 8: , case 9: , case 10: , case 11: , case 24: , case 25: > : : : p.49 = p; D.24174 = *p.49; D.24175 = (long int) D.24174; emit_sleb128 (w, D.24175); goto ; : : : p.49 = p; D.24176 = MEM[(const guint16 *)p.49]; D.24177 = D.24176 >> 8; D.24178 = (int) D.24177; p.49 = p; D.24176 = MEM[(const guint16 *)p.49]; D.24179 = (int) D.24176; D.24180 = D.24179 << 8; D.24181 = D.24180 & 65535; D.24182 = D.24178 | D.24181; D.24183 = (long int) D.24182; emit_sleb128 (w, D.24183); goto ; : : p.49 = p; D.24184 = MEM[(const guint32 *)p.49]; D.24185 = D.24184 << 24; p.49 = p; D.24184 = MEM[(const guint32 *)p.49]; D.24186 = D.24184 >> 8; D.24187 = D.24186 & 65280; D.24188 = D.24185 | D.24187; p.49 = p; D.24184 = MEM[(const guint32 *)p.49]; D.24189 = D.24184 << 8; D.24190 = D.24189 & 16711680; D.24191 = D.24188 | D.24190; p.49 = p; D.24184 = MEM[(const guint32 *)p.49]; D.24192 = D.24184 >> 24; D.24193 = D.24191 | D.24192; D.24194 = (long int) D.24193; emit_sleb128 (w, D.24194); goto ; : : p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24196 = (unsigned int) D.24195; D.24197 = D.24196 << 24; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24196 = (unsigned int) D.24195; D.24198 = D.24196 >> 8; D.24199 = D.24198 & 65280; D.24200 = D.24197 | D.24199; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24196 = (unsigned int) D.24195; D.24201 = D.24196 << 8; D.24202 = D.24201 & 16711680; D.24203 = D.24200 | D.24202; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24196 = (unsigned int) D.24195; D.24204 = D.24196 >> 24; D.24205 = D.24203 | D.24204; D.24206 = (long unsigned int) D.24205; D.24207 = D.24206 << 32; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24208 = D.24195 >> 32; D.24209 = (unsigned int) D.24208; D.24210 = D.24209 << 24; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24208 = D.24195 >> 32; D.24209 = (unsigned int) D.24208; D.24211 = D.24209 >> 8; D.24212 = D.24211 & 65280; D.24213 = D.24210 | D.24212; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24208 = D.24195 >> 32; D.24209 = (unsigned int) D.24208; D.24214 = D.24209 << 8; D.24215 = D.24214 & 16711680; D.24216 = D.24213 | D.24215; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24208 = D.24195 >> 32; D.24209 = (unsigned int) D.24208; D.24217 = D.24209 >> 24; D.24218 = D.24216 | D.24217; D.24219 = (long unsigned int) D.24218; D.24220 = D.24207 | D.24219; D.24221 = (long int) D.24220; emit_sleb128 (w, D.24221); goto ; : : p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24196 = (unsigned int) D.24195; D.24197 = D.24196 << 24; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24196 = (unsigned int) D.24195; D.24198 = D.24196 >> 8; D.24199 = D.24198 & 65280; D.24200 = D.24197 | D.24199; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24196 = (unsigned int) D.24195; D.24201 = D.24196 << 8; D.24202 = D.24201 & 16711680; D.24203 = D.24200 | D.24202; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24196 = (unsigned int) D.24195; D.24204 = D.24196 >> 24; D.24205 = D.24203 | D.24204; D.24206 = (long unsigned int) D.24205; D.24207 = D.24206 << 32; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24208 = D.24195 >> 32; D.24209 = (unsigned int) D.24208; D.24210 = D.24209 << 24; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24208 = D.24195 >> 32; D.24209 = (unsigned int) D.24208; D.24211 = D.24209 >> 8; D.24212 = D.24211 & 65280; D.24213 = D.24210 | D.24212; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24208 = D.24195 >> 32; D.24209 = (unsigned int) D.24208; D.24214 = D.24209 << 8; D.24215 = D.24214 & 16711680; D.24216 = D.24213 | D.24215; p.49 = p; D.24195 = MEM[(const guint64 *)p.49]; D.24208 = D.24195 >> 32; D.24209 = (unsigned int) D.24208; D.24217 = D.24209 >> 24; D.24218 = D.24216 | D.24217; D.24219 = (long unsigned int) D.24218; D.24220 = D.24207 | D.24219; D.24221 = (long int) D.24220; emit_sleb128 (w, D.24221); goto ; : monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "dwarfwriter.c", 1103); : } finally { p = {CLOBBER}; def_type = {CLOBBER}; } } : field = mono_class_get_fields (klass, &iter); if (field != 0B) goto ; else goto ; : has_children = 1; } goto ; : { guint8 buf[128]; guint8 * p; char * parent_die; try { D.24223 = klass->parent; if (D.24223 != 0B) goto ; else goto ; : D.24223 = klass->parent; parent_die = emit_class_dwarf_info (w, D.24223, 0); goto ; : parent_die = 0B; : iter = 0B; goto ; : D.24157 = field->type; D.24158 = D.24157->attrs; D.24159 = (int) D.24158; D.24227 = D.24159 & 16; if (D.24227 != 0) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.24157 = field->type; emit_type (w, D.24157); : field = mono_class_get_fields (klass, &iter); if (field != 0B) goto ; else goto ; : iter = 0B; if (parent_die != 0B) goto ; else goto ; : D.24235 = mono_class_get_fields (klass, &iter); if (D.24235 != 0B) goto ; else goto ; : iftmp.50 = 1; goto ; : iftmp.50 = 0; : has_children = iftmp.50; emit_label (w, die); if (has_children != 0) goto ; else goto ; : iftmp.51 = 5; goto ; : iftmp.51 = 17; : emit_uleb128 (w, iftmp.51); emit_string (w, full_name); D.24240 = klass->instance_size; D.24241 = (unsigned int) D.24240; emit_uleb128 (w, D.24241); if (parent_die != 0B) goto ; else goto ; : emit_uleb128 (w, 16); emit_symbol_diff (w, parent_die, ".Ldebug_info_start", 0); p = &buf; p.52 = p; p.53 = p.52; p.54 = p.53 + 1; p = p.54; *p.53 = 35; p.52 = p; encode_uleb128 (0, p.52, &p); p.52 = p; p.55 = (long int) p.52; buf.56 = (long int) &buf; D.24249 = p.55 - buf.56; D.24250 = (unsigned char) D.24249; emit_byte (w, D.24250); p.52 = p; p.55 = (long int) p.52; buf.56 = (long int) &buf; D.24249 = p.55 - buf.56; D.24251 = (int) D.24249; emit_bytes (w, &buf, D.24251); : iter = 0B; goto ; : D.24157 = field->type; D.24158 = D.24157->attrs; D.24159 = (int) D.24158; D.24227 = D.24159 & 16; if (D.24227 != 0) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.24157 = field->type; fdie = get_type_die (w, D.24157); if (fdie != 0B) goto ; else goto ; : emit_uleb128 (w, 6); D.24256 = field->name; emit_string (w, D.24256); emit_symbol_diff (w, fdie, ".Ldebug_info_start", 0); p = &buf; p.52 = p; p.57 = p.52; p.58 = p.57 + 1; p = p.58; *p.57 = 35; D.24114 = BIT_FIELD_REF <*klass, 64, 256>; D.24261 = D.24114 & 1152921504606846976; if (D.24261 != 0) goto ; else goto ; : if (vtype != 0) goto ; else goto ; : D.24264 = field->offset; D.24265 = (unsigned int) D.24264; D.24266 = D.24265 + 4294967280; p.52 = p; encode_uleb128 (D.24266, p.52, &p); goto ; : D.24264 = field->offset; D.24265 = (unsigned int) D.24264; p.52 = p; encode_uleb128 (D.24265, p.52, &p); : p.52 = p; p.55 = (long int) p.52; buf.56 = (long int) &buf; D.24249 = p.55 - buf.56; D.24250 = (unsigned char) D.24249; emit_byte (w, D.24250); p.52 = p; p.55 = (long int) p.52; buf.56 = (long int) &buf; D.24249 = p.55 - buf.56; D.24251 = (int) D.24249; emit_bytes (w, &buf, D.24251); : : field = mono_class_get_fields (klass, &iter); if (field != 0B) goto ; else goto ; : } finally { buf = {CLOBBER}; p = {CLOBBER}; } } : if (has_children != 0) goto ; else goto ; : emit_uleb128 (w, 0); : 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 ; else goto ; : emit_uleb128 (w, 0); : D.24103 = die; return D.24103; } finally { iter = {CLOBBER}; } } get_type_die (struct MonoDwarfWriter * w, struct MonoType * t) { long unsigned int D.24275; long unsigned int D.24276; unsigned char D.24279; struct GHashTable * D.24282; struct MonoClass * D.24284; int D.24285; int D.24286; unsigned int j.59; struct GHashTable * D.24292; long unsigned int D.24293; long unsigned int D.24294; int D.24298; _Bool D.24302; long int D.24303; long int D.24304; const char * D.24307; struct MonoClass * klass; int j; const char * tdie; klass = mono_class_from_mono_type (t); D.24275 = BIT_FIELD_REF <*t, 64, 64>; D.24276 = D.24275 & 8589934592; if (D.24276 != 0) goto ; else goto ; : D.24279 = t->type; if (D.24279 == 17) goto ; else goto ; : D.24282 = w->class_to_pointer_die; tdie = monoeg_g_hash_table_lookup (D.24282, klass); goto ; : tdie = get_class_die (w, klass, 0); : D.24284 = mono_defaults.int_class; t = &D.24284->byval_arg; : j = 0; goto ; : D.24285 = basic_types[j].type; D.24279 = t->type; D.24286 = (int) D.24279; if (D.24285 == D.24286) goto ; else goto ; : j = j + 1; : j.59 = (unsigned int) j; if (j.59 <= 16) goto ; else goto ; : j.59 = (unsigned int) j; if (j.59 <= 16) goto ; else goto ; : tdie = basic_types[j].die_name; goto ; : D.24279 = t->type; D.24286 = (int) D.24279; switch (D.24286) , case 15: , case 17: , case 18: , case 20: , case 21: > : D.24292 = w->class_to_reference_die; tdie = monoeg_g_hash_table_lookup (D.24292, klass); goto ; : tdie = ".LDIE_OBJECT"; goto ; : D.24293 = BIT_FIELD_REF <*klass, 64, 256>; D.24294 = D.24293 & 576460752303423488; if (D.24294 != 0) goto ; else goto ; : tdie = get_class_die (w, klass, 0); goto ; : tdie = ".LDIE_I4"; : goto ; : D.24298 = mono_type_is_struct (t); if (D.24298 == 0) goto ; else goto ; : D.24292 = w->class_to_reference_die; tdie = monoeg_g_hash_table_lookup (D.24292, klass); goto ; : tdie = ".LDIE_I4"; : goto ; : tdie = ".LDIE_I"; goto ; : tdie = ".LDIE_I4"; goto ; : : D.24302 = tdie == 0B; D.24303 = (long int) D.24302; D.24304 = __builtin_expect (D.24303, 0); if (D.24304 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 1259, "tdie"); : D.24307 = tdie; return D.24307; } get_class_die (struct MonoDwarfWriter * w, struct MonoClass * klass, gboolean vtype) { const char * D.24312; struct GHashTable * cache; if (vtype != 0) goto ; else goto ; : cache = w->class_to_vtype_die; goto ; : cache = w->class_to_die; : D.24312 = monoeg_g_hash_table_lookup (cache, klass); return D.24312; } __attribute__((__unused__)) encode_uleb128 (guint32 value, guint8 * buf, guint8 * * endbuf) { unsigned char D.24314; guint8 * p.60; guint8 * p; p = buf; : { guint8 b; D.24314 = (unsigned char) value; b = D.24314 & 127; value = value >> 7; if (value != 0) goto ; else goto ; : b = b | 128; : p.60 = p; p = p.60 + 1; *p.60 = b; } if (value != 0) goto ; else goto ; : *endbuf = p; } find_vmv (struct MonoCompile * cfg, struct MonoInst * ins) { struct MonoInst * * D.24318; long unsigned int D.24321; long unsigned int D.24322; struct MonoInst * * D.24323; struct MonoInst * D.24324; unsigned int D.24326; unsigned int j.61; struct MonoMethodVar * D.24330; struct MonoMethodVar * D.24331; long unsigned int D.24332; int j; D.24318 = cfg->varinfo; if (D.24318 != 0B) goto ; else goto ; : j = 0; goto ; : D.24318 = cfg->varinfo; D.24321 = (long unsigned int) j; D.24322 = D.24321 * 8; D.24323 = D.24318 + D.24322; D.24324 = *D.24323; if (D.24324 == ins) goto ; else goto ; : j = j + 1; : D.24326 = cfg->num_varinfo; j.61 = (unsigned int) j; if (D.24326 > j.61) goto ; else goto ; : D.24326 = cfg->num_varinfo; j.61 = (unsigned int) j; if (D.24326 > j.61) goto ; else goto ; : D.24331 = cfg->vars; D.24321 = (long unsigned int) j; D.24332 = D.24321 * 80; D.24330 = D.24331 + D.24332; return D.24330; : : D.24330 = 0B; return D.24330; } __attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__)) sprintf (char * restrict __s, const char * restrict __fmt) { int D.24334; long unsigned int D.24335; D.24335 = __builtin_object_size (__s, 1); D.24334 = __builtin___sprintf_chk (__s, 1, D.24335, __fmt, __builtin_va_arg_pack ()); return D.24334; } 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.24339; int D.24340; int D.24341; short unsigned int D.24345; guint8 * p.62; int D.24349; int D.24350; unsigned char D.24351; unsigned char D.24352; guint8 * p.63; guint8 * p.64; guint8 * p.65; int D.24359; int D.24360; unsigned char D.24361; unsigned char D.24362; long int D.24363; int D.24364; guint8 * p.66; guint8 * p.67; if (ins == 0B) goto ; else goto ; : D.24339 = ins->flags; D.24340 = (int) D.24339; D.24341 = D.24340 & 2; if (D.24341 != 0) goto ; else goto ; : goto ; : D.24345 = ins->opcode; if (D.24345 == 366) goto ; else goto ; : p.62 = p; D.24349 = ins->dreg; D.24350 = mono_hw_reg_to_dwarf_reg (D.24349); D.24351 = (unsigned char) D.24350; D.24352 = D.24351 + 80; *p.62 = D.24352; p.62 = p; p.63 = p.62 + 1; p = p.63; goto ; : D.24345 = ins->opcode; if (D.24345 == 367) goto ; else goto ; : p.62 = p; p.64 = p.62; p.65 = p.64 + 1; p = p.65; D.24359 = ins->sreg1; D.24360 = mono_hw_reg_to_dwarf_reg (D.24359); D.24361 = (unsigned char) D.24360; D.24362 = D.24361 + 112; *p.64 = D.24362; D.24363 = ins->data.op[0].const_val; D.24364 = (int) D.24363; p.62 = p; encode_sleb128 (D.24364, p.62, &p); goto ; : p.62 = p; p.66 = p.62; p.67 = p.66 + 1; p = p.67; *p.66 = 80; : : : : p.62 = p; *endp = p.62; } __attribute__((__unused__)) encode_sleb128 (gint32 value, guint8 * buf, guint8 * * endbuf) { _Bool D.24368; unsigned char D.24369; unsigned int D.24372; int D.24373; int D.24374; int D.24380; int D.24381; guint8 * p.68; gboolean more; gboolean negative; guint32 size; guint8 byte; guint8 * p; more = 1; D.24368 = value < 0; negative = (gboolean) D.24368; size = 32; p = buf; goto ; : D.24369 = (unsigned char) value; byte = D.24369 & 127; value = value >> 7; if (negative != 0) goto ; else goto ; : D.24372 = size + 4294967289; D.24373 = 1 << D.24372; D.24374 = -D.24373; value = D.24374 | value; : if (value == 0) goto ; else goto ; : D.24380 = (int) byte; D.24381 = D.24380 & 64; if (D.24381 == 0) goto ; else goto ; : if (value == -1) goto ; else goto ; : D.24380 = (int) byte; D.24381 = D.24380 & 64; if (D.24381 != 0) goto ; else goto ; : more = 0; goto ; : byte = byte | 128; : p.68 = p; p = p.68 + 1; *p.68 = byte; : if (more != 0) goto ; else goto ; : *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.24384; int D.24385; int D.24386; unsigned char D.24387; unsigned int D.24388; unsigned char D.24389; int expr_len.69; char label[128]; try { emit_push_section (w, ".debug_loc", 0); D.24384 = w->loclist_index; D.24385 = D.24384; D.24386 = D.24385 + 1; w->loclist_index = D.24386; sprintf (&label, ".Lloclist_%d", D.24385); emit_label (w, &label); emit_pointer_value (w, loclist_begin_addr); emit_pointer_value (w, loclist_end_addr); D.24387 = (unsigned char) expr_len; emit_byte (w, D.24387); D.24388 = expr_len / 256; D.24389 = (unsigned char) D.24388; emit_byte (w, D.24389); expr_len.69 = (int) expr_len; emit_bytes (w, expr, expr_len.69); 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.24391; D.24391 = w->w; img_writer_emit_push_section (D.24391, section_name, subsection); } emit_pop_section (struct MonoDwarfWriter * w) { struct MonoImageWriter * D.24392; D.24392 = w->w; img_writer_emit_pop_section (D.24392); } 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.24398; long int D.24399; long int D.24400; int code_size.70; struct GSList * D.24405; unsigned int D.24410; unsigned int i.71; unsigned int uw_info_len.72; int uw_info_len.73; 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 ; else goto ; : emit_pointer (w, start_symbol); if (end_symbol != 0B) goto ; else goto ; : emit_symbol_diff (w, end_symbol, start_symbol, 0); goto ; : D.24398 = code_size == 0; D.24399 = (long int) D.24398; D.24400 = __builtin_expect (D.24399, 0); if (D.24400 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dwarfwriter.c", 395, "code_size"); : code_size.70 = (int) code_size; emit_int32 (w, code_size.70); : goto ; : emit_pointer_value (w, code); code_size.70 = (int) code_size; emit_int32 (w, code_size.70); : emit_int32 (w, 0); l = unwind_ops; D.24405 = w->cie_program; if (D.24405 != 0B) goto ; else goto ; : { int i; i = 0; goto ; : if (l != 0B) goto ; else goto ; : l = l->next; : i = i + 1; : D.24405 = w->cie_program; D.24410 = monoeg_g_slist_length (D.24405); i.71 = (unsigned int) i; if (D.24410 > i.71) goto ; else goto ; : } : uw_info = mono_unwind_ops_encode (l, &uw_info_len); uw_info_len.72 = uw_info_len; uw_info_len.73 = (int) uw_info_len.72; emit_bytes (w, uw_info, uw_info_len.73); monoeg_g_free (uw_info); emit_alignment (w, 8); emit_label (w, &symbol2); } finally { symbol1 = {CLOBBER}; symbol2 = {CLOBBER}; uw_info_len = {CLOBBER}; } } emit_pointer (struct MonoDwarfWriter * w, const char * target) { struct MonoImageWriter * D.24414; D.24414 = w->w; img_writer_emit_pointer (D.24414, target); } emit_line (struct MonoDwarfWriter * w) { struct MonoImageWriter * D.24415; D.24415 = w->w; img_writer_emit_line (D.24415); } __attribute__((visibility ("hidden"))) 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) { sizetype D.24416; guint8 * D.24417; int D.24418; int D.24419; emit_section_change (w, ".debug_info", 0); emit_uleb128 (w, 18); emit_string (w, tramp_name); emit_pointer_value (w, code); D.24416 = (sizetype) code_size; D.24417 = code + D.24416; emit_pointer_value (w, D.24417); emit_uleb128 (w, 0); emit_debug_info_end (w); D.24418 = w->fde_index; emit_fde (w, D.24418, start_symbol, end_symbol, code, code_size, unwind_info, 0); D.24418 = w->fde_index; D.24419 = D.24418 + 1; w->fde_index = D.24419; }