_wapi_getpid () { pid_t D.11700; mono_once (&pid_init_once, pid_init); D.11700 = _wapi_pid; return D.11700; } pid_init () { int _wapi_pid.0; _wapi_pid.0 = getpid (); _wapi_pid = _wapi_pid.0; } wapi_init () { int D.11705; unsigned int _wapi_fd_reserve.1; unsigned int _wapi_fd_reserve.2; unsigned int D.11708; unsigned int _wapi_fd_reserve.3; unsigned int _wapi_private_handle_count.4; unsigned int _wapi_private_handle_count.5; unsigned int _wapi_private_handle_slot_count.6; unsigned int _wapi_private_handle_slot_count.7; void * _wapi_shared_layout.8; struct _WapiHandleSharedLayout * _wapi_shared_layout.9; _Bool D.11716; long int D.11717; long int D.11718; int D.11721; void * _wapi_fileshare_layout.10; struct _WapiFileShareLayout * _wapi_fileshare_layout.11; _Bool D.11726; long int D.11727; long int D.11728; int D.11731; void * _wapi_global_signal_handle.12; void * _wapi_global_signal_handle.13; long int _wapi_global_signal_handle.14; unsigned int D.11737; unsigned int D.11738; struct _WapiHandleUnshared * D.11739; long unsigned int D.11740; long unsigned int D.11741; long unsigned int D.11742; struct _WapiHandleUnshared * D.11743; union pthread_cond_t * _wapi_global_signal_cond.15; union mono_mutex_t * _wapi_global_signal_mutex.16; if (0 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 247, "(sizeof (handle_ops) / sizeof (handle_ops[0])) == WAPI_HANDLE_COUNT"); : D.11705 = getdtablesize (); _wapi_fd_reserve.1 = (unsigned int) D.11705; _wapi_fd_reserve = _wapi_fd_reserve.1; _wapi_fd_reserve.2 = _wapi_fd_reserve; D.11708 = _wapi_fd_reserve.2 + 255; _wapi_fd_reserve.3 = D.11708 & 4294967040; _wapi_fd_reserve = _wapi_fd_reserve.3; : _wapi_private_handle_count.4 = _wapi_private_handle_count; _wapi_private_handle_count.5 = _wapi_private_handle_count.4 + 256; _wapi_private_handle_count = _wapi_private_handle_count.5; _wapi_private_handle_slot_count.6 = _wapi_private_handle_slot_count; _wapi_private_handle_slot_count.7 = _wapi_private_handle_slot_count.6 + 1; _wapi_private_handle_slot_count = _wapi_private_handle_slot_count.7; _wapi_fd_reserve.2 = _wapi_fd_reserve; _wapi_private_handle_count.4 = _wapi_private_handle_count; if (_wapi_fd_reserve.2 > _wapi_private_handle_count.4) goto ; else goto ; : _wapi_shm_semaphores_init (); _wapi_shared_layout.8 = _wapi_shm_attach (0); _wapi_shared_layout = _wapi_shared_layout.8; _wapi_shared_layout.9 = _wapi_shared_layout; D.11716 = _wapi_shared_layout.9 == 0B; D.11717 = (long int) D.11716; D.11718 = __builtin_expect (D.11717, 0); if (D.11718 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 271, "_wapi_shared_layout != NULL"); : D.11721 = _wapi_shm_enabled (); if (D.11721 != 0) goto ; else goto ; : _wapi_fileshare_layout.10 = _wapi_shm_attach (1); _wapi_fileshare_layout = _wapi_fileshare_layout.10; _wapi_fileshare_layout.11 = _wapi_fileshare_layout; D.11726 = _wapi_fileshare_layout.11 == 0B; D.11727 = (long int) D.11726; D.11728 = __builtin_expect (D.11727, 0); if (D.11728 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 276, "_wapi_fileshare_layout != NULL"); : : D.11731 = _wapi_shm_enabled (); if (D.11731 != 0) goto ; else goto ; : _wapi_collection_init (); : _wapi_io_init (); pthread_mutex_init (&scan_mutex, 0B); _wapi_global_signal_handle.12 = _wapi_handle_new (6, 0B); _wapi_global_signal_handle = _wapi_global_signal_handle.12; _wapi_global_signal_handle.13 = _wapi_global_signal_handle; _wapi_global_signal_handle.14 = (long int) _wapi_global_signal_handle.13; D.11737 = (unsigned int) _wapi_global_signal_handle.14; D.11738 = D.11737 / 256; D.11739 = _wapi_private_handles[D.11738]; _wapi_global_signal_handle.13 = _wapi_global_signal_handle; _wapi_global_signal_handle.14 = (long int) _wapi_global_signal_handle.13; D.11737 = (unsigned int) _wapi_global_signal_handle.14; D.11740 = (long unsigned int) D.11737; D.11741 = D.11740 & 255; D.11742 = D.11741 * 200; D.11743 = D.11739 + D.11742; _wapi_global_signal_cond.15 = &D.11743->signal_cond; _wapi_global_signal_cond = _wapi_global_signal_cond.15; _wapi_global_signal_handle.13 = _wapi_global_signal_handle; _wapi_global_signal_handle.14 = (long int) _wapi_global_signal_handle.13; D.11737 = (unsigned int) _wapi_global_signal_handle.14; D.11738 = D.11737 / 256; D.11739 = _wapi_private_handles[D.11738]; _wapi_global_signal_handle.13 = _wapi_global_signal_handle; _wapi_global_signal_handle.14 = (long int) _wapi_global_signal_handle.13; D.11737 = (unsigned int) _wapi_global_signal_handle.14; D.11740 = (long unsigned int) D.11737; D.11741 = D.11740 & 255; D.11742 = D.11741 * 200; D.11743 = D.11739 + D.11742; _wapi_global_signal_mutex.16 = &D.11743->signal_mutex; _wapi_global_signal_mutex = _wapi_global_signal_mutex.16; atexit (handle_cleanup); } handle_cleanup () { struct _WapiHandleUnshared * D.11746; long unsigned int D.11747; long unsigned int D.11748; D.11749; int D.11750; int D.11751; long int D.11752; _Bool D.11755; _Bool D.11756; _Bool D.11757; unsigned int type.17; unsigned int D.11760; unsigned int D.11765; struct GHashTable * file_share_hash.18; int i; int j; int k; i = 0; goto ; : j = 0; goto ; : { struct _WapiHandleUnshared * handle_data; int type; void * handle; D.11746 = _wapi_private_handles[i]; D.11747 = (long unsigned int) j; D.11748 = D.11747 * 200; handle_data = D.11746 + D.11748; D.11749 = handle_data->type; type = (int) D.11749; D.11750 = i * 256; D.11751 = D.11750 + j; D.11752 = (long int) D.11751; handle = (void *) D.11752; D.11755 = type == 9; D.11756 = type == 11; D.11757 = D.11755 | D.11756; if (D.11757 != 0) goto ; else goto ; : type.17 = (unsigned int) type; D.11760 = type.17 + 4294967284; if (D.11760 <= 1) goto ; else goto ; : if (type == 3) goto ; else goto ; : if (1 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 211, "0"); : _wapi_thread_set_termination_details (handle, 0); : : D.11765 = handle_data->ref; k = (int) D.11765; goto ; : _wapi_handle_unref_full (handle, 1); k = k + -1; : if (k > 0) goto ; else goto ; : } j = j + 1; : if (j <= 255) goto ; else goto ; : i = i + 1; : D.11746 = _wapi_private_handles[i]; if (D.11746 != 0B) goto ; else goto ; : _wapi_shm_semaphores_remove (); _wapi_shm_detach (0); _wapi_shm_detach (1); file_share_hash.18 = file_share_hash; if (file_share_hash.18 != 0B) goto ; else goto ; : file_share_hash.18 = file_share_hash; monoeg_g_hash_table_destroy (file_share_hash.18); DeleteCriticalSection (&file_share_hash_mutex); : i = 0; goto ; : D.11746 = _wapi_private_handles[i]; monoeg_g_free (D.11746); i = i + 1; : if (i <= 16383) goto ; else goto ; : } _wapi_handle_unref_full (void * handle, gboolean ignore_private_busy_handles) { long int handle.19; D.11772; unsigned int D.11775; struct _WapiHandleUnshared * D.11776; long unsigned int D.11777; long unsigned int D.11778; long unsigned int D.11779; struct _WapiHandleUnshared * D.11780; guint * D.11781; int D.11782; _Bool D.11783; int iftmp.20; _Bool D.11790; _Bool D.11791; _Bool D.11792; unsigned int D.11794; _Bool D.11797; long int D.11798; long int D.11799; long int D.11802; long int D.11803; union { struct _WapiHandle_event event; struct _WapiHandle_file file; struct _WapiHandle_find find; struct _WapiHandle_mutex mutex; struct _WapiHandle_sem sem; struct _WapiHandle_socket sock; struct _WapiHandle_thread thread; struct _WapiHandle_shared_ref shared; } * D.11806; union mono_mutex_t * D.11809; _Bool D.11810; _Bool D.11811; _Bool D.11812; union pthread_cond_t * D.11818; struct _WapiHandleSharedLayout * _wapi_shared_layout.21; unsigned int D.11826; unsigned int D.11827; unsigned int D.11830; guint32 idx; gboolean destroy; gboolean early_exit; int thr_ret; static const char __func__[24] = "_wapi_handle_unref_full"; handle.19 = (long int) handle; idx = (guint32) handle.19; destroy = 0; early_exit = 0; if (idx > 4194303) goto ; else goto ; : return; : D.11772 = _wapi_handle_type (handle); if (D.11772 == 0) goto ; else goto ; : monoeg_g_log (0B, 16, "%s: Attempting to unref unused handle %p", &__func__, handle); return; : D.11775 = idx / 256; D.11776 = _wapi_private_handles[D.11775]; D.11777 = (long unsigned int) idx; D.11778 = D.11777 & 255; D.11779 = D.11778 * 200; D.11780 = D.11776 + D.11779; D.11781 = &D.11780->ref; D.11782 = InterlockedDecrement (D.11781); D.11783 = D.11782 == 0; destroy = (gboolean) D.11783; if (destroy == 1) goto ; else goto ; : { struct _WapiHandleUnshared handle_data; struct _WapiHandleShared shared_handle_data; WapiHandleType type; void (*) (void *, void *) close_func; gboolean is_shared; try { D.11775 = idx / 256; D.11776 = _wapi_private_handles[D.11775]; D.11777 = (long unsigned int) idx; D.11778 = D.11777 & 255; D.11779 = D.11778 * 200; D.11780 = D.11776 + D.11779; type = D.11780->type; close_func = _wapi_handle_ops_get_close_func (type); D.11790 = type == 9; D.11791 = type == 11; D.11792 = D.11790 | D.11791; if (D.11792 != 0) goto ; else goto ; : D.11794 = type + 4294967284; if (D.11794 <= 1) goto ; else goto ; : iftmp.20 = 1; goto ; : iftmp.20 = 0; : is_shared = iftmp.20; if (is_shared != 0) goto ; else goto ; : thr_ret = _wapi_handle_lock_shared_handles (); D.11797 = thr_ret != 0; D.11798 = (long int) D.11797; D.11799 = __builtin_expect (D.11798, 0); if (D.11799 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1080, "thr_ret == 0"); : : { struct __pthread_unwind_buf_t __cancel_buf; void (*) (void *) __cancel_routine; void * __cancel_arg; int __not_first_call; try { __cancel_routine = mono_mutex_unlock_in_cleanup; __cancel_arg = &scan_mutex; __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0); D.11802 = (long int) __not_first_call; D.11803 = __builtin_expect (D.11802, 0); if (D.11803 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); : __pthread_register_cancel (&__cancel_buf); thr_ret = pthread_mutex_lock (&scan_mutex); D.11775 = idx / 256; D.11776 = _wapi_private_handles[D.11775]; D.11777 = (long unsigned int) idx; D.11778 = D.11777 & 255; D.11779 = D.11778 * 200; D.11780 = D.11776 + D.11779; memcpy (&handle_data, D.11780, 200); D.11775 = idx / 256; D.11776 = _wapi_private_handles[D.11775]; D.11777 = (long unsigned int) idx; D.11778 = D.11777 & 255; D.11779 = D.11778 * 200; D.11780 = D.11776 + D.11779; D.11806 = &D.11780->u; memset (D.11806, 0, 96); D.11775 = idx / 256; D.11776 = _wapi_private_handles[D.11775]; D.11777 = (long unsigned int) idx; D.11778 = D.11777 & 255; D.11779 = D.11778 * 200; D.11780 = D.11776 + D.11779; D.11780->type = 0; if (is_shared == 0) goto ; else goto ; : D.11775 = idx / 256; D.11776 = _wapi_private_handles[D.11775]; D.11777 = (long unsigned int) idx; D.11778 = D.11777 & 255; D.11779 = D.11778 * 200; D.11780 = D.11776 + D.11779; D.11809 = &D.11780->signal_mutex; thr_ret = pthread_mutex_destroy (D.11809); D.11810 = thr_ret == 16; D.11811 = ignore_private_busy_handles != 0; D.11812 = D.11810 & D.11811; if (D.11812 != 0) goto ; else goto ; : early_exit = 1; goto ; : if (thr_ret != 0) goto ; else goto ; : monoeg_g_log (0B, 4, "Error destroying handle %p mutex due to %d\n", handle, thr_ret); : goto ; : D.11775 = idx / 256; D.11776 = _wapi_private_handles[D.11775]; D.11777 = (long unsigned int) idx; D.11778 = D.11777 & 255; D.11779 = D.11778 * 200; D.11780 = D.11776 + D.11779; D.11818 = &D.11780->signal_cond; thr_ret = pthread_cond_destroy (D.11818); D.11810 = thr_ret == 16; D.11811 = ignore_private_busy_handles != 0; D.11812 = D.11810 & D.11811; if (D.11812 != 0) goto ; else goto ; : early_exit = 1; goto ; : if (thr_ret != 0) goto ; else goto ; : monoeg_g_log (0B, 4, "Error destroying handle %p cond var due to %d\n", handle, thr_ret); : goto ; : : : goto ; : { struct _WapiHandleShared * shared; _wapi_shared_layout.21 = _wapi_shared_layout; D.11826 = handle_data.u.shared.offset; shared = &_wapi_shared_layout.21->handles[D.11826]; memcpy (&shared_handle_data, shared, 336); D.11827 = shared->handle_refs; if (D.11827 != 0) goto ; else goto ; : D.11827 = shared->handle_refs; D.11830 = D.11827 + 4294967295; shared->handle_refs = D.11830; D.11827 = shared->handle_refs; if (D.11827 == 0) goto ; else goto ; : memset (shared, 0, 336); : : } : thr_ret = pthread_mutex_unlock (&scan_mutex); D.11797 = thr_ret != 0; D.11798 = (long int) D.11797; D.11799 = __builtin_expect (D.11798, 0); if (D.11799 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1138, "thr_ret == 0"); : __pthread_unregister_cancel (&__cancel_buf); if (0 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); : } finally { __cancel_buf = {CLOBBER}; } } if (early_exit != 0) goto ; else goto ; : return; : if (is_shared != 0) goto ; else goto ; : _wapi_handle_unlock_shared_handles (); : if (close_func != 0B) goto ; else goto ; : if (is_shared != 0) goto ; else goto ; : close_func (handle, &shared_handle_data.u); goto ; : close_func (handle, &handle_data.u); : : } finally { handle_data = {CLOBBER}; shared_handle_data = {CLOBBER}; } } : } mono_mutex_unlock_in_cleanup (union mono_mutex_t * mutex) { int D.11855; D.11855 = pthread_mutex_unlock (mutex); return D.11855; } _wapi_handle_type (void * handle) { long int handle.22; unsigned int D.11861; struct _WapiHandleUnshared * D.11862; WapiHandleType D.11863; unsigned int D.11864; struct _WapiHandleUnshared * D.11865; long unsigned int D.11866; long unsigned int D.11867; long unsigned int D.11868; struct _WapiHandleUnshared * D.11869; guint32 idx; handle.22 = (long int) handle; idx = (guint32) handle.22; if (idx > 4194303) goto ; else goto ; : D.11861 = idx / 256; D.11862 = _wapi_private_handles[D.11861]; if (D.11862 == 0B) goto ; else goto ; : D.11863 = 0; return D.11863; : D.11864 = idx / 256; D.11865 = _wapi_private_handles[D.11864]; D.11866 = (long unsigned int) idx; D.11867 = D.11866 & 255; D.11868 = D.11867 * 200; D.11869 = D.11865 + D.11868; D.11863 = D.11869->type; return D.11863; } InterlockedDecrement (volatile gint32 * val) { gint32 D.11871; unsigned int D.11872; D.11872 = __sync_sub_and_fetch_4 (val, 1); D.11871 = (gint32) D.11872; return D.11871; } _wapi_handle_ops_get_close_func (WapiHandleType type) { struct _WapiHandleOps * D.11874; void (*) (void *, void *) D.11877; void (*) (void *, void *) D.11880; D.11874 = handle_ops[type]; if (D.11874 != 0B) goto ; else goto ; : D.11874 = handle_ops[type]; D.11877 = D.11874->close; if (D.11877 != 0B) goto ; else goto ; : D.11874 = handle_ops[type]; D.11880 = D.11874->close; return D.11880; : : D.11880 = 0B; return D.11880; } _wapi_handle_lock_shared_handles () { int D.11882; D.11882 = _wapi_shm_sem_lock (3); return D.11882; } memcpy (void * restrict __dest, const void * restrict __src, size_t __len) { void * D.11884; long unsigned int D.11885; D.11885 = __builtin_object_size (__dest, 0); D.11884 = __builtin___memcpy_chk (__dest, __src, __len, D.11885); return D.11884; } memset (void * __dest, int __ch, size_t __len) { int D.11889; int D.11894; void * D.11896; long unsigned int D.11897; D.11889 = __builtin_constant_p (__len); if (D.11889 != 0) goto ; else goto ; : if (__len == 0) goto ; else goto ; : D.11894 = __builtin_constant_p (__ch); if (D.11894 == 0) goto ; else goto ; : if (__ch != 0) goto ; else goto ; : __warn_memset_zero_len (); D.11896 = __dest; return D.11896; : : : D.11897 = __builtin_object_size (__dest, 0); D.11896 = __builtin___memset_chk (__dest, __ch, __len, D.11897); return D.11896; } _wapi_handle_unlock_shared_handles () { int D.11899; D.11899 = _wapi_shm_sem_unlock (3); return D.11899; } wapi_cleanup () { int _wapi_has_shut_down.23; _Bool D.11902; long int D.11903; long int D.11904; _wapi_has_shut_down.23 = _wapi_has_shut_down; D.11902 = _wapi_has_shut_down.23 != 0; D.11903 = (long int) D.11902; D.11904 = __builtin_expect (D.11903, 0); if (D.11904 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 303, "_wapi_has_shut_down == FALSE"); : _wapi_has_shut_down = 1; _wapi_error_cleanup (); _wapi_thread_cleanup (); } _wapi_handle_new (WapiHandleType type, void * handle_specific) { int _wapi_has_shut_down.24; _Bool D.11908; long int D.11909; long int D.11910; int iftmp.25; unsigned int D.11917; _Bool D.11918; _Bool D.11919; _Bool D.11920; _Bool D.11922; long int D.11923; long int D.11924; long int D.11927; long int D.11928; _Bool D.11931; long int D.11932; long int D.11933; unsigned int _wapi_private_handle_count.26; unsigned int D.11937; void * D.11939; unsigned int _wapi_private_handle_count.27; unsigned int _wapi_private_handle_slot_count.28; unsigned int _wapi_private_handle_slot_count.29; unsigned int _wapi_fd_reserve.30; _Bool D.11950; long int D.11951; long int D.11952; long unsigned int D.11955; _Bool D.11958; _Bool D.11959; _Bool D.11960; unsigned int D.11962; unsigned int D.11967; struct _WapiHandleUnshared * D.11968; long unsigned int D.11969; long unsigned int D.11970; struct _WapiHandleUnshared * D.11971; void * D.11972; guint32 handle_idx; void * handle; int thr_ret; void done = <<< error >>>; handle_idx = 0; _wapi_has_shut_down.24 = _wapi_has_shut_down; D.11908 = _wapi_has_shut_down.24 != 0; D.11909 = (long int) D.11908; D.11910 = __builtin_expect (D.11909, 0); if (D.11910 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 466, "_wapi_has_shut_down == FALSE"); : D.11917 = type + 4294967295; D.11918 = D.11917 <= 1; D.11919 = type == 7; D.11920 = D.11918 | D.11919; if (D.11920 != 0) goto ; else goto ; : if (type == 10) goto ; else goto ; : iftmp.25 = 1; goto ; : iftmp.25 = 0; : D.11922 = iftmp.25 != 0; D.11923 = (long int) D.11922; D.11924 = __builtin_expect (D.11923, 0); if (D.11924 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 471, "!_WAPI_FD_HANDLE(type)"); : { struct __pthread_unwind_buf_t __cancel_buf; void (*) (void *) __cancel_routine; void * __cancel_arg; int __not_first_call; try { __cancel_routine = mono_mutex_unlock_in_cleanup; __cancel_arg = &scan_mutex; __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0); D.11927 = (long int) __not_first_call; D.11928 = __builtin_expect (D.11927, 0); if (D.11928 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); : __pthread_register_cancel (&__cancel_buf); thr_ret = pthread_mutex_lock (&scan_mutex); D.11931 = thr_ret != 0; D.11932 = (long int) D.11931; D.11933 = __builtin_expect (D.11932, 0); if (D.11933 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 476, "thr_ret == 0"); : goto ; : { int idx; _wapi_private_handle_count.26 = _wapi_private_handle_count; D.11937 = _wapi_private_handle_count.26 / 256; idx = (int) D.11937; if (idx > 16383) goto ; else goto ; : D.11939 = monoeg_malloc0 (51200); _wapi_private_handles[idx] = D.11939; _wapi_private_handle_count.26 = _wapi_private_handle_count; _wapi_private_handle_count.27 = _wapi_private_handle_count.26 + 256; _wapi_private_handle_count = _wapi_private_handle_count.27; _wapi_private_handle_slot_count.28 = _wapi_private_handle_slot_count; _wapi_private_handle_slot_count.29 = _wapi_private_handle_slot_count.28 + 1; _wapi_private_handle_slot_count = _wapi_private_handle_slot_count.29; } : handle_idx = _wapi_handle_new_internal (type, handle_specific); if (handle_idx == 0) goto ; else goto ; : thr_ret = pthread_mutex_unlock (&scan_mutex); D.11931 = thr_ret != 0; D.11932 = (long int) D.11931; D.11933 = __builtin_expect (D.11932, 0); if (D.11933 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 493, "thr_ret == 0"); : __pthread_unregister_cancel (&__cancel_buf); if (0 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); : } finally { __cancel_buf = {CLOBBER}; } } if (handle_idx == 0) goto ; else goto ; : handle = -1B; goto done; : _wapi_fd_reserve.30 = _wapi_fd_reserve; D.11950 = handle_idx < _wapi_fd_reserve.30; D.11951 = (long int) D.11950; D.11952 = __builtin_expect (D.11951, 0); if (D.11952 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 503, "handle_idx >= _wapi_fd_reserve"); : D.11955 = (long unsigned int) handle_idx; handle = (void *) D.11955; D.11958 = type == 9; D.11959 = type == 11; D.11960 = D.11958 | D.11959; if (D.11960 != 0) goto ; else goto ; : D.11962 = type + 4294967284; if (D.11962 <= 1) goto ; else goto ; : { guint32 ref; ref = _wapi_handle_new_shared (type, handle_specific); if (ref == 0) goto ; else goto ; : _wapi_handle_collect (); ref = _wapi_handle_new_shared (type, handle_specific); if (ref == 0) goto ; else goto ; : handle = -1B; goto done; : : D.11967 = handle_idx / 256; D.11968 = _wapi_private_handles[D.11967]; D.11955 = (long unsigned int) handle_idx; D.11969 = D.11955 & 255; D.11970 = D.11969 * 200; D.11971 = D.11968 + D.11970; D.11971->u.shared.offset = ref; } : done: D.11972 = handle; return D.11972; } _wapi_handle_new_internal (WapiHandleType type, void * handle_specific) { int _wapi_has_shut_down.31; _Bool D.11981; long int D.11982; long int D.11983; unsigned int last.32; unsigned int _wapi_fd_reserve.33; struct _WapiHandleUnshared * D.11991; long unsigned int D.11994; long unsigned int D.11995; D.11996; unsigned int last.34; guint32 D.12000; unsigned int _wapi_private_handle_slot_count.35; guint32 i; guint32 k; guint32 count; static guint32 last = 0; gboolean retry; void again = <<< error >>>; retry = 0; _wapi_has_shut_down.31 = _wapi_has_shut_down; D.11981 = _wapi_has_shut_down.31 != 0; D.11982 = (long int) D.11981; D.11983 = __builtin_expect (D.11982, 0); if (D.11983 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 416, "_wapi_has_shut_down == FALSE"); : last.32 = last; _wapi_fd_reserve.33 = _wapi_fd_reserve; if (last.32 < _wapi_fd_reserve.33) goto ; else goto ; : _wapi_fd_reserve.33 = _wapi_fd_reserve; last = _wapi_fd_reserve.33; goto ; : retry = 1; : again: count = last; i = count / 256; goto ; : D.11991 = _wapi_private_handles[i]; if (D.11991 != 0B) goto ; else goto ; : k = count & 255; goto ; : { struct _WapiHandleUnshared * handle; D.11991 = _wapi_private_handles[i]; D.11994 = (long unsigned int) k; D.11995 = D.11994 * 200; handle = D.11991 + D.11995; D.11996 = handle->type; if (D.11996 == 0) goto ; else goto ; : last.34 = count + 1; last = last.34; _wapi_handle_init (handle, type, handle_specific); D.12000 = count; return D.12000; : count = count + 1; } k = k + 1; : if (k <= 255) goto ; else goto ; : : i = i + 1; : _wapi_private_handle_slot_count.35 = _wapi_private_handle_slot_count; if (i < _wapi_private_handle_slot_count.35) goto ; else goto ; : if (retry != 0) goto ; else goto ; : last.32 = last; _wapi_fd_reserve.33 = _wapi_fd_reserve; if (last.32 > _wapi_fd_reserve.33) goto ; else goto ; : _wapi_fd_reserve.33 = _wapi_fd_reserve; last = _wapi_fd_reserve.33; goto again; : : D.12000 = 0; return D.12000; } _wapi_handle_init (struct _WapiHandleUnshared * handle, WapiHandleType type, void * handle_specific) { int _wapi_has_shut_down.36; _Bool D.12008; long int D.12009; long int D.12010; _Bool D.12013; _Bool D.12014; _Bool D.12015; unsigned int D.12018; union pthread_cond_t * D.12021; _Bool D.12022; long int D.12023; long int D.12024; union mono_mutex_t * D.12027; union { struct _WapiHandle_event event; struct _WapiHandle_file file; struct _WapiHandle_find find; struct _WapiHandle_mutex mutex; struct _WapiHandle_sem sem; struct _WapiHandle_socket sock; struct _WapiHandle_thread thread; struct _WapiHandle_shared_ref shared; } * D.12032; int thr_ret; _wapi_has_shut_down.36 = _wapi_has_shut_down; D.12008 = _wapi_has_shut_down.36 != 0; D.12009 = (long int) D.12008; D.12010 = __builtin_expect (D.12009, 0); if (D.12010 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 332, "_wapi_has_shut_down == FALSE"); : handle->type = type; handle->signalled = 0; handle->ref = 1; D.12013 = type != 9; D.12014 = type != 11; D.12015 = D.12013 & D.12014; if (D.12015 != 0) goto ; else goto ; : D.12018 = type + 4294967284; if (D.12018 > 1) goto ; else goto ; : D.12021 = &handle->signal_cond; thr_ret = pthread_cond_init (D.12021, 0B); D.12022 = thr_ret != 0; D.12023 = (long int) D.12022; D.12024 = __builtin_expect (D.12023, 0); if (D.12024 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 340, "thr_ret == 0"); : D.12027 = &handle->signal_mutex; thr_ret = pthread_mutex_init (D.12027, 0B); D.12022 = thr_ret != 0; D.12023 = (long int) D.12022; D.12024 = __builtin_expect (D.12023, 0); if (D.12024 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 343, "thr_ret == 0"); : if (handle_specific != 0B) goto ; else goto ; : D.12032 = &handle->u; memcpy (D.12032, handle_specific, 96); : : : } _wapi_handle_new_shared (WapiHandleType type, void * handle_specific) { int _wapi_has_shut_down.37; _Bool D.12034; long int D.12035; long int D.12036; struct _WapiHandleSharedLayout * _wapi_shared_layout.38; D.12040; _Bool D.12043; long int D.12044; long int D.12045; int type.39; WapiHandleType * D.12049; int D.12050; unsigned int last.40; guint32 D.12054; unsigned int last.41; guint32 offset; static guint32 last = 1; int thr_ret; void again = <<< error >>>; _wapi_has_shut_down.37 = _wapi_has_shut_down; D.12034 = _wapi_has_shut_down.37 != 0; D.12035 = (long int) D.12034; D.12036 = __builtin_expect (D.12035, 0); if (D.12036 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 359, "_wapi_has_shut_down == FALSE"); : again: offset = last; goto ; : { struct _WapiHandleShared * handle; _wapi_shared_layout.38 = _wapi_shared_layout; handle = &_wapi_shared_layout.38->handles[offset]; D.12040 = handle->type; if (D.12040 == 0) goto ; else goto ; : thr_ret = _wapi_handle_lock_shared_handles (); D.12043 = thr_ret != 0; D.12044 = (long int) D.12043; D.12045 = __builtin_expect (D.12044, 0); if (D.12045 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 369, "thr_ret == 0"); : type.39 = (int) type; D.12049 = &handle->type; D.12050 = InterlockedCompareExchange (D.12049, type.39, 0); if (D.12050 == 0) goto ; else goto ; : last.40 = offset + 1; last = last.40; _wapi_handle_init_shared (handle, type, handle_specific); _wapi_handle_unlock_shared_handles (); D.12054 = offset; return D.12054; : _wapi_handle_unlock_shared_handles (); : } offset = offset + 1; : if (offset <= 255) goto ; else goto ; : last.41 = last; if (last.41 > 1) goto ; else goto ; : last = 1; goto again; : D.12054 = 0; return D.12054; } InterlockedCompareExchange (volatile gint32 * dest, gint32 exch, gint32 comp) { gint32 D.12059; unsigned int exch.42; unsigned int comp.43; unsigned int D.12062; exch.42 = (unsigned int) exch; comp.43 = (unsigned int) comp; D.12062 = __sync_val_compare_and_swap_4 (dest, comp.43, exch.42); D.12059 = (gint32) D.12062; return D.12059; } _wapi_handle_init_shared (struct _WapiHandleShared * handle, WapiHandleType type, void * handle_specific) { int _wapi_has_shut_down.44; _Bool D.12065; long int D.12066; long int D.12067; long int D.12070; unsigned int D.12071; union { struct _WapiHandle_process process; struct _WapiHandle_namedmutex namedmutex; struct _WapiHandle_namedsem namedsem; struct _WapiHandle_namedevent namedevent; } * D.12074; _wapi_has_shut_down.44 = _wapi_has_shut_down; D.12065 = _wapi_has_shut_down.44 != 0; D.12066 = (long int) D.12065; D.12067 = __builtin_expect (D.12066, 0); if (D.12067 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 315, "_wapi_has_shut_down == FALSE"); : handle->type = type; D.12070 = time (0B); D.12071 = (unsigned int) D.12070; handle->timestamp = D.12071; handle->signalled = 0; handle->handle_refs = 1; if (handle_specific != 0B) goto ; else goto ; : D.12074 = &handle->u; memcpy (D.12074, handle_specific, 320); : } _wapi_handle_new_from_offset (WapiHandleType type, guint32 offset, gboolean timestamp) { int _wapi_has_shut_down.45; _Bool D.12076; long int D.12077; long int D.12078; int iftmp.46; unsigned int D.12085; _Bool D.12086; _Bool D.12087; _Bool D.12088; _Bool D.12090; long int D.12091; long int D.12092; int iftmp.47; _Bool D.12098; _Bool D.12099; _Bool D.12100; unsigned int D.12102; _Bool D.12104; long int D.12105; long int D.12106; _Bool D.12109; long int D.12110; long int D.12111; struct _WapiHandleSharedLayout * _wapi_shared_layout.48; long int D.12117; int now.49; guint32 * D.12119; long int D.12120; long int D.12121; _Bool D.12124; long int D.12125; long int D.12126; struct _WapiHandleUnshared * D.12129; long unsigned int D.12132; long unsigned int D.12133; D.12134; unsigned int D.12137; int D.12140; int D.12141; long unsigned int D.12142; unsigned int i.50; unsigned int _wapi_private_handle_slot_count.51; void * D.12151; D.12154; long int D.12157; long int D.12158; unsigned int _wapi_private_handle_count.52; unsigned int D.12164; void * D.12165; unsigned int _wapi_private_handle_count.53; unsigned int _wapi_private_handle_slot_count.54; unsigned int _wapi_fd_reserve.55; _Bool D.12173; long int D.12174; long int D.12175; long unsigned int D.12178; unsigned int D.12179; struct _WapiHandleUnshared * D.12180; long unsigned int D.12181; long unsigned int D.12182; struct _WapiHandleUnshared * D.12183; guint32 * D.12184; guint32 handle_idx; void * handle; int thr_ret; int i; int k; struct _WapiHandleShared * shared; void first_pass_done = <<< error >>>; void done = <<< error >>>; handle_idx = 0; handle = -1B; _wapi_has_shut_down.45 = _wapi_has_shut_down; D.12076 = _wapi_has_shut_down.45 != 0; D.12077 = (long int) D.12076; D.12078 = __builtin_expect (D.12077, 0); if (D.12078 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 541, "_wapi_has_shut_down == FALSE"); : D.12085 = type + 4294967295; D.12086 = D.12085 <= 1; D.12087 = type == 7; D.12088 = D.12086 | D.12087; if (D.12088 != 0) goto ; else goto ; : if (type == 10) goto ; else goto ; : iftmp.46 = 1; goto ; : iftmp.46 = 0; : D.12090 = iftmp.46 != 0; D.12091 = (long int) D.12090; D.12092 = __builtin_expect (D.12091, 0); if (D.12092 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 546, "!_WAPI_FD_HANDLE(type)"); : D.12098 = type != 9; D.12099 = type != 11; D.12100 = D.12098 & D.12099; if (D.12100 != 0) goto ; else goto ; : D.12102 = type + 4294967284; if (D.12102 > 1) goto ; else goto ; : iftmp.47 = 1; goto ; : iftmp.47 = 0; : D.12104 = iftmp.47 != 0; D.12105 = (long int) D.12104; D.12106 = __builtin_expect (D.12105, 0); if (D.12106 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 547, "_WAPI_SHARED_HANDLE(type)"); : D.12109 = offset == 0; D.12110 = (long int) D.12109; D.12111 = __builtin_expect (D.12110, 0); if (D.12111 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 548, "offset != 0"); : _wapi_shared_layout.48 = _wapi_shared_layout; shared = &_wapi_shared_layout.48->handles[offset]; if (timestamp != 0) goto ; else goto ; : { guint32 now; D.12117 = time (0B); now = (guint32) D.12117; now.49 = (int) now; D.12119 = &shared->timestamp; InterlockedExchange (D.12119, now.49); } : { struct __pthread_unwind_buf_t __cancel_buf; void (*) (void *) __cancel_routine; void * __cancel_arg; int __not_first_call; try { __cancel_routine = mono_mutex_unlock_in_cleanup; __cancel_arg = &scan_mutex; __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0); D.12120 = (long int) __not_first_call; D.12121 = __builtin_expect (D.12120, 0); if (D.12121 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); : __pthread_register_cancel (&__cancel_buf); thr_ret = pthread_mutex_lock (&scan_mutex); D.12124 = thr_ret != 0; D.12125 = (long int) D.12124; D.12126 = __builtin_expect (D.12125, 0); if (D.12126 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 560, "thr_ret == 0"); : i = 0; goto ; : D.12129 = _wapi_private_handles[i]; if (D.12129 != 0B) goto ; else goto ; : k = 0; goto ; : { struct _WapiHandleUnshared * handle_data; D.12129 = _wapi_private_handles[i]; D.12132 = (long unsigned int) k; D.12133 = D.12132 * 200; handle_data = D.12129 + D.12133; D.12134 = handle_data->type; if (D.12134 == type) goto ; else goto ; : D.12137 = handle_data->u.shared.offset; if (D.12137 == offset) goto ; else goto ; : D.12140 = i * 256; D.12141 = D.12140 + k; D.12142 = (long unsigned int) D.12141; handle = (void *) D.12142; goto first_pass_done; : : } k = k + 1; : if (k <= 255) goto ; else goto ; : : i = i + 1; : i.50 = (unsigned int) i; _wapi_private_handle_slot_count.51 = _wapi_private_handle_slot_count; if (i.50 < _wapi_private_handle_slot_count.51) goto ; else goto ; : first_pass_done: thr_ret = pthread_mutex_unlock (&scan_mutex); D.12124 = thr_ret != 0; D.12125 = (long int) D.12124; D.12126 = __builtin_expect (D.12125, 0); if (D.12126 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 578, "thr_ret == 0"); : __pthread_unregister_cancel (&__cancel_buf); if (0 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); : } finally { __cancel_buf = {CLOBBER}; } } if (handle != -1B) goto ; else goto ; : _wapi_handle_ref (handle); D.12151 = handle; return D.12151; : thr_ret = _wapi_handle_lock_shared_handles (); D.12124 = thr_ret != 0; D.12125 = (long int) D.12124; D.12126 = __builtin_expect (D.12125, 0); if (D.12126 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 591, "thr_ret == 0"); : D.12154 = shared->type; if (D.12154 == 0) goto done; else goto ; : D.12154 = shared->type; if (D.12154 != type) goto done; else goto ; : { struct __pthread_unwind_buf_t __cancel_buf; void (*) (void *) __cancel_routine; void * __cancel_arg; int __not_first_call; try { __cancel_routine = mono_mutex_unlock_in_cleanup; __cancel_arg = &scan_mutex; __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0); D.12157 = (long int) __not_first_call; D.12158 = __builtin_expect (D.12157, 0); if (D.12158 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); : __pthread_register_cancel (&__cancel_buf); thr_ret = pthread_mutex_lock (&scan_mutex); D.12124 = thr_ret != 0; D.12125 = (long int) D.12124; D.12126 = __builtin_expect (D.12125, 0); if (D.12126 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 610, "thr_ret == 0"); : goto ; : { int idx; _wapi_private_handle_count.52 = _wapi_private_handle_count; D.12164 = _wapi_private_handle_count.52 / 256; idx = (int) D.12164; D.12165 = monoeg_malloc0 (51200); _wapi_private_handles[idx] = D.12165; _wapi_private_handle_count.52 = _wapi_private_handle_count; _wapi_private_handle_count.53 = _wapi_private_handle_count.52 + 256; _wapi_private_handle_count = _wapi_private_handle_count.53; _wapi_private_handle_slot_count.51 = _wapi_private_handle_slot_count; _wapi_private_handle_slot_count.54 = _wapi_private_handle_slot_count.51 + 1; _wapi_private_handle_slot_count = _wapi_private_handle_slot_count.54; } : handle_idx = _wapi_handle_new_internal (type, 0B); if (handle_idx == 0) goto ; else goto ; : thr_ret = pthread_mutex_unlock (&scan_mutex); D.12124 = thr_ret != 0; D.12125 = (long int) D.12124; D.12126 = __builtin_expect (D.12125, 0); if (D.12126 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 623, "thr_ret == 0"); : __pthread_unregister_cancel (&__cancel_buf); if (0 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); : } finally { __cancel_buf = {CLOBBER}; } } _wapi_fd_reserve.55 = _wapi_fd_reserve; D.12173 = handle_idx < _wapi_fd_reserve.55; D.12174 = (long int) D.12173; D.12175 = __builtin_expect (D.12174, 0); if (D.12175 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 627, "handle_idx >= _wapi_fd_reserve"); : D.12178 = (long unsigned int) handle_idx; handle = (void *) D.12178; D.12179 = handle_idx / 256; D.12180 = _wapi_private_handles[D.12179]; D.12178 = (long unsigned int) handle_idx; D.12181 = D.12178 & 255; D.12182 = D.12181 * 200; D.12183 = D.12180 + D.12182; D.12183->u.shared.offset = offset; D.12184 = &shared->handle_refs; InterlockedIncrement (D.12184); done: _wapi_handle_unlock_shared_handles (); D.12151 = handle; return D.12151; } InterlockedExchange (volatile gint32 * val, gint32 new_val) { unsigned int new_val.56; unsigned int old_val.57; unsigned int D.12195; int D.12196; gint32 D.12197; gint32 old_val; : old_val = *val; new_val.56 = (unsigned int) new_val; old_val.57 = (unsigned int) old_val; D.12195 = __sync_val_compare_and_swap_4 (val, old_val.57, new_val.56); D.12196 = (int) D.12195; if (D.12196 != old_val) goto ; else goto ; : D.12197 = old_val; return D.12197; } InterlockedIncrement (volatile gint32 * val) { gint32 D.12199; unsigned int D.12200; D.12200 = __sync_add_and_fetch_4 (val, 1); D.12199 = (gint32) D.12200; return D.12199; } _wapi_handle_new_fd (WapiHandleType type, int fd, void * handle_specific) { int _wapi_has_shut_down.58; _Bool D.12203; long int D.12204; long int D.12205; int iftmp.59; unsigned int D.12211; _Bool D.12212; _Bool D.12213; _Bool D.12214; _Bool D.12217; long int D.12218; long int D.12219; int iftmp.60; _Bool D.12226; _Bool D.12227; _Bool D.12228; unsigned int D.12230; _Bool D.12231; long int D.12232; long int D.12233; unsigned int fd.61; unsigned int _wapi_fd_reserve.62; void * D.12240; int D.12241; struct _WapiHandleUnshared * D.12242; int D.12245; long unsigned int D.12246; long unsigned int D.12247; D.12248; _Bool D.12251; long int D.12252; long int D.12253; long unsigned int D.12256; struct _WapiHandleUnshared * handle; int thr_ret; _wapi_has_shut_down.58 = _wapi_has_shut_down; D.12203 = _wapi_has_shut_down.58 != 0; D.12204 = (long int) D.12203; D.12205 = __builtin_expect (D.12204, 0); if (D.12205 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 669, "_wapi_has_shut_down == FALSE"); : D.12211 = type + 4294967295; D.12212 = D.12211 > 1; D.12213 = type != 7; D.12214 = D.12212 & D.12213; if (D.12214 != 0) goto ; else goto ; : if (type != 10) goto ; else goto ; : iftmp.59 = 1; goto ; : iftmp.59 = 0; : D.12217 = iftmp.59 != 0; D.12218 = (long int) D.12217; D.12219 = __builtin_expect (D.12218, 0); if (D.12219 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 674, "_WAPI_FD_HANDLE(type)"); : D.12226 = type == 9; D.12227 = type == 11; D.12228 = D.12226 | D.12227; if (D.12228 != 0) goto ; else goto ; : D.12230 = type + 4294967284; if (D.12230 <= 1) goto ; else goto ; : iftmp.60 = 1; goto ; : iftmp.60 = 0; : D.12231 = iftmp.60 != 0; D.12232 = (long int) D.12231; D.12233 = __builtin_expect (D.12232, 0); if (D.12233 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 675, "!_WAPI_SHARED_HANDLE(type)"); : fd.61 = (unsigned int) fd; _wapi_fd_reserve.62 = _wapi_fd_reserve; if (fd.61 >= _wapi_fd_reserve.62) goto ; else goto ; : D.12240 = -1B; return D.12240; : D.12241 = fd / 256; D.12242 = _wapi_private_handles[D.12241]; if (D.12242 == 0B) goto ; else goto ; : D.12241 = fd / 256; init_handles_slot (D.12241); : D.12241 = fd / 256; D.12242 = _wapi_private_handles[D.12241]; D.12245 = fd % 256; D.12246 = (long unsigned int) D.12245; D.12247 = D.12246 * 200; handle = D.12242 + D.12247; D.12248 = handle->type; if (D.12248 != 0) goto ; else goto ; : : thr_ret = _wapi_shm_sem_lock (2); D.12251 = thr_ret != 0; D.12252 = (long int) D.12251; D.12253 = __builtin_expect (D.12252, 0); if (D.12253 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 702, "thr_ret == 0"); : _wapi_handle_init (handle, type, handle_specific); thr_ret = _wapi_shm_sem_unlock (2); D.12256 = (long unsigned int) fd; D.12240 = (void *) D.12256; return D.12240; } init_handles_slot (int idx) { long int D.12258; long int D.12259; _Bool D.12262; long int D.12263; long int D.12264; struct _WapiHandleUnshared * D.12267; void * D.12270; _Bool D.12271; long int D.12272; long int D.12273; int thr_ret; { struct __pthread_unwind_buf_t __cancel_buf; void (*) (void *) __cancel_routine; void * __cancel_arg; int __not_first_call; try { __cancel_routine = mono_mutex_unlock_in_cleanup; __cancel_arg = &scan_mutex; __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0); D.12258 = (long int) __not_first_call; D.12259 = __builtin_expect (D.12258, 0); if (D.12259 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); : __pthread_register_cancel (&__cancel_buf); thr_ret = pthread_mutex_lock (&scan_mutex); D.12262 = thr_ret != 0; D.12263 = (long int) D.12262; D.12264 = __builtin_expect (D.12263, 0); if (D.12264 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 650, "thr_ret == 0"); : D.12267 = _wapi_private_handles[idx]; if (D.12267 == 0B) goto ; else goto ; : D.12270 = monoeg_malloc0 (51200); _wapi_private_handles[idx] = D.12270; D.12267 = _wapi_private_handles[idx]; D.12271 = D.12267 == 0B; D.12272 = (long int) D.12271; D.12273 = __builtin_expect (D.12272, 0); if (D.12273 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 655, "_wapi_private_handles [idx]"); : : thr_ret = pthread_mutex_unlock (&scan_mutex); D.12262 = thr_ret != 0; D.12263 = (long int) D.12262; D.12264 = __builtin_expect (D.12263, 0); if (D.12264 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 659, "thr_ret == 0"); : __pthread_unregister_cancel (&__cancel_buf); if (0 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); : } finally { __cancel_buf = {CLOBBER}; } } } _wapi_lookup_handle (void * handle, WapiHandleType type, void * * handle_specific) { long int handle.63; gboolean D.12286; unsigned int D.12287; struct _WapiHandleUnshared * D.12288; int D.12291; long unsigned int D.12292; long unsigned int D.12293; long unsigned int D.12294; D.12295; _Bool D.12303; _Bool D.12304; _Bool D.12305; unsigned int D.12307; struct _WapiHandleSharedLayout * _wapi_shared_layout.64; unsigned int D.12309; D.12310; union { struct _WapiHandle_process process; struct _WapiHandle_namedmutex namedmutex; struct _WapiHandle_namedsem namedsem; struct _WapiHandle_namedevent namedevent; } * D.12313; union { struct _WapiHandle_event event; struct _WapiHandle_file file; struct _WapiHandle_find find; struct _WapiHandle_mutex mutex; struct _WapiHandle_sem sem; struct _WapiHandle_socket sock; struct _WapiHandle_thread thread; struct _WapiHandle_shared_ref shared; } * D.12314; struct _WapiHandleUnshared * handle_data; guint32 handle_idx; handle.63 = (long int) handle; handle_idx = (guint32) handle.63; if (handle_idx > 4194303) goto ; else goto ; : D.12286 = 0; return D.12286; : D.12287 = handle_idx / 256; D.12288 = _wapi_private_handles[D.12287]; if (D.12288 == 0B) goto ; else goto ; : D.12287 = handle_idx / 256; D.12291 = (int) D.12287; init_handles_slot (D.12291); : D.12287 = handle_idx / 256; D.12288 = _wapi_private_handles[D.12287]; D.12292 = (long unsigned int) handle_idx; D.12293 = D.12292 & 255; D.12294 = D.12293 * 200; handle_data = D.12288 + D.12294; D.12295 = handle_data->type; if (D.12295 != type) goto ; else goto ; : D.12286 = 0; return D.12286; : if (handle_specific == 0B) goto ; else goto ; : D.12286 = 0; return D.12286; : D.12303 = type == 9; D.12304 = type == 11; D.12305 = D.12303 | D.12304; if (D.12305 != 0) goto ; else goto ; : D.12307 = type + 4294967284; if (D.12307 <= 1) goto ; else goto ; : { struct _WapiHandle_shared_ref * ref; struct _WapiHandleShared * shared_handle_data; ref = &handle_data->u.shared; _wapi_shared_layout.64 = _wapi_shared_layout; D.12309 = ref->offset; shared_handle_data = &_wapi_shared_layout.64->handles[D.12309]; D.12310 = shared_handle_data->type; if (D.12310 != type) goto ; else goto ; : D.12286 = 0; return D.12286; : D.12313 = &shared_handle_data->u; *handle_specific = D.12313; } goto ; : D.12314 = &handle_data->u; *handle_specific = D.12314; : D.12286 = 1; return D.12286; } _wapi_handle_foreach (WapiHandleType type, gboolean (*) (void *, void *) on_each, void * user_data) { long int D.12316; long int D.12317; _Bool D.12320; long int D.12321; long int D.12322; struct _WapiHandleUnshared * D.12325; long unsigned int D.12328; long unsigned int D.12329; D.12330; unsigned int D.12333; unsigned int D.12334; long unsigned int D.12335; int D.12336; unsigned int _wapi_private_handle_slot_count.65; struct _WapiHandleUnshared * handle_data; void * ret; guint32 i; guint32 k; int thr_ret; handle_data = 0B; ret = 0B; { struct __pthread_unwind_buf_t __cancel_buf; void (*) (void *) __cancel_routine; void * __cancel_arg; int __not_first_call; try { __cancel_routine = mono_mutex_unlock_in_cleanup; __cancel_arg = &scan_mutex; __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0); D.12316 = (long int) __not_first_call; D.12317 = __builtin_expect (D.12316, 0); if (D.12317 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); : __pthread_register_cancel (&__cancel_buf); thr_ret = pthread_mutex_lock (&scan_mutex); D.12320 = thr_ret != 0; D.12321 = (long int) D.12320; D.12322 = __builtin_expect (D.12321, 0); if (D.12322 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 769, "thr_ret == 0"); : i = 0; goto ; : D.12325 = _wapi_private_handles[i]; if (D.12325 != 0B) goto ; else goto ; : k = 0; goto ; : D.12325 = _wapi_private_handles[i]; D.12328 = (long unsigned int) k; D.12329 = D.12328 * 200; handle_data = D.12325 + D.12329; D.12330 = handle_data->type; if (D.12330 == type) goto ; else goto ; : D.12333 = i * 256; D.12334 = D.12333 + k; D.12335 = (long unsigned int) D.12334; ret = (void *) D.12335; D.12336 = on_each (ret, user_data); if (D.12336 == 1) goto ; else goto ; : : k = k + 1; : if (k <= 255) goto ; else goto ; : : i = i + 1; : _wapi_private_handle_slot_count.65 = _wapi_private_handle_slot_count; if (i < _wapi_private_handle_slot_count.65) goto ; else goto ; : thr_ret = pthread_mutex_unlock (&scan_mutex); D.12320 = thr_ret != 0; D.12321 = (long int) D.12320; D.12322 = __builtin_expect (D.12321, 0); if (D.12322 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 786, "thr_ret == 0"); : __pthread_unregister_cancel (&__cancel_buf); if (0 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); : } finally { __cancel_buf = {CLOBBER}; } } } _wapi_search_handle (WapiHandleType type, gboolean (*) (void *, void *) check, void * user_data, void * * handle_specific, gboolean search_shared) { long int D.12346; long int D.12347; _Bool D.12350; long int D.12351; long int D.12352; struct _WapiHandleUnshared * D.12355; long unsigned int D.12358; long unsigned int D.12359; D.12360; unsigned int D.12363; unsigned int D.12364; long unsigned int D.12365; int D.12366; _Bool D.12371; _Bool D.12372; _Bool D.12373; unsigned int D.12375; struct _WapiHandleSharedLayout * _wapi_shared_layout.66; unsigned int _wapi_private_handle_slot_count.67; _Bool D.12384; _Bool D.12385; _Bool D.12386; D.12390; int D.12395; long int D.12402; int now.68; guint32 * D.12404; long int ret.69; unsigned int D.12406; unsigned int D.12407; struct _WapiHandleUnshared * D.12408; long unsigned int D.12409; long unsigned int D.12410; long unsigned int D.12411; _Bool D.12420; long int D.12421; long int D.12422; union { struct _WapiHandle_process process; struct _WapiHandle_namedmutex namedmutex; struct _WapiHandle_namedsem namedsem; struct _WapiHandle_namedevent namedevent; } * D.12425; union { struct _WapiHandle_event event; struct _WapiHandle_file file; struct _WapiHandle_find find; struct _WapiHandle_mutex mutex; struct _WapiHandle_sem sem; struct _WapiHandle_socket sock; struct _WapiHandle_thread thread; struct _WapiHandle_shared_ref shared; } * D.12426; void * D.12427; struct _WapiHandleUnshared * handle_data; struct _WapiHandleShared * shared; void * ret; guint32 i; guint32 k; gboolean found; int thr_ret; void done = <<< error >>>; handle_data = 0B; shared = 0B; ret = 0B; found = 0; { struct __pthread_unwind_buf_t __cancel_buf; void (*) (void *) __cancel_routine; void * __cancel_arg; int __not_first_call; try { __cancel_routine = mono_mutex_unlock_in_cleanup; __cancel_arg = &scan_mutex; __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0); D.12346 = (long int) __not_first_call; D.12347 = __builtin_expect (D.12346, 0); if (D.12347 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); : __pthread_register_cancel (&__cancel_buf); thr_ret = pthread_mutex_lock (&scan_mutex); D.12350 = thr_ret != 0; D.12351 = (long int) D.12350; D.12352 = __builtin_expect (D.12351, 0); if (D.12352 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 814, "thr_ret == 0"); : i = 0; goto ; : D.12355 = _wapi_private_handles[i]; if (D.12355 != 0B) goto ; else goto ; : k = 0; goto ; : D.12355 = _wapi_private_handles[i]; D.12358 = (long unsigned int) k; D.12359 = D.12358 * 200; handle_data = D.12355 + D.12359; D.12360 = handle_data->type; if (D.12360 == type) goto ; else goto ; : D.12363 = i * 256; D.12364 = D.12363 + k; D.12365 = (long unsigned int) D.12364; ret = (void *) D.12365; D.12366 = check (ret, user_data); if (D.12366 == 1) goto ; else goto ; : _wapi_handle_ref (ret); found = 1; D.12371 = type == 9; D.12372 = type == 11; D.12373 = D.12371 | D.12372; if (D.12373 != 0) goto ; else goto ; : D.12375 = type + 4294967284; if (D.12375 <= 1) goto ; else goto ; : _wapi_shared_layout.66 = _wapi_shared_layout; shared = &_wapi_shared_layout.66->handles[i]; : goto ; : : k = k + 1; : if (k <= 255) goto ; else goto ; : : i = i + 1; : if (found == 0) goto ; else goto ; : _wapi_private_handle_slot_count.67 = _wapi_private_handle_slot_count; if (i < _wapi_private_handle_slot_count.67) goto ; else goto ; : thr_ret = pthread_mutex_unlock (&scan_mutex); D.12350 = thr_ret != 0; D.12351 = (long int) D.12350; D.12352 = __builtin_expect (D.12351, 0); if (D.12352 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 839, "thr_ret == 0"); : __pthread_unregister_cancel (&__cancel_buf); if (0 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); : } finally { __cancel_buf = {CLOBBER}; } } D.12384 = found == 0; D.12385 = search_shared != 0; D.12386 = D.12384 & D.12385; if (D.12386 != 0) goto ; else goto ; : D.12371 = type == 9; D.12372 = type == 11; D.12373 = D.12371 | D.12372; if (D.12373 != 0) goto ; else goto ; : D.12375 = type + 4294967284; if (D.12375 <= 1) goto ; else goto ; : i = 0; goto ; : _wapi_shared_layout.66 = _wapi_shared_layout; shared = &_wapi_shared_layout.66->handles[i]; D.12390 = shared->type; if (D.12390 == type) goto ; else goto ; : ret = _wapi_handle_new_from_offset (type, i, 0); if (ret == -1B) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.12395 = check (ret, user_data); if (D.12395 == 1) goto ; else goto ; : thr_ret = _wapi_handle_lock_shared_handles (); D.12350 = thr_ret != 0; D.12351 = (long int) D.12350; D.12352 = __builtin_expect (D.12351, 0); if (D.12352 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 881, "thr_ret == 0"); : D.12390 = shared->type; if (D.12390 == type) goto ; else goto ; : { guint32 now; D.12402 = time (0B); now = (guint32) D.12402; now.68 = (int) now; D.12404 = &shared->timestamp; InterlockedExchange (D.12404, now.68); found = 1; ret.69 = (long int) ret; D.12406 = (unsigned int) ret.69; D.12407 = D.12406 / 256; D.12408 = _wapi_private_handles[D.12407]; ret.69 = (long int) ret; D.12406 = (unsigned int) ret.69; D.12409 = (long unsigned int) D.12406; D.12410 = D.12409 & 255; D.12411 = D.12410 * 200; handle_data = D.12408 + D.12411; _wapi_handle_unlock_shared_handles (); goto ; } : _wapi_handle_unlock_shared_handles (); : _wapi_handle_unref (ret); : : i = i + 1; : if (i <= 255) goto ; else goto ; : : if (found == 0) goto ; else goto ; : ret = 0B; goto done; : if (handle_specific != 0B) goto ; else goto ; : D.12371 = type == 9; D.12372 = type == 11; D.12373 = D.12371 | D.12372; if (D.12373 != 0) goto ; else goto ; : D.12375 = type + 4294967284; if (D.12375 <= 1) goto ; else goto ; : D.12390 = shared->type; D.12420 = D.12390 != type; D.12421 = (long int) D.12420; D.12422 = __builtin_expect (D.12421, 0); if (D.12422 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 917, "shared->type == type"); : D.12425 = &shared->u; *handle_specific = D.12425; goto ; : D.12426 = &handle_data->u; *handle_specific = D.12426; : : done: D.12427 = ret; return D.12427; } _wapi_search_handle_namespace (WapiHandleType type, gchar * utf8_name) { int iftmp.70; _Bool D.12438; _Bool D.12439; _Bool D.12440; unsigned int D.12442; _Bool D.12444; long int D.12445; long int D.12446; _Bool D.12449; long int D.12450; long int D.12451; struct _WapiHandleSharedLayout * _wapi_shared_layout.71; D.12455; unsigned int D.12456; int D.11396; gchar[261] * D.12459; gint32 D.12464; struct _WapiHandleShared * shared_handle_data; guint32 i; gint32 ret; int thr_ret; void done = <<< error >>>; ret = 0; D.12438 = type != 9; D.12439 = type != 11; D.12440 = D.12438 & D.12439; if (D.12440 != 0) goto ; else goto ; : D.12442 = type + 4294967284; if (D.12442 > 1) goto ; else goto ; : iftmp.70 = 1; goto ; : iftmp.70 = 0; : D.12444 = iftmp.70 != 0; D.12445 = (long int) D.12444; D.12446 = __builtin_expect (D.12445, 0); if (D.12446 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 940, "_WAPI_SHARED_HANDLE(type)"); : _wapi_handle_collect (); thr_ret = _wapi_handle_lock_shared_handles (); D.12449 = thr_ret != 0; D.12450 = (long int) D.12449; D.12451 = __builtin_expect (D.12450, 0); if (D.12451 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 951, "thr_ret == 0"); : i = 1; goto ; : { struct WapiSharedNamespace * sharedns; _wapi_shared_layout.71 = _wapi_shared_layout; shared_handle_data = &_wapi_shared_layout.71->handles[i]; D.12455 = shared_handle_data->type; D.12456 = D.12455 + 4294967285; if (D.12456 > 2) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : sharedns = &shared_handle_data->u; { size_t __s1_len; size_t __s2_len; D.12459 = &sharedns->name; D.11396 = __builtin_strcmp (D.12459, utf8_name); } if (D.11396 == 0) goto ; else goto ; : D.12455 = shared_handle_data->type; if (D.12455 != type) goto ; else goto ; : ret = -1; goto done; : ret = (gint32) i; goto done; : } : i = i + 1; : if (i <= 255) goto ; else goto ; : done: _wapi_handle_unlock_shared_handles (); D.12464 = ret; return D.12464; } _wapi_handle_ref (void * handle) { long int handle.72; D.12469; unsigned int D.12472; struct _WapiHandleUnshared * D.12473; long unsigned int D.12474; long unsigned int D.12475; long unsigned int D.12476; guint * D.12477; D.12480; _Bool D.12481; _Bool D.12482; _Bool D.12483; D.12485; struct _WapiHandleSharedLayout * _wapi_shared_layout.73; unsigned int D.12488; long int D.12489; int now.74; guint32 * D.12491; guint32 idx; struct _WapiHandleUnshared * handle_data; static const char __func__[17] = "_wapi_handle_ref"; handle.72 = (long int) handle; idx = (guint32) handle.72; if (idx > 4194303) goto ; else goto ; : return; : D.12469 = _wapi_handle_type (handle); if (D.12469 == 0) goto ; else goto ; : monoeg_g_log (0B, 16, "%s: Attempting to ref unused handle %p", &__func__, handle); return; : D.12472 = idx / 256; D.12473 = _wapi_private_handles[D.12472]; D.12474 = (long unsigned int) idx; D.12475 = D.12474 & 255; D.12476 = D.12475 * 200; handle_data = D.12473 + D.12476; D.12477 = &handle_data->ref; InterlockedIncrement (D.12477); D.12480 = handle_data->type; D.12481 = D.12480 == 9; D.12482 = D.12480 == 11; D.12483 = D.12481 | D.12482; if (D.12483 != 0) goto ; else goto ; : D.12485 = handle_data->type; if (D.12485 == 12) goto ; else goto ; : D.12485 = handle_data->type; if (D.12485 == 13) goto ; else goto ; : { struct _WapiHandleShared * shared_data; guint32 now; _wapi_shared_layout.73 = _wapi_shared_layout; D.12488 = handle_data->u.shared.offset; shared_data = &_wapi_shared_layout.73->handles[D.12488]; D.12489 = time (0B); now = (guint32) D.12489; now.74 = (int) now; D.12491 = &shared_data->timestamp; InterlockedExchange (D.12491, now.74); } : } _wapi_handle_unref (void * handle) { _wapi_handle_unref_full (handle, 0); } _wapi_handle_register_capabilities (WapiHandleType type, WapiHandleCapability caps) { handle_caps[type] = caps; } _wapi_handle_test_capabilities (void * handle, WapiHandleCapability caps) { long int handle.75; gboolean D.12496; unsigned int D.12497; struct _WapiHandleUnshared * D.12498; long unsigned int D.12499; long unsigned int D.12500; long unsigned int D.12501; struct _WapiHandleUnshared * D.12502; D.12503; unsigned int D.12504; _Bool D.12505; guint32 idx; WapiHandleType type; handle.75 = (long int) handle; idx = (guint32) handle.75; if (idx > 4194303) goto ; else goto ; : D.12496 = 0; return D.12496; : D.12497 = idx / 256; D.12498 = _wapi_private_handles[D.12497]; D.12499 = (long unsigned int) idx; D.12500 = D.12499 & 255; D.12501 = D.12500 * 200; D.12502 = D.12498 + D.12501; type = D.12502->type; D.12503 = handle_caps[type]; D.12504 = D.12503 & caps; D.12505 = D.12504 != 0; D.12496 = (gboolean) D.12505; return D.12496; } _wapi_handle_ops_close (void * handle, void * data) { long int handle.76; unsigned int D.12510; struct _WapiHandleUnshared * D.12511; long unsigned int D.12512; long unsigned int D.12513; long unsigned int D.12514; struct _WapiHandleUnshared * D.12515; struct _WapiHandleOps * D.12516; void (*) (void *, void *) D.12519; guint32 idx; WapiHandleType type; handle.76 = (long int) handle; idx = (guint32) handle.76; if (idx > 4194303) goto ; else goto ; : return; : D.12510 = idx / 256; D.12511 = _wapi_private_handles[D.12510]; D.12512 = (long unsigned int) idx; D.12513 = D.12512 & 255; D.12514 = D.12513 * 200; D.12515 = D.12511 + D.12514; type = D.12515->type; D.12516 = handle_ops[type]; if (D.12516 != 0B) goto ; else goto ; : D.12516 = handle_ops[type]; D.12519 = D.12516->close; if (D.12519 != 0B) goto ; else goto ; : D.12516 = handle_ops[type]; D.12519 = D.12516->close; D.12519 (handle, data); : : } _wapi_handle_ops_signal (void * handle) { long int handle.77; unsigned int D.12526; struct _WapiHandleUnshared * D.12527; long unsigned int D.12528; long unsigned int D.12529; long unsigned int D.12530; struct _WapiHandleUnshared * D.12531; struct _WapiHandleOps * D.12532; void (*) (void *) D.12535; guint32 idx; WapiHandleType type; handle.77 = (long int) handle; idx = (guint32) handle.77; if (idx > 4194303) goto ; else goto ; : return; : D.12526 = idx / 256; D.12527 = _wapi_private_handles[D.12526]; D.12528 = (long unsigned int) idx; D.12529 = D.12528 & 255; D.12530 = D.12529 * 200; D.12531 = D.12527 + D.12530; type = D.12531->type; D.12532 = handle_ops[type]; if (D.12532 != 0B) goto ; else goto ; : D.12532 = handle_ops[type]; D.12535 = D.12532->signal; if (D.12535 != 0B) goto ; else goto ; : D.12532 = handle_ops[type]; D.12535 = D.12532->signal; D.12535 (handle); : : } _wapi_handle_ops_own (void * handle) { long int handle.78; gboolean D.12542; unsigned int D.12543; struct _WapiHandleUnshared * D.12544; long unsigned int D.12545; long unsigned int D.12546; long unsigned int D.12547; struct _WapiHandleUnshared * D.12548; struct _WapiHandleOps * D.12550; gboolean (*) (void *) D.12552; guint32 idx; WapiHandleType type; handle.78 = (long int) handle; idx = (guint32) handle.78; if (idx > 4194303) goto ; else goto ; : D.12542 = 0; return D.12542; : D.12543 = idx / 256; D.12544 = _wapi_private_handles[D.12543]; D.12545 = (long unsigned int) idx; D.12546 = D.12545 & 255; D.12547 = D.12546 * 200; D.12548 = D.12544 + D.12547; type = D.12548->type; D.12550 = handle_ops[type]; if (D.12550 != 0B) goto ; else goto ; : D.12550 = handle_ops[type]; D.12552 = D.12550->own_handle; if (D.12552 != 0B) goto ; else goto ; : D.12550 = handle_ops[type]; D.12552 = D.12550->own_handle; D.12542 = D.12552 (handle); return D.12542; : D.12542 = 0; return D.12542; } _wapi_handle_ops_isowned (void * handle) { long int handle.79; gboolean D.12558; unsigned int D.12559; struct _WapiHandleUnshared * D.12560; long unsigned int D.12561; long unsigned int D.12562; long unsigned int D.12563; struct _WapiHandleUnshared * D.12564; struct _WapiHandleOps * D.12566; gboolean (*) (void *) D.12568; guint32 idx; WapiHandleType type; handle.79 = (long int) handle; idx = (guint32) handle.79; if (idx > 4194303) goto ; else goto ; : D.12558 = 0; return D.12558; : D.12559 = idx / 256; D.12560 = _wapi_private_handles[D.12559]; D.12561 = (long unsigned int) idx; D.12562 = D.12561 & 255; D.12563 = D.12562 * 200; D.12564 = D.12560 + D.12563; type = D.12564->type; D.12566 = handle_ops[type]; if (D.12566 != 0B) goto ; else goto ; : D.12566 = handle_ops[type]; D.12568 = D.12566->is_owned; if (D.12568 != 0B) goto ; else goto ; : D.12566 = handle_ops[type]; D.12568 = D.12566->is_owned; D.12558 = D.12568 (handle); return D.12558; : D.12558 = 0; return D.12558; } _wapi_handle_ops_special_wait (void * handle, guint32 timeout, gboolean alertable) { long int handle.80; guint32 D.12574; unsigned int D.12575; struct _WapiHandleUnshared * D.12576; long unsigned int D.12577; long unsigned int D.12578; long unsigned int D.12579; struct _WapiHandleUnshared * D.12580; struct _WapiHandleOps * D.12582; guint32 (*) (void *, guint32, gboolean) D.12584; guint32 idx; WapiHandleType type; handle.80 = (long int) handle; idx = (guint32) handle.80; if (idx > 4194303) goto ; else goto ; : D.12574 = 4294967295; return D.12574; : D.12575 = idx / 256; D.12576 = _wapi_private_handles[D.12575]; D.12577 = (long unsigned int) idx; D.12578 = D.12577 & 255; D.12579 = D.12578 * 200; D.12580 = D.12576 + D.12579; type = D.12580->type; D.12582 = handle_ops[type]; if (D.12582 != 0B) goto ; else goto ; : D.12582 = handle_ops[type]; D.12584 = D.12582->special_wait; if (D.12584 != 0B) goto ; else goto ; : D.12582 = handle_ops[type]; D.12584 = D.12582->special_wait; D.12574 = D.12584 (handle, timeout, alertable); return D.12574; : D.12574 = 4294967295; return D.12574; } _wapi_handle_ops_prewait (void * handle) { long int handle.81; unsigned int D.12590; struct _WapiHandleUnshared * D.12591; long unsigned int D.12592; long unsigned int D.12593; long unsigned int D.12594; struct _WapiHandleUnshared * D.12595; struct _WapiHandleOps * D.12596; void (*) (void *) D.12599; guint32 idx; WapiHandleType type; handle.81 = (long int) handle; idx = (guint32) handle.81; if (idx > 4194303) goto ; else goto ; : return; : D.12590 = idx / 256; D.12591 = _wapi_private_handles[D.12590]; D.12592 = (long unsigned int) idx; D.12593 = D.12592 & 255; D.12594 = D.12593 * 200; D.12595 = D.12591 + D.12594; type = D.12595->type; D.12596 = handle_ops[type]; if (D.12596 != 0B) goto ; else goto ; : D.12596 = handle_ops[type]; D.12599 = D.12596->prewait; if (D.12599 != 0B) goto ; else goto ; : D.12596 = handle_ops[type]; D.12599 = D.12596->prewait; D.12599 (handle); : : } CloseHandle (void * handle) { struct _WapiHandleUnshared * D.12605; D.12606; gboolean D.12609; if (handle == 0B) goto ; else goto ; : D.12605 = _wapi_private_handles[0]; D.12606 = D.12605->type; if (D.12606 != 2) goto ; else goto ; : SetLastError (87); D.12609 = 0; return D.12609; : : if (handle == -1B) goto ; else goto ; : SetLastError (87); D.12609 = 0; return D.12609; : _wapi_handle_unref (handle); D.12609 = 1; return D.12609; } DuplicateHandle (void * srcprocess, void * src, void * targetprocess, void * * target, guint32 access, gboolean inherit, guint32 options) { _Bool D.12613; _Bool D.12614; _Bool D.12615; gboolean D.12618; void * D.12621; void * D.12625; D.12613 = srcprocess != 4294967295B; D.12614 = targetprocess != 4294967295B; D.12615 = D.12613 | D.12614; if (D.12615 != 0) goto ; else goto ; : SetLastError (6); D.12618 = 0; return D.12618; : if (src == 4294967295B) goto ; else goto ; : D.12621 = _wapi_process_duplicate (); *target = D.12621; goto ; : if (src == 4294967294B) goto ; else goto ; : D.12625 = _wapi_thread_duplicate (); *target = D.12625; goto ; : _wapi_handle_ref (src); *target = src; : : D.12618 = 1; return D.12618; } _wapi_handle_count_signalled_handles (guint32 numhandles, void * * handles, gboolean waitall, guint32 * retcount, guint32 * lowest) { _Bool D.12628; long int D.12629; long int D.12630; long unsigned int D.12633; long unsigned int D.12634; void * * D.12635; long int handle.82; unsigned int D.12637; struct _WapiHandleUnshared * D.12638; long unsigned int D.12639; long unsigned int D.12640; long unsigned int D.12641; struct _WapiHandleUnshared * D.12642; unsigned int i.83; unsigned int D.12652; long int handle.84; unsigned int D.12654; struct _WapiHandleUnshared * D.12655; long unsigned int D.12656; long unsigned int D.12657; long unsigned int D.12658; struct _WapiHandleUnshared * D.12659; int D.12665; int D.12667; _Bool D.12668; _Bool D.12669; _Bool D.12670; unsigned int D.12672; struct _WapiHandleSharedLayout * _wapi_shared_layout.85; unsigned int D.12674; unsigned int D.12675; struct _WapiHandleUnshared * D.12676; long unsigned int D.12677; long unsigned int D.12678; long unsigned int D.12679; struct _WapiHandleUnshared * D.12680; unsigned int D.12681; int D.12682; _Bool D.12683; _Bool D.12684; _Bool D.12685; int D.12688; unsigned int D.12689; _Bool D.12695; _Bool D.12696; _Bool D.12697; _Bool D.12699; _Bool D.12700; _Bool D.12701; gboolean D.12702; guint32 count; guint32 i; guint32 iter; gboolean ret; int thr_ret; WapiHandleType type; void again = <<< error >>>; static const char __func__[37] = "_wapi_handle_count_signalled_handles"; iter = 0; again: thr_ret = _wapi_handle_lock_shared_handles (); D.12628 = thr_ret != 0; D.12629 = (long int) D.12628; D.12630 = __builtin_expect (D.12629, 0); if (D.12630 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1375, "thr_ret == 0"); : i = 0; goto ; : { void * handle; guint32 idx; D.12633 = (long unsigned int) i; D.12634 = D.12633 * 8; D.12635 = handles + D.12634; handle = *D.12635; handle.82 = (long int) handle; idx = (guint32) handle.82; D.12637 = idx / 256; D.12638 = _wapi_private_handles[D.12637]; D.12639 = (long unsigned int) idx; D.12640 = D.12639 & 255; D.12641 = D.12640 * 200; D.12642 = D.12638 + D.12641; type = D.12642->type; thr_ret = _wapi_handle_trylock_handle (handle); if (thr_ret != 0) goto ; else goto ; : thr_ret = _wapi_handle_unlock_shared_handles (); D.12628 = thr_ret != 0; D.12629 = (long int) D.12628; D.12630 = __builtin_expect (D.12629, 0); if (D.12630 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1394, "thr_ret == 0"); : goto ; : D.12633 = (long unsigned int) i; D.12634 = D.12633 * 8; D.12635 = handles + D.12634; handle = *D.12635; handle.82 = (long int) handle; idx = (guint32) handle.82; thr_ret = _wapi_handle_unlock_handle (handle); D.12628 = thr_ret != 0; D.12629 = (long int) D.12628; D.12630 = __builtin_expect (D.12629, 0); if (D.12630 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1401, "thr_ret == 0"); : : i.83 = i; i = i.83 + 4294967295; if (i.83 != 0) goto ; else goto ; : iter = iter + 1; if (iter == 100) goto ; else goto ; : monoeg_g_log (0B, 16, "%s: iteration overflow!", &__func__); iter = 1; : D.12652 = iter * 10; _wapi_handle_spin (D.12652); goto again; : } i = i + 1; : if (i < numhandles) goto ; else goto ; : count = 0; *lowest = numhandles; i = 0; goto ; : { void * handle; guint32 idx; D.12633 = (long unsigned int) i; D.12634 = D.12633 * 8; D.12635 = handles + D.12634; handle = *D.12635; handle.84 = (long int) handle; idx = (guint32) handle.84; D.12654 = idx / 256; D.12655 = _wapi_private_handles[D.12654]; D.12656 = (long unsigned int) idx; D.12657 = D.12656 & 255; D.12658 = D.12657 * 200; D.12659 = D.12655 + D.12658; type = D.12659->type; D.12665 = _wapi_handle_test_capabilities (handle, 4); if (D.12665 == 1) goto ; else goto ; : D.12667 = _wapi_handle_ops_isowned (handle); if (D.12667 == 1) goto ; else goto ; : D.12668 = type == 9; D.12669 = type == 11; D.12670 = D.12668 | D.12669; if (D.12670 != 0) goto ; else goto ; : D.12672 = type + 4294967284; if (D.12672 <= 1) goto ; else goto ; : _wapi_shared_layout.85 = _wapi_shared_layout; handle.84 = (long int) handle; D.12674 = (unsigned int) handle.84; D.12675 = D.12674 / 256; D.12676 = _wapi_private_handles[D.12675]; handle.84 = (long int) handle; D.12674 = (unsigned int) handle.84; D.12677 = (long unsigned int) D.12674; D.12678 = D.12677 & 255; D.12679 = D.12678 * 200; D.12680 = D.12676 + D.12679; D.12681 = D.12680->u.shared.offset; D.12682 = _wapi_shared_layout.85->handles[D.12681].signalled; if (D.12682 == 1) goto ; else goto ; : D.12683 = type != 9; D.12684 = type != 11; D.12685 = D.12683 & D.12684; if (D.12685 != 0) goto ; else goto ; : D.12672 = type + 4294967284; if (D.12672 > 1) goto ; else goto ; : D.12654 = idx / 256; D.12655 = _wapi_private_handles[D.12654]; D.12656 = (long unsigned int) idx; D.12657 = D.12656 & 255; D.12658 = D.12657 * 200; D.12659 = D.12655 + D.12658; D.12688 = D.12659->signalled; if (D.12688 == 1) goto ; else goto ; : count = count + 1; D.12689 = *lowest; if (D.12689 > i) goto ; else goto ; : *lowest = i; : : } i = i + 1; : if (i < numhandles) goto ; else goto ; : D.12695 = waitall == 1; D.12696 = count == numhandles; D.12697 = D.12695 & D.12696; if (D.12697 != 0) goto ; else goto ; : D.12699 = waitall == 0; D.12700 = count != 0; D.12701 = D.12699 & D.12700; if (D.12701 != 0) goto ; else goto ; : ret = 1; goto ; : ret = 0; : *retcount = count; D.12702 = ret; return D.12702; } _wapi_handle_trylock_handle (void * handle) { long int handle.86; int D.12707; D.12710; D.12712; D.12714; D.12716; unsigned int D.12717; struct _WapiHandleUnshared * D.12718; long unsigned int D.12719; long unsigned int D.12720; long unsigned int D.12721; struct _WapiHandleUnshared * D.12722; union mono_mutex_t * D.12723; guint32 idx; int ret; handle.86 = (long int) handle; idx = (guint32) handle.86; if (idx > 4194303) goto ; else goto ; : D.12707 = 0; return D.12707; : _wapi_handle_ref (handle); D.12710 = _wapi_handle_type (handle); if (D.12710 == 9) goto ; else goto ; : D.12712 = _wapi_handle_type (handle); if (D.12712 == 11) goto ; else goto ; : D.12714 = _wapi_handle_type (handle); if (D.12714 == 12) goto ; else goto ; : D.12716 = _wapi_handle_type (handle); if (D.12716 == 13) goto ; else goto ; : D.12707 = 0; return D.12707; : D.12717 = idx / 256; D.12718 = _wapi_private_handles[D.12717]; D.12719 = (long unsigned int) idx; D.12720 = D.12719 & 255; D.12721 = D.12720 * 200; D.12722 = D.12718 + D.12721; D.12723 = &D.12722->signal_mutex; ret = pthread_mutex_trylock (D.12723); if (ret != 0) goto ; else goto ; : _wapi_handle_unref (handle); : D.12707 = ret; return D.12707; } _wapi_handle_unlock_handle (void * handle) { long int handle.87; int D.12730; D.12733; D.12735; D.12737; D.12739; unsigned int D.12740; struct _WapiHandleUnshared * D.12741; long unsigned int D.12742; long unsigned int D.12743; long unsigned int D.12744; struct _WapiHandleUnshared * D.12745; union mono_mutex_t * D.12746; guint32 idx; int ret; handle.87 = (long int) handle; idx = (guint32) handle.87; if (idx > 4194303) goto ; else goto ; : D.12730 = 0; return D.12730; : D.12733 = _wapi_handle_type (handle); if (D.12733 == 9) goto ; else goto ; : D.12735 = _wapi_handle_type (handle); if (D.12735 == 11) goto ; else goto ; : D.12737 = _wapi_handle_type (handle); if (D.12737 == 12) goto ; else goto ; : D.12739 = _wapi_handle_type (handle); if (D.12739 == 13) goto ; else goto ; : _wapi_handle_unref (handle); D.12730 = 0; return D.12730; : D.12740 = idx / 256; D.12741 = _wapi_private_handles[D.12740]; D.12742 = (long unsigned int) idx; D.12743 = D.12742 & 255; D.12744 = D.12743 * 200; D.12745 = D.12741 + D.12744; D.12746 = &D.12745->signal_mutex; ret = pthread_mutex_unlock (D.12746); _wapi_handle_unref (handle); D.12730 = ret; return D.12730; } _wapi_handle_spin (guint32 ms) { _Bool D.12748; long int D.12749; long int D.12750; unsigned int D.12753; long int D.12754; struct timespec sleepytime; try { D.12748 = ms > 999; D.12749 = (long int) D.12748; D.12750 = __builtin_expect (D.12749, 0); if (D.12750 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/io-layer/handles-private.h", 326, "ms < 1000"); : sleepytime.tv_sec = 0; D.12753 = ms * 1000000; D.12754 = (long int) D.12753; sleepytime.tv_nsec = D.12754; nanosleep (&sleepytime, 0B); } finally { sleepytime = {CLOBBER}; } } _wapi_handle_unlock_handles (guint32 numhandles, void * * handles) { _Bool D.12755; long int D.12756; long int D.12757; long unsigned int D.12760; long unsigned int D.12761; void * * D.12762; guint32 i; int thr_ret; thr_ret = _wapi_handle_unlock_shared_handles (); D.12755 = thr_ret != 0; D.12756 = (long int) D.12755; D.12757 = __builtin_expect (D.12756, 0); if (D.12757 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1474, "thr_ret == 0"); : i = 0; goto ; : { void * handle; D.12760 = (long unsigned int) i; D.12761 = D.12760 * 8; D.12762 = handles + D.12761; handle = *D.12762; thr_ret = _wapi_handle_unlock_handle (handle); D.12755 = thr_ret != 0; D.12756 = (long int) D.12755; D.12757 = __builtin_expect (D.12756, 0); if (D.12757 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1482, "thr_ret == 0"); : } i = i + 1; : if (i < numhandles) goto ; else goto ; : } _wapi_handle_wait_signal (gboolean poll) { int D.12765; void * _wapi_global_signal_handle.88; _wapi_global_signal_handle.88 = _wapi_global_signal_handle; D.12765 = _wapi_handle_timedwait_signal_handle (_wapi_global_signal_handle.88, 0B, 1, poll); return D.12765; } _wapi_handle_timedwait_signal (struct timespec * timeout, gboolean poll) { int D.12768; void * _wapi_global_signal_handle.89; _wapi_global_signal_handle.89 = _wapi_global_signal_handle; D.12768 = _wapi_handle_timedwait_signal_handle (_wapi_global_signal_handle.89, timeout, 1, poll); return D.12768; } _wapi_handle_wait_signal_handle (void * handle, gboolean alertable) { int D.12771; D.12771 = _wapi_handle_timedwait_signal_handle (handle, 0B, alertable, 0); return D.12771; } _wapi_handle_timedwait_signal_handle (void * handle, struct timespec * timeout, gboolean alertable, gboolean poll) { D.12775; D.12777; D.12779; D.12781; struct _WapiHandleSharedLayout * _wapi_shared_layout.90; long int handle.91; unsigned int D.12784; unsigned int D.12785; struct _WapiHandleUnshared * D.12786; long unsigned int D.12787; long unsigned int D.12788; long unsigned int D.12789; struct _WapiHandleUnshared * D.12790; unsigned int D.12791; int D.12792; int D.12795; long int D.12800; long int D.12801; long int D.12804; long int D.12805; int D.12806; int D.12811; unsigned int D.12814; struct _WapiHandleUnshared * D.12815; long unsigned int D.12816; long unsigned int D.12817; long unsigned int D.12818; struct _WapiHandleUnshared * D.12819; D.12775 = _wapi_handle_type (handle); if (D.12775 == 9) goto ; else goto ; : D.12777 = _wapi_handle_type (handle); if (D.12777 == 11) goto ; else goto ; : D.12779 = _wapi_handle_type (handle); if (D.12779 == 12) goto ; else goto ; : D.12781 = _wapi_handle_type (handle); if (D.12781 == 13) goto ; else goto ; : _wapi_shared_layout.90 = _wapi_shared_layout; handle.91 = (long int) handle; D.12784 = (unsigned int) handle.91; D.12785 = D.12784 / 256; D.12786 = _wapi_private_handles[D.12785]; handle.91 = (long int) handle; D.12784 = (unsigned int) handle.91; D.12787 = (long unsigned int) D.12784; D.12788 = D.12787 & 255; D.12789 = D.12788 * 200; D.12790 = D.12786 + D.12789; D.12791 = D.12790->u.shared.offset; D.12792 = _wapi_shared_layout.90->handles[D.12791].signalled; if (D.12792 == 1) goto ; else goto ; : D.12795 = 0; return D.12795; : if (timeout != 0B) goto ; else goto ; : { struct timespec fake_timeout; try { _wapi_calc_timeout (&fake_timeout, 100); D.12800 = fake_timeout.tv_sec; D.12801 = timeout->tv_sec; if (D.12800 > D.12801) goto ; else goto ; : D.12800 = fake_timeout.tv_sec; D.12801 = timeout->tv_sec; if (D.12800 == D.12801) goto ; else goto ; : D.12804 = fake_timeout.tv_nsec; D.12805 = timeout->tv_nsec; if (D.12804 > D.12805) goto ; else goto ; : _wapi_handle_spin (100); _wapi_shared_layout.90 = _wapi_shared_layout; handle.91 = (long int) handle; D.12784 = (unsigned int) handle.91; D.12785 = D.12784 / 256; D.12786 = _wapi_private_handles[D.12785]; handle.91 = (long int) handle; D.12784 = (unsigned int) handle.91; D.12787 = (long unsigned int) D.12784; D.12788 = D.12787 & 255; D.12789 = D.12788 * 200; D.12790 = D.12786 + D.12789; D.12791 = D.12790->u.shared.offset; D.12806 = _wapi_shared_layout.90->handles[D.12791].signalled; if (D.12806 == 1) goto ; else goto ; : D.12795 = 0; return D.12795; : D.12795 = 110; return D.12795; : } finally { fake_timeout = {CLOBBER}; } } : _wapi_handle_spin (100); D.12795 = 0; return D.12795; : { guint32 idx; int res; union pthread_cond_t * cond; union mono_mutex_t * mutex; handle.91 = (long int) handle; idx = (guint32) handle.91; if (alertable != 0) goto ; else goto ; : D.12811 = wapi_thread_set_wait_handle (handle); if (D.12811 == 0) goto ; else goto ; : D.12795 = 0; return D.12795; : : D.12814 = idx / 256; D.12815 = _wapi_private_handles[D.12814]; D.12816 = (long unsigned int) idx; D.12817 = D.12816 & 255; D.12818 = D.12817 * 200; D.12819 = D.12815 + D.12818; cond = &D.12819->signal_cond; D.12814 = idx / 256; D.12815 = _wapi_private_handles[D.12814]; D.12816 = (long unsigned int) idx; D.12817 = D.12816 & 255; D.12818 = D.12817 * 200; D.12819 = D.12815 + D.12818; mutex = &D.12819->signal_mutex; if (poll != 0) goto ; else goto ; : res = timedwait_signal_poll_cond (cond, mutex, timeout, alertable); goto ; : if (timeout != 0B) goto ; else goto ; : res = pthread_cond_timedwait (cond, mutex, timeout); goto ; : res = pthread_cond_wait (cond, mutex); : : if (alertable != 0) goto ; else goto ; : wapi_thread_clear_wait_handle (handle); : D.12795 = res; return D.12795; } } timedwait_signal_poll_cond (union pthread_cond_t * cond, union mono_mutex_t * mutex, struct timespec * timeout, gboolean alertable) { long int D.12841; long int D.12842; long int D.12845; long int D.12846; int D.12849; struct timespec fake_timeout; int ret; try { if (alertable == 0) goto ; else goto ; : if (timeout != 0B) goto ; else goto ; : ret = pthread_cond_timedwait (cond, mutex, timeout); goto ; : ret = pthread_cond_wait (cond, mutex); : goto ; : _wapi_calc_timeout (&fake_timeout, 100); if (timeout != 0B) goto ; else goto ; : D.12841 = fake_timeout.tv_sec; D.12842 = timeout->tv_sec; if (D.12841 > D.12842) goto ; else goto ; : D.12841 = fake_timeout.tv_sec; D.12842 = timeout->tv_sec; if (D.12841 == D.12842) goto ; else goto ; : D.12845 = fake_timeout.tv_nsec; D.12846 = timeout->tv_nsec; if (D.12845 > D.12846) goto ; else goto ; : ret = pthread_cond_timedwait (cond, mutex, timeout); goto ; : ret = pthread_cond_timedwait (cond, mutex, &fake_timeout); if (ret == 110) goto ; else goto ; : ret = 0; : : : D.12849 = ret; return D.12849; } finally { fake_timeout = {CLOBBER}; } } _wapi_free_share_info (struct _WapiFileShare * share_info) { int D.12852; _Bool D.12857; long int D.12858; long int D.12859; struct GHashTable * file_share_hash.92; _Bool D.12865; long int D.12866; long int D.12867; D.12852 = _wapi_shm_enabled (); if (D.12852 == 0) goto ; else goto ; : { int ret; ret = pthread_mutex_lock (&file_share_hash_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.12857 = ret != 0; D.12858 = (long int) D.12857; D.12859 = __builtin_expect (D.12858, 0); if (D.12859 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1602, "ret == 0"); : } file_share_hash.92 = file_share_hash; monoeg_g_hash_table_remove (file_share_hash.92, share_info); { int ret; ret = pthread_mutex_unlock (&file_share_hash_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.12865 = ret != 0; D.12866 = (long int) D.12865; D.12867 = __builtin_expect (D.12866, 0); if (D.12867 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1604, "ret == 0"); : } goto ; : memset (share_info, 0, 40); : } _wapi_handle_get_or_set_share (dev_t device, ino_t inode, guint32 new_sharemode, guint32 new_access, guint32 * old_sharemode, guint32 * old_access, struct _WapiFileShare * * share_info) { long int D.12871; _Bool D.12872; long int D.12873; long int D.12874; int D.12879; struct GHashTable * file_share_hash.93; struct GHashTable * file_share_hash.94; _Bool D.12888; long int D.12889; long int D.12890; unsigned int D.12895; unsigned int D.12896; guint32 * D.12897; int D.12899; _Bool D.12902; long int D.12903; long int D.12904; struct _WapiFileShareLayout * _wapi_fileshare_layout.95; unsigned int D.12911; long unsigned int D.12916; long unsigned int D.12919; unsigned int i.96; unsigned int D.12923; _Bool D.12926; _Bool D.12927; _Bool D.12928; int D.12935; struct _WapiFileShare * D.12936; int now.97; guint32 * D.12940; gboolean D.12941; struct _WapiFileShare * file_share; guint32 now; int thr_ret; int i; int first_unused; gboolean exists; D.12871 = time (0B); now = (guint32) D.12871; first_unused = -1; exists = 0; thr_ret = _wapi_handle_lock_shared_handles (); D.12872 = thr_ret != 0; D.12873 = (long int) D.12872; D.12874 = __builtin_expect (D.12873, 0); if (D.12874 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1643, "thr_ret == 0"); : thr_ret = _wapi_shm_sem_lock (2); D.12872 = thr_ret != 0; D.12873 = (long int) D.12872; D.12874 = __builtin_expect (D.12873, 0); if (D.12874 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1647, "thr_ret == 0"); : D.12879 = _wapi_shm_enabled (); if (D.12879 == 0) goto ; else goto ; : { struct _WapiFileShare tmp; try { file_share_hash.93 = file_share_hash; if (file_share_hash.93 == 0B) goto ; else goto ; : file_share_hash.94 = monoeg_g_hash_table_new_full (wapi_share_info_hash, wapi_share_info_equal, 0B, monoeg_g_free); file_share_hash = file_share_hash.94; InitializeCriticalSection (&file_share_hash_mutex); : tmp.device = device; tmp.inode = inode; { int ret; ret = pthread_mutex_lock (&file_share_hash_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.12888 = ret != 0; D.12889 = (long int) D.12888; D.12890 = __builtin_expect (D.12889, 0); if (D.12890 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1665, "ret == 0"); : } file_share_hash.93 = file_share_hash; file_share = monoeg_g_hash_table_lookup (file_share_hash.93, &tmp); if (file_share != 0B) goto ; else goto ; : D.12895 = file_share->sharemode; *old_sharemode = D.12895; D.12896 = file_share->access; *old_access = D.12896; *share_info = file_share; D.12897 = &file_share->handle_refs; InterlockedIncrement (D.12897); exists = 1; goto ; : file_share = monoeg_malloc0 (40); file_share->device = device; file_share->inode = inode; D.12899 = _wapi_getpid (); file_share->opened_by_pid = D.12899; file_share->sharemode = new_sharemode; file_share->access = new_access; file_share->handle_refs = 1; *share_info = file_share; file_share_hash.93 = file_share_hash; monoeg_g_hash_table_insert_replace (file_share_hash.93, file_share, file_share, 0); : { int ret; ret = pthread_mutex_unlock (&file_share_hash_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.12902 = ret != 0; D.12903 = (long int) D.12902; D.12904 = __builtin_expect (D.12903, 0); if (D.12904 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1689, "ret == 0"); : } } finally { tmp = {CLOBBER}; } } goto ; : *share_info = 0B; i = 0; goto ; : _wapi_fileshare_layout.95 = _wapi_fileshare_layout; file_share = &_wapi_fileshare_layout.95->share_info[i]; if (first_unused == -1) goto ; else goto ; : D.12911 = file_share->handle_refs; if (D.12911 == 0) goto ; else goto ; : first_unused = i; // predicted unlikely by continue predictor. goto ; : : D.12911 = file_share->handle_refs; if (D.12911 == 0) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.12916 = file_share->device; if (D.12916 == device) goto ; else goto ; : D.12919 = file_share->inode; if (D.12919 == inode) goto ; else goto ; : D.12895 = file_share->sharemode; *old_sharemode = D.12895; D.12896 = file_share->access; *old_access = D.12896; *share_info = file_share; D.12897 = &file_share->handle_refs; InterlockedIncrement (D.12897); exists = 1; goto ; : : : i = i + 1; : i.96 = (unsigned int) i; _wapi_fileshare_layout.95 = _wapi_fileshare_layout; D.12923 = _wapi_fileshare_layout.95->hwm; if (i.96 <= D.12923) goto ; else goto ; : if (exists == 0) goto ; else goto ; : D.12926 = i == 102400; D.12927 = first_unused == -1; D.12928 = D.12926 & D.12927; if (D.12928 != 0) goto ; else goto ; : goto ; : if (first_unused == -1) goto ; else goto ; : _wapi_fileshare_layout.95 = _wapi_fileshare_layout; i = i + 1; file_share = &_wapi_fileshare_layout.95->share_info[i]; _wapi_fileshare_layout.95 = _wapi_fileshare_layout; i.96 = (unsigned int) i; _wapi_fileshare_layout.95->hwm = i.96; goto ; : _wapi_fileshare_layout.95 = _wapi_fileshare_layout; file_share = &_wapi_fileshare_layout.95->share_info[first_unused]; : file_share->device = device; file_share->inode = inode; D.12935 = _wapi_getpid (); file_share->opened_by_pid = D.12935; file_share->sharemode = new_sharemode; file_share->access = new_access; file_share->handle_refs = 1; *share_info = file_share; : : D.12936 = *share_info; if (D.12936 != 0B) goto ; else goto ; : now.97 = (int) now; D.12936 = *share_info; D.12940 = &D.12936->timestamp; InterlockedExchange (D.12940, now.97); : : thr_ret = _wapi_shm_sem_unlock (2); _wapi_handle_unlock_shared_handles (); D.12941 = exists; return D.12941; } wapi_share_info_equal (const void * ka, const void * kb) { gint D.12943; int iftmp.98; long unsigned int D.12947; long unsigned int D.12948; long unsigned int D.12950; long unsigned int D.12951; const struct _WapiFileShare * s1; const struct _WapiFileShare * s2; s1 = ka; s2 = kb; D.12947 = s1->device; D.12948 = s2->device; if (D.12947 == D.12948) goto ; else goto ; : D.12950 = s1->inode; D.12951 = s2->inode; if (D.12950 == D.12951) goto ; else goto ; : iftmp.98 = 1; goto ; : iftmp.98 = 0; : D.12943 = iftmp.98; return D.12943; } wapi_share_info_hash (const void * data) { guint D.12954; long unsigned int D.12955; const struct _WapiFileShare * s; s = data; D.12955 = s->inode; D.12954 = (guint) D.12955; return D.12954; } _wapi_handle_check_share (struct _WapiFileShare * share_info, int fd) { _Bool D.12957; long int D.12958; long int D.12959; int D.12964; int D.12967; struct _WapiHandleUnshared * D.12968; int D.12971; long unsigned int D.12972; long unsigned int D.12973; D.12976; struct _WapiFileShare * D.12979; unsigned int i.99; unsigned int _wapi_fd_reserve.100; struct _WapiHandleSharedLayout * _wapi_shared_layout.101; D.12984; int D.11637; int iftmp.102; int D.11636; const char[2] * D.12994; unsigned char D.12995; int D.12996; unsigned char D.12997; int D.12998; _Bool D.12999; _Bool D.13000; _Bool D.13001; const unsigned char * D.13004; unsigned char D.13005; int D.13006; const unsigned char * D.13007; unsigned char D.13008; int D.13009; _Bool D.13010; _Bool D.13011; const unsigned char * D.13014; unsigned char D.13015; int D.13016; const unsigned char * D.13017; unsigned char D.13018; int D.13019; _Bool D.13020; _Bool D.13021; const unsigned char * D.13024; unsigned char D.13025; int D.13026; const unsigned char * D.13027; unsigned char D.13028; int D.13029; char[256] * D.13031; int D.11646; int iftmp.103; int D.11645; const char[3] * D.13036; unsigned char D.13037; int D.13038; unsigned char D.13039; int D.13040; _Bool D.13041; _Bool D.13042; _Bool D.13043; const unsigned char * D.13046; unsigned char D.13047; int D.13048; const unsigned char * D.13049; unsigned char D.13050; int D.13051; _Bool D.13052; _Bool D.13053; const unsigned char * D.13056; unsigned char D.13057; int D.13058; const unsigned char * D.13059; unsigned char D.13060; int D.13061; _Bool D.13062; _Bool D.13063; const unsigned char * D.13066; unsigned char D.13067; int D.13068; const unsigned char * D.13069; unsigned char D.13070; int D.13071; int D.13075; long unsigned int D.13076; long unsigned int D.13077; long unsigned int D.13080; long unsigned int D.13081; gboolean found; gboolean proc_fds; pid_t self; int pid; int thr_ret; int i; void done = <<< error >>>; found = 0; proc_fds = 0; self = _wapi_getpid (); thr_ret = _wapi_handle_lock_shared_handles (); D.12957 = thr_ret != 0; D.12958 = (long int) D.12957; D.12959 = __builtin_expect (D.12958, 0); if (D.12959 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1803, "thr_ret == 0"); : thr_ret = _wapi_shm_sem_lock (2); D.12957 = thr_ret != 0; D.12958 = (long int) D.12957; D.12959 = __builtin_expect (D.12958, 0); if (D.12959 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1807, "thr_ret == 0"); : D.12964 = access ("/proc", 0); if (D.12964 == -1) goto ; else goto ; : _wapi_handle_check_share_by_pid (share_info); goto done; : i = 0; goto ; : D.12967 = i / 256; D.12968 = _wapi_private_handles[D.12967]; if (D.12968 != 0B) goto ; else goto ; : { struct _WapiHandleUnshared * handle; D.12967 = i / 256; D.12968 = _wapi_private_handles[D.12967]; D.12971 = i % 256; D.12972 = (long unsigned int) D.12971; D.12973 = D.12972 * 200; handle = D.12968 + D.12973; if (i != fd) goto ; else goto ; : D.12976 = handle->type; if (D.12976 == 1) goto ; else goto ; : { struct _WapiHandle_file * file_handle; file_handle = &handle->u.file; D.12979 = file_handle->share_info; if (D.12979 == share_info) goto done; else goto ; : } : : } : i = i + 1; : i.99 = (unsigned int) i; _wapi_fd_reserve.100 = _wapi_fd_reserve; if (i.99 < _wapi_fd_reserve.100) goto ; else goto ; : i = 0; goto ; : { struct _WapiHandleShared * shared; struct _WapiHandle_process * process_handle; _wapi_shared_layout.101 = _wapi_shared_layout; shared = &_wapi_shared_layout.101->handles[i]; D.12984 = shared->type; if (D.12984 == 9) goto ; else goto ; : { struct DIR * fd_dir; struct dirent * fd_entry; char subdir[256]; try { process_handle = &shared->u.process; pid = process_handle->id; monoeg_g_snprintf (&subdir, 256, "/proc/%d/fd", pid); fd_dir = opendir (&subdir); if (fd_dir == 0B) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : proc_fds = 1; goto ; : { char path[256]; struct stat link_stat; try { { size_t __s1_len; size_t __s2_len; __s2_len = 1; if (__s2_len <= 3) goto ; else goto ; : { const unsigned char * __s2; int __result; __s2 = &fd_entry->d_name; D.12994 = "."; D.12995 = MEM[(const unsigned char *)D.12994]; D.12996 = (int) D.12995; D.12997 = *__s2; D.12998 = (int) D.12997; __result = D.12996 - D.12998; { D.12999 = __s2_len != 0; D.13000 = __result == 0; D.13001 = D.12999 & D.13000; if (D.13001 != 0) goto ; else goto ; : D.13004 = &MEM[(void *)"." + 1B]; D.13005 = *D.13004; D.13006 = (int) D.13005; D.13007 = __s2 + 1; D.13008 = *D.13007; D.13009 = (int) D.13008; __result = D.13006 - D.13009; D.13010 = __s2_len > 1; D.13000 = __result == 0; D.13011 = D.13010 & D.13000; if (D.13011 != 0) goto ; else goto ; : D.13014 = &MEM[(void *)"." + 2B]; D.13015 = *D.13014; D.13016 = (int) D.13015; D.13017 = __s2 + 2; D.13018 = *D.13017; D.13019 = (int) D.13018; __result = D.13016 - D.13019; D.13020 = __s2_len > 2; D.13000 = __result == 0; D.13021 = D.13020 & D.13000; if (D.13021 != 0) goto ; else goto ; : D.13024 = &MEM[(void *)"." + 3B]; D.13025 = *D.13024; D.13026 = (int) D.13025; D.13027 = __s2 + 3; D.13028 = *D.13027; D.13029 = (int) D.13028; __result = D.13026 - D.13029; : : : } D.11636 = __result; } iftmp.102 = -D.11636; goto ; : D.13031 = &fd_entry->d_name; iftmp.102 = __builtin_strcmp (D.13031, "."); : D.11637 = iftmp.102; } if (D.11637 == 0) goto ; else goto ; : { size_t __s1_len; size_t __s2_len; __s2_len = 2; if (__s2_len <= 3) goto ; else goto ; : { const unsigned char * __s2; int __result; __s2 = &fd_entry->d_name; D.13036 = ".."; D.13037 = MEM[(const unsigned char *)D.13036]; D.13038 = (int) D.13037; D.13039 = *__s2; D.13040 = (int) D.13039; __result = D.13038 - D.13040; { D.13041 = __s2_len != 0; D.13042 = __result == 0; D.13043 = D.13041 & D.13042; if (D.13043 != 0) goto ; else goto ; : D.13046 = &MEM[(void *)".." + 1B]; D.13047 = *D.13046; D.13048 = (int) D.13047; D.13049 = __s2 + 1; D.13050 = *D.13049; D.13051 = (int) D.13050; __result = D.13048 - D.13051; D.13052 = __s2_len > 1; D.13042 = __result == 0; D.13053 = D.13052 & D.13042; if (D.13053 != 0) goto ; else goto ; : D.13056 = &MEM[(void *)".." + 2B]; D.13057 = *D.13056; D.13058 = (int) D.13057; D.13059 = __s2 + 2; D.13060 = *D.13059; D.13061 = (int) D.13060; __result = D.13058 - D.13061; D.13062 = __s2_len > 2; D.13042 = __result == 0; D.13063 = D.13062 & D.13042; if (D.13063 != 0) goto ; else goto ; : D.13066 = &MEM[(void *)".." + 3B]; D.13067 = *D.13066; D.13068 = (int) D.13067; D.13069 = __s2 + 3; D.13070 = *D.13069; D.13071 = (int) D.13070; __result = D.13068 - D.13071; : : : } D.11645 = __result; } iftmp.103 = -D.11645; goto ; : D.13031 = &fd_entry->d_name; iftmp.103 = __builtin_strcmp (D.13031, ".."); : D.11646 = iftmp.103; } if (D.11646 == 0) goto ; else goto ; : if (pid == self) goto ; else goto ; : D.13031 = &fd_entry->d_name; D.13075 = atoi (D.13031); if (D.13075 == fd) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.13031 = &fd_entry->d_name; monoeg_g_snprintf (&path, 256, "/proc/%d/fd/%s", pid, D.13031); stat (&path, &link_stat); D.13076 = link_stat.st_dev; D.13077 = share_info->device; if (D.13076 == D.13077) goto ; else goto ; : D.13080 = link_stat.st_ino; D.13081 = share_info->inode; if (D.13080 == D.13081) goto ; else goto ; : found = 1; : : } finally { path = {CLOBBER}; link_stat = {CLOBBER}; } } : fd_entry = readdir (fd_dir); if (fd_entry != 0B) goto ; else goto ; : closedir (fd_dir); } finally { subdir = {CLOBBER}; } } : } : i = i + 1; : if (i <= 255) goto ; else goto ; : if (proc_fds == 0) goto ; else goto ; : _wapi_handle_check_share_by_pid (share_info); goto ; : if (found == 0) goto ; else goto ; : _wapi_free_share_info (share_info); : : done: thr_ret = _wapi_shm_sem_unlock (2); _wapi_handle_unlock_shared_handles (); } atoi (const char * __nptr) { int D.13093; long int D.13094; D.13094 = strtol (__nptr, 0B, 10); D.13093 = (int) D.13094; return D.13093; } stat (const char * __path, struct stat * __statbuf) { int D.13096; D.13096 = __xstat (1, __path, __statbuf); return D.13096; } _wapi_handle_check_share_by_pid (struct _WapiFileShare * share_info) { int D.13098; int D.13099; int * D.13102; int D.13103; _Bool D.13104; _Bool D.13105; _Bool D.13106; D.13098 = share_info->opened_by_pid; D.13099 = kill (D.13098, 0); if (D.13099 == -1) goto ; else goto ; : D.13102 = __errno_location (); D.13103 = *D.13102; D.13104 = D.13103 == 3; D.13105 = D.13103 == 1; D.13106 = D.13104 | D.13105; if (D.13106 != 0) goto ; else goto ; : _wapi_free_share_info (share_info); : : } _wapi_handle_dump () { long int D.13109; long int D.13110; _Bool D.13113; long int D.13114; long int D.13115; struct _WapiHandleUnshared * D.13118; long unsigned int D.13121; long unsigned int D.13122; D.13123; unsigned int D.13126; const char * iftmp.104; int D.13128; const char * D.13132; unsigned int D.13133; unsigned int D.13134; void (*) (void *) D.13135; union { struct _WapiHandle_event event; struct _WapiHandle_file file; struct _WapiHandle_find find; struct _WapiHandle_mutex mutex; struct _WapiHandle_sem sem; struct _WapiHandle_socket sock; struct _WapiHandle_thread thread; struct _WapiHandle_shared_ref shared; } * D.13136; unsigned int _wapi_private_handle_slot_count.105; struct _WapiHandleUnshared * handle_data; guint32 i; guint32 k; int thr_ret; { struct __pthread_unwind_buf_t __cancel_buf; void (*) (void *) __cancel_routine; void * __cancel_arg; int __not_first_call; try { __cancel_routine = mono_mutex_unlock_in_cleanup; __cancel_arg = &scan_mutex; __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0); D.13109 = (long int) __not_first_call; D.13110 = __builtin_expect (D.13109, 0); if (D.13110 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); : __pthread_register_cancel (&__cancel_buf); thr_ret = pthread_mutex_lock (&scan_mutex); D.13113 = thr_ret != 0; D.13114 = (long int) D.13113; D.13115 = __builtin_expect (D.13114, 0); if (D.13115 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1943, "thr_ret == 0"); : i = 0; goto ; : D.13118 = _wapi_private_handles[i]; if (D.13118 != 0B) goto ; else goto ; : k = 0; goto ; : D.13118 = _wapi_private_handles[i]; D.13121 = (long unsigned int) k; D.13122 = D.13121 * 200; handle_data = D.13118 + D.13122; D.13123 = handle_data->type; if (D.13123 == 0) goto ; else goto ; : // predicted unlikely by continue predictor. goto ; : D.13126 = handle_data->ref; D.13128 = handle_data->signalled; if (D.13128 != 0) goto ; else goto ; : iftmp.104 = "Sg"; goto ; : iftmp.104 = "Un"; : D.13123 = handle_data->type; D.13132 = _wapi_handle_typename[D.13123]; D.13133 = i * 256; D.13134 = D.13133 + k; monoeg_g_print ("%3x [%7s] %s %d ", D.13134, D.13132, iftmp.104, D.13126); D.13123 = handle_data->type; D.13135 = handle_details[D.13123]; D.13136 = &handle_data->u; D.13135 (D.13136); monoeg_g_print ("\n"); : k = k + 1; : if (k <= 255) goto ; else goto ; : : i = i + 1; : _wapi_private_handle_slot_count.105 = _wapi_private_handle_slot_count; if (i < _wapi_private_handle_slot_count.105) goto ; else goto ; : thr_ret = pthread_mutex_unlock (&scan_mutex); D.13113 = thr_ret != 0; D.13114 = (long int) D.13113; D.13115 = __builtin_expect (D.13114, 0); if (D.13115 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1966, "thr_ret == 0"); : __pthread_unregister_cancel (&__cancel_buf); if (0 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); : } finally { __cancel_buf = {CLOBBER}; } } } _wapi_shared_details (void * handle_info) { unsigned int D.13144; struct _WapiHandle_shared_ref * shared; shared = handle_info; D.13144 = shared->offset; monoeg_g_print ("offset: 0x%x", D.13144); } _wapi_handle_update_refs () { long int D.13145; _Bool D.13146; long int D.13147; long int D.13148; long int D.13153; long int D.13154; struct _WapiHandleUnshared * D.13157; long unsigned int D.13160; long unsigned int D.13161; D.13165; _Bool D.13166; _Bool D.13167; _Bool D.13168; D.13170; struct _WapiHandleSharedLayout * _wapi_shared_layout.106; unsigned int D.13173; int now.107; guint32 * D.13175; struct _WapiFileShare * D.13178; _Bool D.13179; long int D.13180; long int D.13181; guint32 * D.13184; unsigned int _wapi_private_handle_slot_count.108; guint32 i; guint32 k; int thr_ret; guint32 now; D.13145 = time (0B); now = (guint32) D.13145; thr_ret = _wapi_handle_lock_shared_handles (); D.13146 = thr_ret != 0; D.13147 = (long int) D.13146; D.13148 = __builtin_expect (D.13147, 0); if (D.13148 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1984, "thr_ret == 0"); : thr_ret = _wapi_shm_sem_lock (2); D.13146 = thr_ret != 0; D.13147 = (long int) D.13146; D.13148 = __builtin_expect (D.13147, 0); if (D.13148 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 1988, "thr_ret == 0"); : { struct __pthread_unwind_buf_t __cancel_buf; void (*) (void *) __cancel_routine; void * __cancel_arg; int __not_first_call; try { __cancel_routine = mono_mutex_unlock_in_cleanup; __cancel_arg = &scan_mutex; __not_first_call = __sigsetjmp (&__cancel_buf.__cancel_jmp_buf, 0); D.13153 = (long int) __not_first_call; D.13154 = __builtin_expect (D.13153, 0); if (D.13154 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); : __pthread_register_cancel (&__cancel_buf); thr_ret = pthread_mutex_lock (&scan_mutex); i = 0; goto ; : D.13157 = _wapi_private_handles[i]; if (D.13157 != 0B) goto ; else goto ; : k = 0; goto ; : { struct _WapiHandleUnshared * handle; D.13157 = _wapi_private_handles[i]; D.13160 = (long unsigned int) k; D.13161 = D.13160 * 200; handle = D.13157 + D.13161; D.13165 = handle->type; D.13166 = D.13165 == 9; D.13167 = D.13165 == 11; D.13168 = D.13166 | D.13167; if (D.13168 != 0) goto ; else goto ; : D.13170 = handle->type; if (D.13170 == 12) goto ; else goto ; : D.13170 = handle->type; if (D.13170 == 13) goto ; else goto ; : { struct _WapiHandleShared * shared_data; _wapi_shared_layout.106 = _wapi_shared_layout; D.13173 = handle->u.shared.offset; shared_data = &_wapi_shared_layout.106->handles[D.13173]; now.107 = (int) now; D.13175 = &shared_data->timestamp; InterlockedExchange (D.13175, now.107); } goto ; : D.13170 = handle->type; if (D.13170 == 1) goto ; else goto ; : { struct _WapiHandle_file * file_handle; file_handle = &handle->u.file; D.13178 = file_handle->share_info; D.13179 = D.13178 == 0B; D.13180 = (long int) D.13179; D.13181 = __builtin_expect (D.13180, 0); if (D.13181 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 2014, "file_handle->share_info != NULL"); : now.107 = (int) now; D.13178 = file_handle->share_info; D.13184 = &D.13178->timestamp; InterlockedExchange (D.13184, now.107); } : : } k = k + 1; : if (k <= 255) goto ; else goto ; : : i = i + 1; : _wapi_private_handle_slot_count.108 = _wapi_private_handle_slot_count; if (i < _wapi_private_handle_slot_count.108) goto ; else goto ; : thr_ret = pthread_mutex_unlock (&scan_mutex); D.13146 = thr_ret != 0; D.13147 = (long int) D.13146; D.13148 = __builtin_expect (D.13147, 0); if (D.13148 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "handles.c", 2025, "thr_ret == 0"); : __pthread_unregister_cancel (&__cancel_buf); if (0 != 0) goto ; else goto ; : __cancel_routine (__cancel_arg); : } finally { __cancel_buf = {CLOBBER}; } } thr_ret = _wapi_shm_sem_unlock (2); _wapi_handle_unlock_shared_handles (); }