mono_create_static_rgctx_trampoline (struct MonoMethod * m, void * addr) { union mono_mutex_t * D.24813; _Bool D.24816; long int D.24817; long int D.24818; void * D.24821; struct GHashTable * D.24822; struct GHashTable * D.24825; _Bool D.24828; long int D.24829; long int D.24830; void * D.24835; int mono_aot_only.0; _Bool D.24842; long int D.24843; long int D.24844; _Bool D.24849; long int D.24850; long int D.24851; unsigned int static_rgctx_trampolines.1; unsigned int static_rgctx_trampolines.2; void * ctx; void * res; struct MonoDomain * domain; struct RgctxTrampInfo tmp_info; struct RgctxTrampInfo * info; try { ctx = mini_method_get_rgctx (m); domain = mono_domain_get (); { int ret; D.24813 = &domain->lock.mutex; ret = pthread_mutex_lock (D.24813); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.24816 = ret != 0; D.24817 = (long int) D.24816; D.24818 = __builtin_expect (D.24817, 0); if (D.24818 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 96, "ret == 0"); : } D.24821 = domain->runtime_info; D.24822 = MEM[(struct MonoJitDomainInfo *)D.24821].static_rgctx_trampoline_hash; if (D.24822 == 0B) goto ; else goto ; : D.24821 = domain->runtime_info; D.24825 = monoeg_g_hash_table_new (rgctx_tramp_info_hash, rgctx_tramp_info_equal); MEM[(struct MonoJitDomainInfo *)D.24821].static_rgctx_trampoline_hash = D.24825; : tmp_info.m = m; tmp_info.addr = addr; D.24821 = domain->runtime_info; D.24822 = MEM[(struct MonoJitDomainInfo *)D.24821].static_rgctx_trampoline_hash; res = monoeg_g_hash_table_lookup (D.24822, &tmp_info); { int ret; D.24813 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.24813); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.24828 = ret != 0; D.24829 = (long int) D.24828; D.24830 = __builtin_expect (D.24829, 0); if (D.24830 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 103, "ret == 0"); : } if (res != 0B) goto ; else goto ; : D.24835 = res; return D.24835; : mono_aot_only.0 = mono_aot_only; if (mono_aot_only.0 != 0) goto ; else goto ; : res = mono_aot_get_static_rgctx_trampoline (ctx, addr); goto ; : res = mono_arch_get_static_rgctx_trampoline (m, ctx, addr); : { int ret; D.24813 = &domain->lock.mutex; ret = pthread_mutex_lock (D.24813); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.24842 = ret != 0; D.24843 = (long int) D.24842; D.24844 = __builtin_expect (D.24843, 0); if (D.24844 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 112, "ret == 0"); : } info = mono_domain_alloc (domain, 8); info->m = m; info->addr = addr; D.24821 = domain->runtime_info; D.24822 = MEM[(struct MonoJitDomainInfo *)D.24821].static_rgctx_trampoline_hash; monoeg_g_hash_table_insert_replace (D.24822, info, res, 0); { int ret; D.24813 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.24813); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.24849 = ret != 0; D.24850 = (long int) D.24849; D.24851 = __builtin_expect (D.24850, 0); if (D.24851 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 118, "ret == 0"); : } static_rgctx_trampolines.1 = static_rgctx_trampolines; static_rgctx_trampolines.2 = static_rgctx_trampolines.1 + 1; static_rgctx_trampolines = static_rgctx_trampolines.2; D.24835 = res; return D.24835; } finally { tmp_info = {CLOBBER}; } } rgctx_tramp_info_equal (const void * ka, const void * kb) { struct MonoMethod * D.24859; struct MonoMethod * D.24860; void * D.24862; void * D.24863; gint D.24865; const struct RgctxTrampInfo * i1; const struct RgctxTrampInfo * i2; i1 = ka; i2 = kb; D.24859 = i1->m; D.24860 = i2->m; if (D.24859 == D.24860) goto ; else goto ; : D.24862 = i1->addr; D.24863 = i2->addr; if (D.24862 == D.24863) goto ; else goto ; : D.24865 = 1; return D.24865; : D.24865 = 0; return D.24865; } rgctx_tramp_info_hash (const void * data) { guint D.24867; struct MonoMethod * D.24868; unsigned int D.24869; void * D.24870; unsigned int D.24871; const struct RgctxTrampInfo * info; info = data; D.24868 = info->m; D.24869 = (unsigned int) D.24868; D.24870 = info->addr; D.24871 = (unsigned int) D.24870; D.24867 = D.24869 ^ D.24871; return D.24867; } mini_jit_info_is_gsharedvt (struct MonoJitInfo * ji) { unsigned char D.24876; unsigned char D.24877; struct MonoGenericSharingContext * D.24879; gboolean * D.24880; struct MonoGenericSharingContext * D.24882; gboolean * D.24883; gboolean D.24884; if (ji != 0B) goto ; else goto ; : D.24876 = BIT_FIELD_REF <*ji, 8, 176>; D.24877 = D.24876 & 2; if (D.24877 != 0) goto ; else goto ; : D.24879 = mono_jit_info_get_generic_sharing_context (ji); D.24880 = D.24879->var_is_vt; if (D.24880 != 0B) goto ; else goto ; : D.24882 = mono_jit_info_get_generic_sharing_context (ji); D.24883 = D.24882->mvar_is_vt; if (D.24883 != 0B) goto ; else goto ; : D.24884 = 1; return D.24884; : D.24884 = 0; return D.24884; } mini_add_method_trampoline (struct MonoMethod * orig_method, struct MonoMethod * m, void * compiled_method, gboolean add_static_rgctx_tramp, gboolean add_unbox_tramp) { struct MonoDomain * D.24886; void * D.24887; unsigned char D.24888; unsigned char D.24889; D.24894; D.24902; unsigned char D.24909; unsigned char D.24910; _Bool D.24911; long int D.24912; long int D.24913; int mono_aot_only.3; unsigned int unbox_trampolines.4; unsigned int unbox_trampolines.5; struct MonoMethodSignature * D.24928; int D.24929; _Bool D.24932; _Bool D.24933; _Bool D.24934; void * D.24937; void * addr; gboolean callee_gsharedvt; gboolean callee_array_helper; struct MonoMethod * jmethod; struct MonoJitInfo * ji; addr = compiled_method; jmethod = 0B; D.24886 = mono_domain_get (); D.24887 = mono_get_addr_from_ftnptr (compiled_method); ji = mini_jit_info_table_find (D.24886, D.24887, 0B); callee_gsharedvt = mini_jit_info_is_gsharedvt (ji); callee_array_helper = 0; D.24888 = BIT_FIELD_REF <*m, 8, 160>; D.24889 = D.24888 & 124; if (D.24889 == 28) goto ; else goto ; : { struct WrapperInfo * info; info = mono_marshal_get_wrapper_info (m); if (info != 0B) goto ; else goto ; : D.24894 = info->subtype; if (D.24894 == 21) goto ; else goto ; : callee_array_helper = 1; m = info->d.generic_array_helper.method; : : } goto ; : D.24888 = BIT_FIELD_REF <*m, 8, 160>; D.24889 = D.24888 & 124; if (D.24889 == 100) goto ; else goto ; : { struct WrapperInfo * info; info = mono_marshal_get_wrapper_info (m); if (info != 0B) goto ; else goto ; : D.24902 = info->subtype; if (D.24902 == 17) goto ; else goto ; : m = info->d.synchronized_inner.method; : : } : : if (orig_method == 0B) goto ; else goto ; : orig_method = m; : if (callee_gsharedvt != 0) goto ; else goto ; : D.24909 = BIT_FIELD_REF <*m, 8, 168>; D.24910 = D.24909 & 16; D.24911 = D.24910 == 0; D.24912 = (long int) D.24911; D.24913 = __builtin_expect (D.24912, 0); if (D.24913 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 324, "m->is_inflated"); : : addr = compiled_method; if (add_unbox_tramp != 0) goto ; else goto ; : mono_aot_only.3 = mono_aot_only; if (mono_aot_only.3 != 0) goto ; else goto ; : addr = mono_aot_get_unbox_trampoline (m); goto ; : unbox_trampolines.4 = unbox_trampolines; unbox_trampolines.5 = unbox_trampolines.4 + 1; unbox_trampolines = unbox_trampolines.5; addr = mono_arch_get_unbox_trampoline (m, addr); : : if (ji != 0B) goto ; else goto ; : jmethod = jinfo_get_method (ji); : if (callee_gsharedvt != 0) goto ; else goto ; : D.24928 = mono_method_signature (jmethod); D.24929 = mini_is_gsharedvt_variable_signature (D.24928); if (D.24929 != 0) goto ; else goto ; : { struct MonoGenericSharingContext * gsctx; struct MonoMethodSignature * sig; struct MonoMethodSignature * gsig; gsctx = mono_jit_info_get_generic_sharing_context (ji); sig = mono_method_signature (m); gsig = mono_method_signature (jmethod); addr = mini_get_gsharedvt_wrapper (1, addr, sig, gsig, gsctx, -1, 0); } : : D.24932 = add_static_rgctx_tramp != 0; D.24933 = callee_array_helper == 0; D.24934 = D.24932 & D.24933; if (D.24934 != 0) goto ; else goto ; : addr = mono_create_static_rgctx_trampoline (m, addr); : D.24937 = addr; return D.24937; } jinfo_get_method (struct MonoJitInfo * ji) { struct MonoMethod * D.24939; D.24939 = mono_jit_info_get_method (ji); return D.24939; } mono_magic_trampoline (mgreg_t * regs, guint8 * code, void * arg, guint8 * tramp) { unsigned int trampoline_calls.6; unsigned int trampoline_calls.7; void * D.24943; trampoline_calls.6 = trampoline_calls; trampoline_calls.7 = trampoline_calls.6 + 1; trampoline_calls = trampoline_calls.7; D.24943 = common_call_trampoline (regs, code, arg, tramp, 0B, 0B, 0); return D.24943; } common_call_trampoline (mgreg_t * regs, guint8 * code, struct MonoMethod * m, guint8 * tramp, struct MonoVTable * vt, void * * vtable_slot, gboolean need_rgctx_tramp) { _Bool D.24945; _Bool D.24946; _Bool D.24947; _Bool D.24948; _Bool D.24951; long int D.24952; long int D.24953; struct MonoVTable * D.24956; struct MonoClass * D.24957; struct MonoClass * D.24958; unsigned char D.24964; unsigned char D.24965; struct MonoGenericInst * D.24967; int variance_used.8; struct MonoClass * D.24972; int D.24973; _Bool D.24976; _Bool D.24977; _Bool D.24978; void * addr.9; struct MonoDomain * D.24982; int D.24983; void * D.24986; struct MonoDomain * D.24987; int D.24991; struct MonoGenericClass * D.24996; struct MonoGenericInst * D.24999; struct MonoGenericContainer * D.25001; _Bool D.25002; long int D.25003; long int D.25004; unsigned char D.25009; unsigned char D.25010; _Bool D.25011; long int D.25012; long int D.25013; struct MonoGenericInst * D.25016; _Bool D.25019; long int D.25020; long int D.25021; struct MonoGenericContext * D.25027; struct MonoGenericInst * D.25028; struct MonoVTable * D.25030; short unsigned int D.25034; int D.25035; int D.25036; unsigned char D.25038; unsigned char D.25039; struct MonoVTable * D.25040; struct MonoClass * D.25041; unsigned char D.25042; unsigned char D.25043; _Bool D.25044; long int D.25045; long int D.25046; struct MonoClass * * D.25051; short unsigned int D.25052; sizetype D.25053; sizetype D.25054; sizetype D.25055; struct MonoClass * * D.25056; _Bool D.25057; _Bool D.25058; int D.25059; _Bool D.25060; long int D.25061; long int D.25062; int vtable_slot.10; int vt.11; int D.25069; _Bool D.25070; long int D.25071; long int D.25072; struct MonoClass * D.25075; struct MonoMethod * * D.25076; unsigned int displacement.12; unsigned int D.25078; struct MonoMethod * * D.25079; unsigned char D.25084; unsigned char D.25085; struct MonoGenericClass * D.25089; struct MonoGenericInst * D.25092; struct MonoGenericContainer * D.25094; struct MonoGenericInst * D.25097; long int D.25098; long int D.25099; _Bool D.25102; long int D.25103; long int D.25104; struct MonoClass * D.25107; _Bool D.25108; long int D.25109; long int D.25110; unsigned char D.25113; unsigned char D.25114; short unsigned int D.25118; int D.25119; int D.25120; int D.25125; _Bool D.25128; long int D.25129; long int D.25130; _Bool D.25133; _Bool D.25134; _Bool D.25135; struct MonoClass * D.25138; unsigned char D.25139; unsigned char D.25140; int need_rgctx_tramp.13; void * addr.14; struct MonoMethod * iftmp.15; struct MonoDomain * D.25158; void * D.25161; struct GHashTable * D.25162; union mono_mutex_t * D.25165; _Bool D.25168; long int D.25169; long int D.25170; _Bool D.25177; long int D.25178; long int D.25179; int D.25188; struct MonoDomain * D.25190; int D.25191; void * D.25192; _Bool D.25193; long int D.25194; long int D.25195; void * D.25198; struct MonoDomain * D.25204; void * D.25205; struct MonoDomain * D.25208; _Bool D.25209; _Bool D.25210; _Bool D.25211; unsigned char D.25216; unsigned char D.25217; unsigned char D.25220; unsigned char D.25221; struct MonoDomain * D.25231; void * D.25232; struct MonoDomain * D.25235; int D.25246; void * D.25249; void * addr; void * compiled_method; gboolean generic_shared; gboolean need_unbox_tramp; struct MonoMethod * declaring; struct MonoMethod * generic_virtual; struct MonoMethod * variant_iface; struct MonoMethod * orig_method; int context_used; gboolean virtual; gboolean variance_used; void * * orig_vtable_slot; void * * vtable_slot_to_patch; struct MonoJitInfo * ji; try { generic_shared = 0; need_unbox_tramp = 0; declaring = 0B; generic_virtual = 0B; variant_iface = 0B; orig_method = 0B; variance_used = 0; vtable_slot_to_patch = 0B; ji = 0B; D.24945 = vtable_slot > vt; virtual = (gboolean) D.24945; orig_vtable_slot = vtable_slot; vtable_slot_to_patch = vtable_slot; D.24946 = vt != 0B; D.24947 = vtable_slot < vt; D.24948 = D.24946 & D.24947; if (D.24948 != 0) goto ; else goto ; : { struct MonoMethod * impl_method; struct MonoObject * this_arg; try { impl_method = 0B; m = mono_arch_find_imt_method (regs, code); vtable_slot = orig_vtable_slot; D.24951 = vtable_slot == 0B; D.24952 = (long int) D.24951; D.24953 = __builtin_expect (D.24952, 0); if (D.24953 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 401, "vtable_slot"); : orig_method = m; this_arg = mono_arch_get_this_arg_from_call (regs, code); D.24956 = this_arg->vtable; D.24957 = D.24956->klass; D.24958 = mono_defaults.transparent_proxy_class; if (D.24957 == D.24958) goto ; else goto ; : m = mono_object_get_virtual_method (this_arg, m); vtable_slot_to_patch = 0B; goto ; : { gboolean lookup_aot; D.24964 = BIT_FIELD_REF <*m, 8, 168>; D.24965 = D.24964 & 16; if (D.24965 != 0) goto ; else goto ; : D.24967 = MEM[(struct MonoMethodInflated *)m].context.method_inst; if (D.24967 != 0B) goto ; else goto ; : generic_virtual = m; need_rgctx_tramp = 1; goto ; : variance_used.8 = variance_used; if (variance_used.8 != 0) goto ; else goto ; : D.24972 = m->klass; D.24973 = mono_class_has_variant_generic_params (D.24972); if (D.24973 != 0) goto ; else goto ; : variant_iface = m; : : : addr = 0B; D.24976 = generic_virtual == 0B; D.24977 = variant_iface == 0B; D.24978 = D.24976 & D.24977; lookup_aot = (gboolean) D.24978; vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, regs, code, m, lookup_aot, &impl_method, &need_rgctx_tramp, &variance_used, &addr); vtable_slot_to_patch = vtable_slot; addr.9 = addr; if (addr.9 != 0B) goto ; else goto ; : D.24982 = mono_domain_get (); D.24983 = mono_domain_owns_vtable_slot (D.24982, vtable_slot); if (D.24983 != 0) goto ; else goto ; : addr.9 = addr; *vtable_slot = addr.9; : D.24987 = mono_domain_get (); addr.9 = addr; D.24986 = mono_create_ftnptr (D.24987, addr.9); return D.24986; : m = impl_method; } : } finally { impl_method = {CLOBBER}; } } : if (virtual != 0) goto ; else goto ; : D.24991 = is_generic_method_definition (m); if (D.24991 != 0) goto ; else goto ; : { struct MonoGenericContext context; struct MonoMethod * declaring; try { context.class_inst = 0B; context.method_inst = 0B; D.24964 = BIT_FIELD_REF <*m, 8, 168>; D.24965 = D.24964 & 16; if (D.24965 != 0) goto ; else goto ; : declaring = mono_method_get_declaring_generic_method (m); goto ; : declaring = m; : D.24972 = m->klass; D.24996 = D.24972->generic_class; if (D.24996 != 0B) goto ; else goto ; : D.24972 = m->klass; D.24996 = D.24972->generic_class; D.24999 = D.24996->context.class_inst; context.class_inst = D.24999; goto ; : D.24972 = m->klass; D.25001 = D.24972->generic_container; D.25002 = D.25001 != 0B; D.25003 = (long int) D.25002; D.25004 = __builtin_expect (D.25003, 0); if (D.25004 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 464, "!m->klass->generic_container"); : : generic_virtual = mono_arch_find_imt_method (regs, code); if (generic_virtual != 0B) goto ; else goto ; : D.25009 = BIT_FIELD_REF <*generic_virtual, 8, 168>; D.25010 = D.25009 & 16; D.25011 = D.25010 == 0; D.25012 = (long int) D.25011; D.25013 = __builtin_expect (D.25012, 0); if (D.25013 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 470, "generic_virtual->is_inflated"); : D.25016 = MEM[(struct MonoMethodInflated *)generic_virtual].context.method_inst; context.method_inst = D.25016; : m = mono_class_inflate_generic_method (declaring, &context); need_rgctx_tramp = 1; } finally { context = {CLOBBER}; } } goto ; : context_used = mono_method_check_context_used (m); if (context_used != 0) goto ; else goto ; : { struct MonoClass * klass; struct MonoMethod * actual_method; struct MonoVTable * vt; struct MonoGenericInst * method_inst; klass = 0B; actual_method = 0B; vt = 0B; method_inst = 0B; vtable_slot = 0B; generic_shared = 1; D.25019 = code == 0B; D.25020 = (long int) D.25019; D.25021 = __builtin_expect (D.25020, 0); if (D.25021 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 486, "code"); : D.24964 = BIT_FIELD_REF <*m, 8, 168>; D.24965 = D.24964 & 16; if (D.24965 != 0) goto ; else goto ; : D.25027 = mono_method_get_context (m); D.25028 = D.25027->method_inst; if (D.25028 != 0B) goto ; else goto ; : { struct MonoMethodRuntimeGenericContext * mrgctx; mrgctx = mono_arch_find_static_call_vtable (regs, code); D.25030 = mrgctx->class_vtable; klass = D.25030->klass; method_inst = mrgctx->method_inst; } goto ; : D.25034 = m->flags; D.25035 = (int) D.25034; D.25036 = D.25035 & 16; if (D.25036 != 0) goto ; else goto ; : D.24972 = m->klass; D.25038 = BIT_FIELD_REF <*D.24972, 8, 160>; D.25039 = D.25038 & 8; if (D.25039 != 0) goto ; else goto ; : { struct MonoVTable * vtable; vtable = mono_arch_find_static_call_vtable (regs, code); klass = vtable->klass; } goto ; : { struct MonoObject * this_argument; this_argument = mono_arch_get_this_arg_from_call (regs, code); vt = this_argument->vtable; vtable_slot = orig_vtable_slot; D.25040 = this_argument->vtable; D.25041 = D.25040->klass; D.25042 = BIT_FIELD_REF <*D.25041, 8, 160>; D.25043 = D.25042 & 1; D.25044 = D.25043 == 0; D.25045 = (long int) D.25044; D.25046 = __builtin_expect (D.25045, 0); if (D.25046 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 512, "this_argument->vtable->klass->inited"); : if (vtable_slot == 0B) goto ; else goto ; : D.25040 = this_argument->vtable; D.25041 = D.25040->klass; mono_class_setup_supertypes (D.25041); D.25040 = this_argument->vtable; D.25041 = D.25040->klass; D.25051 = D.25041->supertypes; D.24972 = m->klass; D.25052 = D.24972->idepth; D.25053 = (sizetype) D.25052; D.25054 = D.25053 + 1073741823; D.25055 = D.25054 * 4; D.25056 = D.25051 + D.25055; klass = *D.25056; : } : : D.24951 = vtable_slot == 0B; D.25057 = klass == 0B; D.25058 = D.24951 & D.25057; D.25059 = (int) D.25058; D.25060 = D.25059 != 0; D.25061 = (long int) D.25060; D.25062 = __builtin_expect (D.25061, 0); if (D.25062 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 524, "vtable_slot || klass"); : if (vtable_slot != 0B) goto ; else goto ; : { int displacement; vtable_slot.10 = (int) vtable_slot; vt.11 = (int) vt; D.25069 = vtable_slot.10 - vt.11; displacement = D.25069 /[ex] 4; monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 529); D.25070 = displacement <= 0; D.25071 = (long int) D.25070; D.25072 = __builtin_expect (D.25071, 0); if (D.25072 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 531, "displacement > 0"); : D.25075 = vt->klass; D.25076 = D.25075->vtable; displacement.12 = (unsigned int) displacement; D.25078 = displacement.12 * 4; D.25079 = D.25076 + D.25078; actual_method = *D.25079; } : if (method_inst != 0B) goto ; else goto ; : D.25084 = BIT_FIELD_REF <*m, 8, 160>; D.25085 = D.25084 & 124; if (D.25085 != 0) goto ; else goto ; : { struct MonoGenericContext context; try { context.class_inst = 0B; context.method_inst = 0B; D.24964 = BIT_FIELD_REF <*m, 8, 168>; D.24965 = D.24964 & 16; if (D.24965 != 0) goto ; else goto ; : declaring = mono_method_get_declaring_generic_method (m); goto ; : declaring = m; : D.25089 = klass->generic_class; if (D.25089 != 0B) goto ; else goto ; : D.25089 = klass->generic_class; D.25092 = D.25089->context.class_inst; context.class_inst = D.25092; goto ; : D.25094 = klass->generic_container; if (D.25094 != 0B) goto ; else goto ; : D.25094 = klass->generic_container; D.25097 = D.25094->context.class_inst; context.class_inst = D.25097; : : context.method_inst = method_inst; actual_method = mono_class_inflate_generic_method (declaring, &context); } finally { context = {CLOBBER}; } } goto ; : actual_method = mono_class_get_method_generic (klass, m); : D.25057 = klass == 0B; D.25098 = (long int) D.25057; D.25099 = __builtin_expect (D.25098, 0); if (D.25099 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 555, "klass"); : D.25102 = actual_method == 0B; D.25103 = (long int) D.25102; D.25104 = __builtin_expect (D.25103, 0); if (D.25104 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 556, "actual_method"); : D.25107 = actual_method->klass; D.25108 = D.25107 != klass; D.25109 = (long int) D.25108; D.25110 = __builtin_expect (D.25109, 0); if (D.25110 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 557, "actual_method->klass == klass"); : D.25113 = BIT_FIELD_REF <*actual_method, 8, 168>; D.25114 = D.25113 & 16; if (D.25114 != 0) goto ; else goto ; : declaring = mono_method_get_declaring_generic_method (actual_method); goto ; : declaring = 0B; : m = actual_method; } : : D.25118 = m->iflags; D.25119 = (int) D.25118; D.25120 = D.25119 & 32; if (D.25120 != 0) goto ; else goto ; : m = mono_marshal_get_synchronized_wrapper (m); need_rgctx_tramp = 0; : if (code == 0B) goto ; else goto ; : D.25125 = mono_method_needs_static_rgctx_invoke (m, 0); if (D.25125 != 0) goto ; else goto ; : need_rgctx_tramp = 1; : : compiled_method = mono_compile_method (m); addr = compiled_method; addr.9 = addr; D.25128 = addr.9 == 0B; D.25129 = (long int) D.25128; D.25130 = __builtin_expect (D.25129, 0); if (D.25130 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 577, "addr"); : D.25133 = generic_virtual != 0B; D.25134 = variant_iface != 0B; D.25135 = D.25133 | D.25134; if (D.25135 != 0) goto ; else goto ; : D.25138 = vt->klass; D.25139 = BIT_FIELD_REF <*D.25138, 8, 160>; D.25140 = D.25139 & 8; if (D.25140 != 0) goto ; else goto ; : need_unbox_tramp = 1; : goto ; : if (orig_vtable_slot != 0B) goto ; else goto ; : D.24972 = m->klass; D.25038 = BIT_FIELD_REF <*D.24972, 8, 160>; D.25039 = D.25038 & 8; if (D.25039 != 0) goto ; else goto ; : need_unbox_tramp = 1; : : : need_rgctx_tramp.13 = need_rgctx_tramp; addr.14 = mini_add_method_trampoline (orig_method, m, compiled_method, need_rgctx_tramp.13, need_unbox_tramp); addr = addr.14; D.25133 = generic_virtual != 0B; D.25134 = variant_iface != 0B; D.25135 = D.25133 | D.25134; if (D.25135 != 0) goto ; else goto ; : { struct MonoMethod * target; if (generic_virtual != 0B) goto ; else goto ; : iftmp.15 = generic_virtual; goto ; : iftmp.15 = variant_iface; : target = iftmp.15; vtable_slot = orig_vtable_slot; D.24951 = vtable_slot == 0B; D.24952 = (long int) D.24951; D.24953 = __builtin_expect (D.24952, 0); if (D.24953 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 593, "vtable_slot"); : D.25158 = mono_domain_get (); addr.9 = addr; mono_method_add_generic_virtual_invocation (D.25158, vt, vtable_slot, target, addr.9); D.24986 = addr; return D.24986; } : if (code == 0B) goto ; else goto ; : { struct MonoDomain * domain; domain = mono_domain_get (); D.25161 = domain->runtime_info; D.25162 = MEM[(struct MonoJitDomainInfo *)D.25161].jump_target_got_slot_hash; if (D.25162 != 0B) goto ; else goto ; : { struct GSList * list; struct GSList * tmp; { int ret; D.25165 = &domain->lock.mutex; ret = pthread_mutex_lock (D.25165); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25168 = ret != 0; D.25169 = (long int) D.25168; D.25170 = __builtin_expect (D.25169, 0); if (D.25170 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 614, "ret == 0"); : } D.25161 = domain->runtime_info; D.25162 = MEM[(struct MonoJitDomainInfo *)D.25161].jump_target_got_slot_hash; list = monoeg_g_hash_table_lookup (D.25162, m); if (list != 0B) goto ; else goto ; : tmp = list; goto ; : { void * * got_slot; got_slot = tmp->data; addr.9 = addr; *got_slot = addr.9; } tmp = tmp->next; : if (tmp != 0B) goto ; else goto ; : D.25161 = domain->runtime_info; D.25162 = MEM[(struct MonoJitDomainInfo *)D.25161].jump_target_got_slot_hash; monoeg_g_hash_table_remove (D.25162, m); monoeg_g_slist_free (list); : { int ret; D.25165 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.25165); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25177 = ret != 0; D.25178 = (long int) D.25177; D.25179 = __builtin_expect (D.25178, 0); if (D.25179 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 624, "ret == 0"); : } } : D.24986 = addr; return D.24986; } : vtable_slot = orig_vtable_slot; if (vtable_slot != 0B) goto ; else goto ; : if (vtable_slot_to_patch != 0B) goto ; else goto ; : D.25188 = mono_aot_is_got_entry (code, vtable_slot_to_patch); if (D.25188 != 0) goto ; else goto ; : D.25190 = mono_domain_get (); D.25191 = mono_domain_owns_vtable_slot (D.25190, vtable_slot_to_patch); if (D.25191 != 0) goto ; else goto ; : D.25192 = *vtable_slot_to_patch; D.25193 = D.25192 == 0B; D.25194 = (long int) D.25193; D.25195 = __builtin_expect (D.25194, 0); if (D.25195 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 634, "*vtable_slot_to_patch"); : addr.9 = addr; D.25198 = mono_get_addr_from_ftnptr (addr.9); *vtable_slot_to_patch = D.25198; : : goto ; : { guint8 * plt_entry; gboolean no_patch; struct MonoJitInfo * target_ji; plt_entry = mono_aot_get_plt_entry (code); no_patch = 0; if (plt_entry != 0B) goto ; else goto ; : if (generic_shared != 0) goto ; else goto ; : D.25204 = mono_domain_get (); D.25205 = mono_get_addr_from_ftnptr (compiled_method); target_ji = mini_jit_info_table_find (D.25204, D.25205, 0B); if (ji == 0B) goto ; else goto ; : D.25208 = mono_domain_get (); ji = mini_jit_info_table_find (D.25208, code, 0B); : D.25209 = ji != 0B; D.25210 = target_ji != 0B; D.25211 = D.25209 & D.25210; if (D.25211 != 0) goto ; else goto ; : if (generic_shared != 0) goto ; else goto ; : D.25216 = BIT_FIELD_REF <*ji, 8, 176>; D.25217 = D.25216 & 2; if (D.25217 != 0) goto ; else goto ; : D.25220 = BIT_FIELD_REF <*target_ji, 8, 176>; D.25221 = D.25220 & 2; if (D.25221 == 0) goto ; else goto ; : no_patch = 1; : : : : : if (no_patch == 0) goto ; else goto ; : addr.9 = addr; mono_aot_patch_plt_entry (plt_entry, 0B, regs, addr.9); : goto ; : if (generic_shared != 0) goto ; else goto ; : D.25084 = BIT_FIELD_REF <*m, 8, 160>; D.25085 = D.25084 & 124; if (D.25085 != 0) goto ; else goto ; : m = mono_marshal_method_from_wrapper (m); : : D.25231 = mono_domain_get (); D.25232 = mono_get_addr_from_ftnptr (compiled_method); target_ji = mini_jit_info_table_find (D.25231, D.25232, 0B); if (ji == 0B) goto ; else goto ; : D.25235 = mono_domain_get (); ji = mini_jit_info_table_find (D.25235, code, 0B); : D.25209 = ji != 0B; D.25210 = target_ji != 0B; D.25211 = D.25209 & D.25210; if (D.25211 != 0) goto ; else goto ; : if (generic_shared != 0) goto ; else goto ; : D.25216 = BIT_FIELD_REF <*ji, 8, 176>; D.25217 = D.25216 & 2; if (D.25217 != 0) goto ; else goto ; : D.25220 = BIT_FIELD_REF <*target_ji, 8, 176>; D.25221 = D.25220 & 2; if (D.25221 == 0) goto ; else goto ; : no_patch = 1; : : : : if (no_patch == 0) goto ; else goto ; : D.25246 = mono_method_same_domain (ji, target_ji); if (D.25246 != 0) goto ; else goto ; : D.25249 = ji->code_start; addr.9 = addr; mono_arch_patch_callsite (D.25249, code, addr.9); : : : } : D.24986 = addr; return D.24986; } finally { addr = {CLOBBER}; variance_used = {CLOBBER}; } } mono_convert_imt_slot_to_vtable_slot (void * * slot, mgreg_t * regs, guint8 * code, struct MonoMethod * method, gboolean lookup_aot, struct MonoMethod * * impl_method, gboolean * need_rgctx_tramp, gboolean * variance_used, void * * aot_addr) { int slot.16; int vt.17; int D.25256; void * * D.25259; struct MonoClass * D.25260; struct MonoClass * D.25261; struct MonoType * D.25264; char * D.25265; struct MonoType * D.25266; char * D.25267; unsigned int D.25268; int D.25269; unsigned char D.25272; unsigned char D.25273; struct MonoGenericInst * D.25275; struct MonoMethod * D.25277; short int D.25278; int D.25279; int D.25280; struct MonoClass * D.25281; struct MonoGenericClass * D.25282; struct MonoGenericInst * D.25285; unsigned char D.25289; unsigned char D.25290; struct MonoDomain * D.25292; int D.25293; int D.25294; void * D.25295; void * D.25296; int D.25300; int D.25301; int D.25304; unsigned char D.25309; unsigned char D.25310; D.25315; _Bool D.25318; long int D.25319; long int D.25320; unsigned int D.25323; int D.25324; unsigned int D.25325; unsigned int D.25326; _Bool D.25329; long int D.25330; long int D.25331; struct MonoObject * this_argument; struct MonoVTable * vt; int displacement; this_argument = mono_arch_get_this_arg_from_call (regs, code); vt = this_argument->vtable; slot.16 = (int) slot; vt.17 = (int) vt; D.25256 = slot.16 - vt.17; displacement = D.25256 /[ex] 4; if (displacement > 0) goto ; else goto ; : D.25259 = slot; return D.25259; : { struct MonoMethod * imt_method; struct MonoMethod * impl; int interface_offset; int imt_slot; imt_method = mono_arch_find_imt_method (regs, code); imt_slot = displacement + 19; D.25260 = vt->klass; D.25261 = imt_method->klass; interface_offset = mono_class_interface_offset_with_variance (D.25260, D.25261, variance_used); if (interface_offset < 0) goto ; else goto ; : D.25260 = vt->klass; D.25264 = &D.25260->byval_arg; D.25265 = mono_type_get_name_full (D.25264, 0); D.25261 = imt_method->klass; D.25266 = &D.25261->byval_arg; D.25267 = mono_type_get_name_full (D.25266, 0); monoeg_g_log (0B, 4, "%s doesn\'t implement interface %s\n", D.25265, D.25267); : goto ; : D.25268 = mono_method_get_imt_slot (imt_method); D.25269 = (int) D.25268; mono_vtable_build_imt_slot (vt, D.25269); D.25272 = BIT_FIELD_REF <*imt_method, 8, 168>; D.25273 = D.25272 & 16; if (D.25273 != 0) goto ; else goto ; : D.25275 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst; if (D.25275 != 0B) goto ; else goto ; : { struct MonoGenericContext context; try { context.class_inst = 0B; context.method_inst = 0B; D.25260 = vt->klass; D.25277 = mono_method_get_declaring_generic_method (imt_method); D.25278 = D.25277->slot; D.25279 = (int) D.25278; D.25280 = D.25279 + interface_offset; impl = mono_class_get_vtable_entry (D.25260, D.25280); D.25281 = impl->klass; D.25282 = D.25281->generic_class; if (D.25282 != 0B) goto ; else goto ; : D.25281 = impl->klass; D.25282 = D.25281->generic_class; D.25285 = D.25282->context.class_inst; context.class_inst = D.25285; : D.25275 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst; context.method_inst = D.25275; impl = mono_class_inflate_generic_method (impl, &context); } finally { context = {CLOBBER}; } } goto ; : if (lookup_aot != 0) goto ; else goto ; : D.25260 = vt->klass; D.25289 = BIT_FIELD_REF <*D.25260, 8, 160>; D.25290 = D.25289 & 8; if (D.25290 == 0) goto ; else goto ; : D.25292 = mono_domain_get (); D.25293 = mono_method_get_vtable_slot (imt_method); D.25294 = D.25293 + interface_offset; D.25295 = mono_aot_get_method_from_vt_slot (D.25292, vt, D.25294); *aot_addr = D.25295; goto ; : *aot_addr = 0B; : D.25296 = *aot_addr; if (D.25296 != 0B) goto ; else goto ; : impl = 0B; goto ; : D.25260 = vt->klass; D.25300 = mono_method_get_vtable_slot (imt_method); D.25301 = D.25300 + interface_offset; impl = mono_class_get_vtable_entry (D.25260, D.25301); : : if (impl != 0B) goto ; else goto ; : D.25304 = mono_method_needs_static_rgctx_invoke (impl, 0); if (D.25304 != 0) goto ; else goto ; : *need_rgctx_tramp = 1; : : if (impl != 0B) goto ; else goto ; : D.25309 = BIT_FIELD_REF <*impl, 8, 160>; D.25310 = D.25309 & 124; if (D.25310 == 28) goto ; else goto ; : { struct WrapperInfo * info; info = mono_marshal_get_wrapper_info (impl); if (info != 0B) goto ; else goto ; : D.25315 = info->subtype; if (D.25315 == 21) goto ; else goto ; : *need_rgctx_tramp = 1; : : } : : *impl_method = impl; D.25318 = imt_slot > 18; D.25319 = (long int) D.25318; D.25320 = __builtin_expect (D.25319, 0); if (D.25320 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 223, "imt_slot < MONO_IMT_SIZE"); : D.25323 = vt->imt_collisions_bitmap; D.25324 = 1 << imt_slot; D.25325 = (unsigned int) D.25324; D.25326 = D.25323 & D.25325; if (D.25326 != 0) goto ; else goto ; : { int slot; int vtable_offset; void * * vtable_slot; slot = mono_method_get_vtable_index (imt_method); D.25329 = slot == -1; D.25330 = (long int) D.25329; D.25331 = __builtin_expect (D.25330, 0); if (D.25331 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 229, "slot != -1"); : vtable_offset = interface_offset + slot; vtable_slot = &vt->vtable[vtable_offset]; D.25259 = vtable_slot; return D.25259; } : D.25259 = slot; return D.25259; } } is_generic_method_definition (struct MonoMethod * m) { unsigned char D.25335; unsigned char D.25336; gboolean D.25339; unsigned char D.25340; struct MonoGenericInst * D.25343; struct MonoMethod * D.25346; struct MonoGenericContainer * D.25347; struct MonoGenericInst * D.25348; struct MonoGenericContext * context; D.25335 = BIT_FIELD_REF <*m, 8, 168>; D.25336 = D.25335 & 8; if (D.25336 != 0) goto ; else goto ; : D.25339 = 1; return D.25339; : D.25335 = BIT_FIELD_REF <*m, 8, 168>; D.25340 = D.25335 & 16; if (D.25340 == 0) goto ; else goto ; : D.25339 = 0; return D.25339; : context = mono_method_get_context (m); D.25343 = context->method_inst; if (D.25343 == 0B) goto ; else goto ; : D.25339 = 0; return D.25339; : D.25343 = context->method_inst; D.25346 = MEM[(struct MonoMethodInflated *)m].declaring; D.25347 = mono_method_get_generic_container (D.25346); D.25348 = D.25347->context.method_inst; if (D.25343 == D.25348) goto ; else goto ; : D.25339 = 1; return D.25339; : D.25339 = 0; return D.25339; } mono_generic_virtual_remoting_trampoline (mgreg_t * regs, guint8 * code, struct MonoMethod * m, guint8 * tramp) { unsigned int trampoline_calls.18; unsigned int trampoline_calls.19; unsigned char D.25354; unsigned char D.25355; _Bool D.25356; long int D.25357; long int D.25358; unsigned char D.25361; struct MonoClass * D.25365; struct MonoGenericClass * D.25366; struct MonoGenericInst * D.25369; struct MonoGenericContainer * D.25371; _Bool D.25372; long int D.25373; long int D.25374; unsigned char D.25377; unsigned char D.25378; struct MonoGenericInst * D.25381; _Bool D.25382; long int D.25383; long int D.25384; void * D.25387; struct MonoGenericContext context; struct MonoMethod * imt_method; struct MonoMethod * declaring; void * addr; try { context.class_inst = 0B; context.method_inst = 0B; trampoline_calls.18 = trampoline_calls; trampoline_calls.19 = trampoline_calls.18 + 1; trampoline_calls = trampoline_calls.19; D.25354 = BIT_FIELD_REF <*m, 8, 168>; D.25355 = D.25354 & 8; D.25356 = D.25355 == 0; D.25357 = (long int) D.25356; D.25358 = __builtin_expect (D.25357, 0); if (D.25358 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 786, "m->is_generic"); : D.25354 = BIT_FIELD_REF <*m, 8, 168>; D.25361 = D.25354 & 16; if (D.25361 != 0) goto ; else goto ; : declaring = mono_method_get_declaring_generic_method (m); goto ; : declaring = m; : D.25365 = m->klass; D.25366 = D.25365->generic_class; if (D.25366 != 0B) goto ; else goto ; : D.25365 = m->klass; D.25366 = D.25365->generic_class; D.25369 = D.25366->context.class_inst; context.class_inst = D.25369; goto ; : D.25365 = m->klass; D.25371 = D.25365->generic_container; D.25372 = D.25371 != 0B; D.25373 = (long int) D.25372; D.25374 = __builtin_expect (D.25373, 0); if (D.25374 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 796, "!m->klass->generic_container"); : : imt_method = mono_arch_find_imt_method (regs, code); D.25377 = BIT_FIELD_REF <*imt_method, 8, 168>; D.25378 = D.25377 & 16; if (D.25378 != 0) goto ; else goto ; : D.25381 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst; context.method_inst = D.25381; : m = mono_class_inflate_generic_method (declaring, &context); m = mono_marshal_get_remoting_invoke_with_check (m); addr = mono_compile_method (m); D.25382 = addr == 0B; D.25383 = (long int) D.25382; D.25384 = __builtin_expect (D.25383, 0); if (D.25384 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 807, "addr"); : D.25387 = addr; return D.25387; } finally { context = {CLOBBER}; } } mono_aot_trampoline (mgreg_t * regs, guint8 * code, guint8 * token_info, guint8 * tramp) { unsigned int trampoline_calls.20; unsigned int trampoline_calls.21; struct MonoDomain * D.25392; _Bool D.25395; long int D.25396; long int D.25397; void * D.25400; struct MonoDomain * D.25401; _Bool D.25402; long int D.25403; long int D.25404; struct MonoImage * image; guint32 token; struct MonoMethod * method; void * addr; guint8 * plt_entry; method = 0B; trampoline_calls.20 = trampoline_calls; trampoline_calls.21 = trampoline_calls.20 + 1; trampoline_calls = trampoline_calls.21; image = MEM[(void * *)token_info]; token_info = token_info + 4; token = MEM[(guint32 *)token_info]; D.25392 = mono_domain_get (); addr = mono_aot_get_method_from_token (D.25392, image, token); if (addr == 0B) goto ; else goto ; : method = mono_get_method (image, token, 0B); D.25395 = method == 0B; D.25396 = (long int) D.25395; D.25397 = __builtin_expect (D.25396, 0); if (D.25397 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 839, "method"); : D.25400 = mono_magic_trampoline (regs, code, method, tramp); return D.25400; : D.25401 = mono_domain_get (); addr = mono_create_ftnptr (D.25401, addr); plt_entry = mono_aot_get_plt_entry (code); D.25402 = plt_entry == 0B; D.25403 = (long int) D.25402; D.25404 = __builtin_expect (D.25403, 0); if (D.25404 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 849, "plt_entry"); : mono_aot_patch_plt_entry (plt_entry, 0B, regs, addr); D.25400 = addr; return D.25400; } mono_aot_plt_trampoline (mgreg_t * regs, guint8 * code, guint8 * aot_module, guint8 * tramp) { unsigned int trampoline_calls.22; unsigned int trampoline_calls.23; struct MonoLoaderError * D.25412; struct MonoLoaderError * D.25415; struct MonoException * D.25416; _Bool D.25417; long int D.25418; long int D.25419; void * D.25422; guint32 plt_info_offset; void * res; plt_info_offset = mono_aot_get_plt_info_offset (regs, code); trampoline_calls.22 = trampoline_calls; trampoline_calls.23 = trampoline_calls.22 + 1; trampoline_calls = trampoline_calls.23; res = mono_aot_plt_resolve (aot_module, plt_info_offset, code); if (res == 0B) goto ; else goto ; : D.25412 = mono_loader_get_last_error (); if (D.25412 != 0B) goto ; else goto ; : D.25415 = mono_loader_get_last_error (); D.25416 = mono_loader_error_prepare_exception (D.25415); mono_raise_exception (D.25416); : D.25417 = res == 0B; D.25418 = (long int) D.25417; D.25419 = __builtin_expect (D.25418, 0); if (D.25419 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 875, "res"); : : D.25422 = res; return D.25422; } mono_class_init_trampoline (mgreg_t * regs, guint8 * code, struct MonoVTable * vtable, guint8 * tramp) { unsigned int trampoline_calls.24; unsigned int trampoline_calls.25; unsigned char D.25426; unsigned char D.25427; guint8 * plt_entry; plt_entry = mono_aot_get_plt_entry (code); trampoline_calls.24 = trampoline_calls; trampoline_calls.25 = trampoline_calls.24 + 1; trampoline_calls = trampoline_calls.25; mono_runtime_class_init (vtable); D.25426 = BIT_FIELD_REF <*vtable, 8, 184>; D.25427 = D.25426 & 2; if (D.25427 != 0) goto ; else goto ; : if (plt_entry != 0B) goto ; else goto ; : mono_arch_nullify_plt_entry (plt_entry, regs); goto ; : mono_arch_nullify_class_init_trampoline (code, regs); : : } mono_generic_class_init_trampoline (mgreg_t * regs, guint8 * code, struct MonoVTable * vtable, guint8 * tramp) { unsigned int trampoline_calls.26; unsigned int trampoline_calls.27; trampoline_calls.26 = trampoline_calls; trampoline_calls.27 = trampoline_calls.26 + 1; trampoline_calls = trampoline_calls.27; mono_runtime_class_init (vtable); } mono_monitor_enter_trampoline (mgreg_t * regs, guint8 * code, struct MonoObject * obj, guint8 * tramp) { mono_monitor_enter (obj); } mono_monitor_exit_trampoline (mgreg_t * regs, guint8 * code, struct MonoObject * obj, guint8 * tramp) { mono_monitor_exit (obj); } mono_delegate_trampoline (mgreg_t * regs, guint8 * code, void * * tramp_data, guint8 * tramp) { unsigned int trampoline_calls.28; unsigned int trampoline_calls.29; struct MonoMethod * D.25437; struct MonoObject * D.25442; struct MonoVTable * D.25444; struct MonoClass * D.25445; struct MonoClass * D.25446; struct MonoRemoteClass * D.25448; struct MonoClass * D.25449; struct MonoClass * D.25450; unsigned char D.25453; unsigned char D.25454; unsigned char D.25459; unsigned char D.25460; struct MonoClass * D.25463; unsigned char D.25464; unsigned char D.25465; int mono_aot_only.30; void * D.25473; void * D.25474; int iftmp.31; short unsigned int D.25488; unsigned int D.25489; unsigned int D.25490; unsigned int D.25493; unsigned int D.25494; short unsigned int D.25499; int D.25500; int D.25501; int D.25506; _Bool D.25509; _Bool D.25510; _Bool D.25511; guint8 * * D.25517; guint8 * D.25519; void * D.25528; struct MonoMulticastDelegate * D.25529; _Bool D.25530; int D.25531; int D.25537; int D.25538; struct MonoMethodSignature * D.25540; short unsigned int D.25541; int D.25542; struct MonoMethodSignature * D.25543; short unsigned int D.25544; int D.25545; int D.25546; guint8 * iftmp.32; void * D.25554; void * D.25555; int D.25556; void * D.25557; struct MonoDomain * domain; struct MonoDelegate * delegate; struct MonoJitInfo * ji; struct MonoMethod * m; struct MonoMethod * method; gboolean multicast; gboolean callvirt; gboolean need_rgctx_tramp; gboolean need_unbox_tramp; gboolean enable_caching; struct MonoMethod * invoke; guint8 * impl_this; guint8 * impl_nothis; struct MonoError err; struct MonoMethodSignature * sig; void * addr; void * compiled_method; try { domain = mono_domain_get (); method = 0B; callvirt = 0; need_rgctx_tramp = 0; need_unbox_tramp = 0; enable_caching = 1; invoke = *tramp_data; impl_this = MEM[(void * *)tramp_data + 4B]; impl_nothis = MEM[(void * *)tramp_data + 8B]; trampoline_calls.28 = trampoline_calls; trampoline_calls.29 = trampoline_calls.28 + 1; trampoline_calls = trampoline_calls.29; delegate = mono_arch_get_this_arg_from_call (regs, code); D.25437 = delegate->method; if (D.25437 != 0B) goto ; else goto ; : method = delegate->method; D.25442 = delegate->target; if (D.25442 != 0B) goto ; else goto ; : D.25442 = delegate->target; D.25444 = D.25442->vtable; D.25445 = D.25444->klass; D.25446 = mono_defaults.transparent_proxy_class; if (D.25445 == D.25446) goto ; else goto ; : D.25442 = delegate->target; D.25448 = MEM[(struct MonoTransparentProxy *)D.25442].remote_class; D.25449 = D.25448->proxy_class; D.25450 = mono_class_get_com_object_class (); if (D.25449 != D.25450) goto ; else goto ; : D.25442 = delegate->target; D.25448 = MEM[(struct MonoTransparentProxy *)D.25442].remote_class; D.25449 = D.25448->proxy_class; D.25453 = BIT_FIELD_REF <*D.25449, 8, 184>; D.25454 = D.25453 & 64; if (D.25454 == 0) goto ; else goto ; : method = mono_marshal_get_remoting_invoke (method); : : goto ; : mono_error_init (&err); sig = mono_method_signature_checked (method, &err); if (sig == 0B) goto ; else goto ; : mono_error_raise_exception (&err); : D.25459 = BIT_FIELD_REF <*sig, 8, 80>; D.25460 = D.25459 & 64; if (D.25460 != 0) goto ; else goto ; : D.25463 = method->klass; D.25464 = BIT_FIELD_REF <*D.25463, 8, 160>; D.25465 = D.25464 & 8; if (D.25465 != 0) goto ; else goto ; : mono_aot_only.30 = mono_aot_only; if (mono_aot_only.30 != 0) goto ; else goto ; : need_unbox_tramp = 1; goto ; : method = mono_marshal_get_unbox_wrapper (method); : : : : goto ; : D.25473 = delegate->method_ptr; D.25474 = mono_get_addr_from_ftnptr (D.25473); ji = mono_jit_info_table_find (domain, D.25474); if (ji != 0B) goto ; else goto ; : method = jinfo_get_method (ji); : : if (method != 0B) goto ; else goto ; : mono_error_init (&err); sig = mono_method_signature_checked (method, &err); if (sig == 0B) goto ; else goto ; : mono_error_raise_exception (&err); : D.25442 = delegate->target; if (D.25442 == 0B) goto ; else goto ; : D.25459 = BIT_FIELD_REF <*sig, 8, 80>; D.25460 = D.25459 & 64; if (D.25460 != 0) goto ; else goto ; : iftmp.31 = 1; goto ; : iftmp.31 = 0; : callvirt = iftmp.31; D.25442 = delegate->target; if (D.25442 != 0B) goto ; else goto ; : D.25488 = method->flags; D.25489 = (unsigned int) D.25488; D.25490 = D.25489 & 1088; if (D.25490 == 1088) goto ; else goto ; : D.25463 = method->klass; D.25493 = D.25463->flags; D.25494 = D.25493 & 128; if (D.25494 != 0) goto ; else goto ; : D.25442 = delegate->target; method = mono_object_get_virtual_method (D.25442, method); enable_caching = 0; : : : : if (method != 0B) goto ; else goto ; : D.25499 = method->iflags; D.25500 = (int) D.25499; D.25501 = D.25500 & 32; if (D.25501 != 0) goto ; else goto ; : method = mono_marshal_get_synchronized_wrapper (method); : : if (method != 0B) goto ; else goto ; : D.25506 = mono_method_needs_static_rgctx_invoke (method, 0); if (D.25506 != 0) goto ; else goto ; : need_rgctx_tramp = 1; : : D.25509 = method != 0B; D.25510 = callvirt == 0; D.25511 = D.25509 & D.25510; if (D.25511 != 0) goto ; else goto ; : if (enable_caching != 0) goto ; else goto ; : D.25517 = delegate->method_code; if (D.25517 != 0B) goto ; else goto ; : D.25517 = delegate->method_code; D.25519 = *D.25517; if (D.25519 != 0B) goto ; else goto ; : D.25517 = delegate->method_code; D.25519 = *D.25517; delegate->method_ptr = D.25519; goto ; : addr = mono_compile_method (method); compiled_method = addr; addr = mini_add_method_trampoline (0B, method, compiled_method, need_rgctx_tramp, need_unbox_tramp); delegate->method_ptr = addr; if (enable_caching != 0) goto ; else goto ; : D.25517 = delegate->method_code; if (D.25517 != 0B) goto ; else goto ; : D.25517 = delegate->method_code; D.25473 = delegate->method_ptr; *D.25517 = D.25473; : : : goto ; : if (need_rgctx_tramp != 0) goto ; else goto ; : D.25473 = delegate->method_ptr; D.25528 = mono_create_static_rgctx_trampoline (method, D.25473); delegate->method_ptr = D.25528; : : D.25529 = MEM[(struct MonoMulticastDelegate *)delegate].prev; D.25530 = D.25529 != 0B; multicast = (gboolean) D.25530; D.25531 = multicast | callvirt; if (D.25531 == 0) goto ; else goto ; : if (method != 0B) goto ; else goto ; : D.25488 = method->flags; D.25537 = (int) D.25488; D.25538 = D.25537 & 16; if (D.25538 != 0) goto ; else goto ; : D.25540 = mono_method_signature (method); D.25541 = D.25540->param_count; D.25542 = (int) D.25541; D.25543 = mono_method_signature (invoke); D.25544 = D.25543->param_count; D.25545 = (int) D.25544; D.25546 = D.25545 + 1; if (D.25542 == D.25546) goto ; else goto ; : code = impl_this; goto ; : D.25442 = delegate->target; if (D.25442 != 0B) goto ; else goto ; : iftmp.32 = impl_this; goto ; : iftmp.32 = impl_nothis; : code = iftmp.32; : if (code != 0B) goto ; else goto ; : D.25554 = mono_get_addr_from_ftnptr (code); delegate->invoke_impl = D.25554; D.25555 = code; return D.25555; : : m = mono_marshal_get_delegate_invoke (invoke, delegate); code = mono_compile_method (m); D.25556 = mono_method_needs_static_rgctx_invoke (m, 0); code = mini_add_method_trampoline (0B, m, code, D.25556, 0); D.25557 = mono_get_addr_from_ftnptr (code); delegate->invoke_impl = D.25557; D.25555 = code; return D.25555; } finally { err = {CLOBBER}; } } mono_get_trampoline_func (MonoTrampolineType tramp_type) { const void * D.25560; switch (tramp_type) , case 0: , case 1: , case 2: , case 3: , case 4: , case 5: , case 6: , case 7: , case 8: , case 9: , case 10: , case 11: , case 12: > : : D.25560 = mono_magic_trampoline; return D.25560; : D.25560 = mono_class_init_trampoline; return D.25560; : D.25560 = mono_generic_class_init_trampoline; return D.25560; : D.25560 = mono_rgctx_lazy_fetch_trampoline; return D.25560; : D.25560 = mono_aot_trampoline; return D.25560; : D.25560 = mono_aot_plt_trampoline; return D.25560; : D.25560 = mono_delegate_trampoline; return D.25560; : D.25560 = mono_altstack_restore_prot; return D.25560; : D.25560 = mono_generic_virtual_remoting_trampoline; return D.25560; : D.25560 = mono_monitor_enter_trampoline; return D.25560; : D.25560 = mono_monitor_exit_trampoline; return D.25560; : D.25560 = mono_vcall_trampoline; return D.25560; : monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1200); D.25560 = 0B; return D.25560; } mono_vcall_trampoline (mgreg_t * regs, guint8 * code, int slot, guint8 * tramp) { unsigned int trampoline_calls.33; unsigned int trampoline_calls.34; _Bool D.25564; long int D.25565; long int D.25566; struct MonoDomain * D.25571; struct MonoClass * D.25574; unsigned char D.25575; unsigned char D.25576; struct MonoDomain * D.25579; int D.25580; void * D.25583; struct MonoDomain * D.25584; unsigned int slot.35; unsigned int D.25587; struct MonoObject * this; struct MonoVTable * vt; void * * vtable_slot; struct MonoMethod * m; gboolean need_rgctx_tramp; void * addr; need_rgctx_tramp = 0; trampoline_calls.33 = trampoline_calls; trampoline_calls.34 = trampoline_calls.33 + 1; trampoline_calls = trampoline_calls.34; this = mono_arch_get_this_arg_from_call (regs, code); D.25564 = this == 0B; D.25565 = (long int) D.25564; D.25566 = __builtin_expect (D.25565, 0); if (D.25566 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 732, "this"); : vt = this->vtable; if (slot >= 0) goto ; else goto ; : vtable_slot = &vt->vtable[slot]; D.25571 = mono_domain_get (); addr = mono_aot_get_method_from_vt_slot (D.25571, vt, slot); if (addr != 0B) goto ; else goto ; : D.25574 = vt->klass; D.25575 = BIT_FIELD_REF <*D.25574, 8, 160>; D.25576 = D.25575 & 8; if (D.25576 == 0) goto ; else goto ; : D.25579 = mono_domain_get (); D.25580 = mono_domain_owns_vtable_slot (D.25579, vtable_slot); if (D.25580 != 0) goto ; else goto ; : *vtable_slot = addr; : D.25584 = mono_domain_get (); D.25583 = mono_create_ftnptr (D.25584, addr); return D.25583; : : D.25574 = vt->klass; m = mono_class_get_vtable_entry (D.25574, slot); need_rgctx_tramp = mono_method_needs_static_rgctx_invoke (m, 0); goto ; : slot.35 = (unsigned int) slot; D.25587 = slot.35 * 4; vtable_slot = vt + D.25587; m = 0B; need_rgctx_tramp = 0; : D.25583 = common_call_trampoline (regs, code, m, tramp, vt, vtable_slot, need_rgctx_tramp); return D.25583; } mono_rgctx_lazy_fetch_trampoline (mgreg_t * regs, guint8 * code, void * data, guint8 * tramp) { int D.25589; signed int slot.36; _Bool D.25591; unsigned int trampoline_calls.37; unsigned int trampoline_calls.38; int inited.39; int num_lookups.40; int num_lookups.41; void * D.25601; static gboolean inited = 0; static int num_lookups = 0; guint32 slot; mgreg_t * r; void * arg; guint32 index; gboolean mrgctx; slot = (guint32) data; r = regs; D.25589 = *r; arg = (void *) D.25589; index = slot & 2147483647; slot.36 = (signed int) slot; D.25591 = slot.36 < 0; mrgctx = (gboolean) D.25591; trampoline_calls.37 = trampoline_calls; trampoline_calls.38 = trampoline_calls.37 + 1; trampoline_calls = trampoline_calls.38; inited.39 = inited; if (inited.39 == 0) goto ; else goto ; : mono_counters_register ("RGCTX unmanaged lookups", 2048, &num_lookups); inited = 1; : num_lookups.40 = num_lookups; num_lookups.41 = num_lookups.40 + 1; num_lookups = num_lookups.41; if (mrgctx != 0) goto ; else goto ; : D.25601 = mono_method_fill_runtime_generic_context (arg, code, index); return D.25601; : D.25601 = mono_class_fill_runtime_generic_context (arg, code, index); return D.25601; } mono_trampolines_init () { int mono_aot_only.42; guchar * D.25606; guchar * D.25607; guchar * D.25608; guchar * D.25609; guchar * D.25610; guchar * D.25611; guchar * D.25612; guchar * D.25613; guchar * D.25614; guchar * D.25615; guchar * D.25616; guchar * D.25617; guchar * D.25618; InitializeCriticalSection (&trampolines_mutex); mono_aot_only.42 = mono_aot_only; if (mono_aot_only.42 != 0) goto ; else goto ; : return; : D.25606 = create_trampoline_code (0); mono_trampoline_code[0] = D.25606; D.25607 = create_trampoline_code (1); mono_trampoline_code[1] = D.25607; D.25608 = create_trampoline_code (2); mono_trampoline_code[2] = D.25608; D.25609 = create_trampoline_code (3); mono_trampoline_code[3] = D.25609; D.25610 = create_trampoline_code (4); mono_trampoline_code[4] = D.25610; D.25611 = create_trampoline_code (5); mono_trampoline_code[5] = D.25611; D.25612 = create_trampoline_code (6); mono_trampoline_code[6] = D.25612; D.25613 = create_trampoline_code (7); mono_trampoline_code[7] = D.25613; D.25614 = create_trampoline_code (8); mono_trampoline_code[8] = D.25614; D.25615 = create_trampoline_code (9); mono_trampoline_code[9] = D.25615; D.25616 = create_trampoline_code (10); mono_trampoline_code[10] = D.25616; D.25617 = create_trampoline_code (11); mono_trampoline_code[11] = D.25617; D.25618 = create_trampoline_code (12); mono_trampoline_code[12] = D.25618; mono_counters_register ("Calls to trampolines", 256, &trampoline_calls); mono_counters_register ("JIT trampolines", 256, &jit_trampolines); mono_counters_register ("Unbox trampolines", 256, &unbox_trampolines); mono_counters_register ("Static rgctx trampolines", 256, &static_rgctx_trampolines); } create_trampoline_code (MonoTrampolineType tramp_type) { struct MonoTrampInfo * info.43; guchar * D.25621; struct MonoTrampInfo * info; guchar * code; try { code = mono_arch_create_generic_trampoline (tramp_type, &info, 0); info.43 = info; mono_tramp_info_register (info.43); D.25621 = code; return D.25621; } finally { info = {CLOBBER}; } } mono_trampolines_cleanup () { struct GHashTable * class_init_hash_addr.44; struct GHashTable * rgctx_lazy_fetch_trampoline_hash.45; struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.46; class_init_hash_addr.44 = class_init_hash_addr; if (class_init_hash_addr.44 != 0B) goto ; else goto ; : class_init_hash_addr.44 = class_init_hash_addr; monoeg_g_hash_table_destroy (class_init_hash_addr.44); : rgctx_lazy_fetch_trampoline_hash.45 = rgctx_lazy_fetch_trampoline_hash; if (rgctx_lazy_fetch_trampoline_hash.45 != 0B) goto ; else goto ; : rgctx_lazy_fetch_trampoline_hash.45 = rgctx_lazy_fetch_trampoline_hash; monoeg_g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash.45); : rgctx_lazy_fetch_trampoline_hash_addr.46 = rgctx_lazy_fetch_trampoline_hash_addr; if (rgctx_lazy_fetch_trampoline_hash_addr.46 != 0B) goto ; else goto ; : rgctx_lazy_fetch_trampoline_hash_addr.46 = rgctx_lazy_fetch_trampoline_hash_addr; monoeg_g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash_addr.46); : DeleteCriticalSection (&trampolines_mutex); } mono_get_trampoline_code (MonoTrampolineType tramp_type) { guint8 * D.25633; _Bool D.25634; long int D.25635; long int D.25636; guint8 * D.25639; D.25633 = mono_trampoline_code[tramp_type]; D.25634 = D.25633 == 0B; D.25635 = (long int) D.25634; D.25636 = __builtin_expect (D.25635, 0); if (D.25636 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1271, "mono_trampoline_code [tramp_type]"); : D.25639 = mono_trampoline_code[tramp_type]; return D.25639; } mono_create_specific_trampoline (void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len) { int mono_aot_only.47; void * D.25644; struct MonoImage * D.25645; mono_aot_only.47 = mono_aot_only; if (mono_aot_only.47 != 0) goto ; else goto ; : D.25645 = mono_defaults.corlib; D.25644 = mono_aot_create_specific_trampoline (D.25645, arg1, tramp_type, domain, code_len); return D.25644; : D.25644 = mono_arch_create_specific_trampoline (arg1, tramp_type, domain, code_len); return D.25644; } mono_create_class_init_trampoline (struct MonoVTable * vtable) { struct MonoClass * D.25647; struct MonoGenericContainer * D.25648; _Bool D.25649; long int D.25650; long int D.25651; union mono_mutex_t * D.25654; _Bool D.25657; long int D.25658; long int D.25659; void * D.25662; struct GHashTable * D.25663; _Bool D.25666; long int D.25667; long int D.25668; void * D.25673; _Bool D.25676; long int D.25677; long int D.25678; _Bool D.25683; long int D.25684; long int D.25685; _Bool D.25690; long int D.25691; long int D.25692; struct GHashTable * class_init_hash_addr.48; struct GHashTable * class_init_hash_addr.49; _Bool D.25701; long int D.25702; long int D.25703; void * code; void * ptr; struct MonoDomain * domain; domain = vtable->domain; D.25647 = vtable->klass; D.25648 = D.25647->generic_container; D.25649 = D.25648 != 0B; D.25650 = (long int) D.25649; D.25651 = __builtin_expect (D.25650, 0); if (D.25651 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1291, "!vtable->klass->generic_container"); : { int ret; D.25654 = &domain->lock.mutex; ret = pthread_mutex_lock (D.25654); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25657 = ret != 0; D.25658 = (long int) D.25657; D.25659 = __builtin_expect (D.25658, 0); if (D.25659 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1294, "ret == 0"); : } D.25662 = domain->runtime_info; D.25663 = MEM[(struct MonoJitDomainInfo *)D.25662].class_init_trampoline_hash; ptr = monoeg_g_hash_table_lookup (D.25663, vtable); { int ret; D.25654 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.25654); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25666 = ret != 0; D.25667 = (long int) D.25666; D.25668 = __builtin_expect (D.25667, 0); if (D.25668 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1298, "ret == 0"); : } if (ptr != 0B) goto ; else goto ; : D.25673 = ptr; return D.25673; : code = mono_create_specific_trampoline (vtable, 2, domain, 0B); ptr = mono_create_ftnptr (domain, code); { int ret; D.25654 = &domain->lock.mutex; ret = pthread_mutex_lock (D.25654); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25676 = ret != 0; D.25677 = (long int) D.25676; D.25678 = __builtin_expect (D.25677, 0); if (D.25678 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1307, "ret == 0"); : } D.25662 = domain->runtime_info; D.25663 = MEM[(struct MonoJitDomainInfo *)D.25662].class_init_trampoline_hash; monoeg_g_hash_table_insert_replace (D.25663, vtable, ptr, 0); { int ret; D.25654 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.25654); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25683 = ret != 0; D.25684 = (long int) D.25683; D.25685 = __builtin_expect (D.25684, 0); if (D.25685 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1310, "ret == 0"); : } { int ret; ret = pthread_mutex_lock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25690 = ret != 0; D.25691 = (long int) D.25690; D.25692 = __builtin_expect (D.25691, 0); if (D.25692 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1312, "ret == 0"); : } class_init_hash_addr.48 = class_init_hash_addr; if (class_init_hash_addr.48 == 0B) goto ; else goto ; : class_init_hash_addr.49 = monoeg_g_hash_table_new (0B, 0B); class_init_hash_addr = class_init_hash_addr.49; : class_init_hash_addr.48 = class_init_hash_addr; monoeg_g_hash_table_insert_replace (class_init_hash_addr.48, ptr, vtable, 0); { int ret; ret = pthread_mutex_unlock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25701 = ret != 0; D.25702 = (long int) D.25701; D.25703 = __builtin_expect (D.25702, 0); if (D.25703 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1316, "ret == 0"); : } D.25673 = ptr; return D.25673; } mono_create_generic_class_init_trampoline () { _Bool D.25709; long int D.25710; long int D.25711; void * code.50; int mono_aot_only.51; void * D.25720; void * code.52; void * code.53; struct MonoTrampInfo * info.54; _Bool D.25727; long int D.25728; long int D.25729; void * D.25732; static void * code; struct MonoTrampInfo * info; try { { int ret; ret = pthread_mutex_lock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25709 = ret != 0; D.25710 = (long int) D.25709; D.25711 = __builtin_expect (D.25710, 0); if (D.25711 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1328, "ret == 0"); : } code.50 = code; if (code.50 == 0B) goto ; else goto ; : mono_aot_only.51 = mono_aot_only; if (mono_aot_only.51 != 0) goto ; else goto ; : D.25720 = mono_aot_get_trampoline ("generic_class_init_trampoline"); code.52 = mono_get_addr_from_ftnptr (D.25720); code = code.52; goto ; : code.53 = mono_arch_create_generic_class_init_trampoline (&info, 0); code = code.53; info.54 = info; mono_tramp_info_register (info.54); : : { int ret; ret = pthread_mutex_unlock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25727 = ret != 0; D.25728 = (long int) D.25727; D.25729 = __builtin_expect (D.25728, 0); if (D.25729 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1340, "ret == 0"); : } D.25732 = code; return D.25732; } finally { info = {CLOBBER}; } } mono_create_jump_trampoline (struct MonoDomain * domain, struct MonoMethod * method, gboolean add_sync_wrapper) { struct MonoJitInfo * ji.55; unsigned char D.25738; unsigned char D.25739; short unsigned int D.25742; int D.25743; int D.25744; void * D.25747; union mono_mutex_t * D.25748; _Bool D.25751; long int D.25752; long int D.25753; void * D.25756; struct GHashTable * D.25757; _Bool D.25760; long int D.25761; long int D.25762; struct MonoDomain * D.25767; unsigned int code_size.56; _Bool D.25769; long int D.25770; long int D.25771; void * ji.57; int code_size.58; _Bool D.25778; long int D.25779; long int D.25780; void * D.25783; _Bool D.25786; long int D.25787; long int D.25788; struct MonoJitInfo * ji; void * code; guint32 code_size; try { code_size = 0; code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji); if (code != 0B) goto ; else goto ; : ji.55 = ji; D.25738 = BIT_FIELD_REF <*ji.55, 8, 176>; D.25739 = D.25738 & 2; if (D.25739 == 0) goto ; else goto ; : D.25742 = method->iflags; D.25743 = (int) D.25742; D.25744 = D.25743 & 32; if (D.25744 == 0) goto ; else goto ; : D.25747 = code; return D.25747; : : : { int ret; D.25748 = &domain->lock.mutex; ret = pthread_mutex_lock (D.25748); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25751 = ret != 0; D.25752 = (long int) D.25751; D.25753 = __builtin_expect (D.25752, 0); if (D.25753 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1365, "ret == 0"); : } D.25756 = domain->runtime_info; D.25757 = MEM[(struct MonoJitDomainInfo *)D.25756].jump_trampoline_hash; code = monoeg_g_hash_table_lookup (D.25757, method); { int ret; D.25748 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.25748); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25760 = ret != 0; D.25761 = (long int) D.25760; D.25762 = __builtin_expect (D.25761, 0); if (D.25762 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1367, "ret == 0"); : } if (code != 0B) goto ; else goto ; : D.25747 = code; return D.25747; : D.25767 = mono_domain_get (); code = mono_create_specific_trampoline (method, 1, D.25767, &code_size); code_size.56 = code_size; D.25769 = code_size.56 == 0; D.25770 = (long int) D.25769; D.25771 = __builtin_expect (D.25770, 0); if (D.25771 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1372, "code_size"); : ji.57 = mono_domain_alloc0 (domain, 28); ji = ji.57; ji.55 = ji; ji.55->code_start = code; ji.55 = ji; code_size.56 = code_size; code_size.58 = (int) code_size.56; ji.55->code_size = code_size.58; ji.55 = ji; ji.55->d.method = method; ji.55 = ji; mono_jit_info_table_add (domain, ji.55); { int ret; D.25748 = &domain->lock.mutex; ret = pthread_mutex_lock (D.25748); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25778 = ret != 0; D.25779 = (long int) D.25778; D.25780 = __builtin_expect (D.25779, 0); if (D.25780 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1386, "ret == 0"); : } D.25756 = domain->runtime_info; D.25757 = MEM[(struct MonoJitDomainInfo *)D.25756].jump_trampoline_hash; ji.55 = ji; D.25783 = ji.55->code_start; monoeg_g_hash_table_insert_replace (D.25757, method, D.25783, 0); { int ret; D.25748 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.25748); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25786 = ret != 0; D.25787 = (long int) D.25786; D.25788 = __builtin_expect (D.25787, 0); if (D.25788 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1388, "ret == 0"); : } ji.55 = ji; D.25747 = ji.55->code_start; return D.25747; } finally { ji = {CLOBBER}; code_size = {CLOBBER}; } } mono_create_jit_trampoline_in_domain (struct MonoDomain * domain, struct MonoMethod * method) { int mono_aot_only.59; void * D.25798; union mono_mutex_t * D.25799; _Bool D.25802; long int D.25803; long int D.25804; void * D.25807; struct GHashTable * D.25808; _Bool D.25811; long int D.25812; long int D.25813; _Bool D.25820; long int D.25821; long int D.25822; _Bool D.25827; long int D.25828; long int D.25829; unsigned int jit_trampolines.60; unsigned int jit_trampolines.61; void * tramp; mono_aot_only.59 = mono_aot_only; if (mono_aot_only.59 != 0) goto ; else goto ; : { void * code; code = mono_jit_find_compiled_method (domain, method); if (code != 0B) goto ; else goto ; : D.25798 = code; return D.25798; : } : { int ret; D.25799 = &domain->lock.mutex; ret = pthread_mutex_lock (D.25799); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25802 = ret != 0; D.25803 = (long int) D.25802; D.25804 = __builtin_expect (D.25803, 0); if (D.25804 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1406, "ret == 0"); : } D.25807 = domain->runtime_info; D.25808 = MEM[(struct MonoJitDomainInfo *)D.25807].jit_trampoline_hash; tramp = monoeg_g_hash_table_lookup (D.25808, method); { int ret; D.25799 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.25799); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25811 = ret != 0; D.25812 = (long int) D.25811; D.25813 = __builtin_expect (D.25812, 0); if (D.25813 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1408, "ret == 0"); : } if (tramp != 0B) goto ; else goto ; : D.25798 = tramp; return D.25798; : tramp = mono_create_specific_trampoline (method, 0, domain, 0B); { int ret; D.25799 = &domain->lock.mutex; ret = pthread_mutex_lock (D.25799); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25820 = ret != 0; D.25821 = (long int) D.25820; D.25822 = __builtin_expect (D.25821, 0); if (D.25822 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1414, "ret == 0"); : } D.25807 = domain->runtime_info; D.25808 = MEM[(struct MonoJitDomainInfo *)D.25807].jit_trampoline_hash; monoeg_g_hash_table_insert_replace (D.25808, method, tramp, 0); { int ret; D.25799 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.25799); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25827 = ret != 0; D.25828 = (long int) D.25827; D.25829 = __builtin_expect (D.25828, 0); if (D.25829 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1416, "ret == 0"); : } jit_trampolines.60 = jit_trampolines; jit_trampolines.61 = jit_trampolines.60 + 1; jit_trampolines = jit_trampolines.61; D.25798 = tramp; return D.25798; } mono_create_jit_trampoline (struct MonoMethod * method) { void * D.25835; struct MonoDomain * D.25836; D.25836 = mono_domain_get (); D.25835 = mono_create_jit_trampoline_in_domain (D.25836, method); return D.25835; } mono_create_jit_trampoline_from_token (struct MonoImage * image, guint32 token) { unsigned int jit_trampolines.62; unsigned int jit_trampolines.63; void * D.25840; void * tramp; struct MonoDomain * domain; guint8 * buf; guint8 * start; domain = mono_domain_get (); start = mono_domain_alloc0 (domain, 8); buf = start; MEM[(void * *)buf] = image; buf = buf + 4; MEM[(guint32 *)buf] = token; tramp = mono_create_specific_trampoline (start, 5, domain, 0B); jit_trampolines.62 = jit_trampolines; jit_trampolines.63 = jit_trampolines.62 + 1; jit_trampolines = jit_trampolines.63; D.25840 = tramp; return D.25840; } mono_create_delegate_trampoline (struct MonoDomain * domain, struct MonoClass * klass) { union mono_mutex_t * D.25842; _Bool D.25845; long int D.25846; long int D.25847; void * D.25850; struct GHashTable * D.25851; _Bool D.25854; long int D.25855; long int D.25856; void * D.25861; _Bool D.25862; long int D.25863; long int D.25864; void * * D.25867; struct MonoMethodSignature * D.25868; void * D.25869; void * * D.25870; struct MonoMethodSignature * D.25871; void * D.25872; unsigned int code_size.64; _Bool D.25874; long int D.25875; long int D.25876; _Bool D.25881; long int D.25882; long int D.25883; _Bool D.25888; long int D.25889; long int D.25890; void * ptr; guint32 code_size; void * * tramp_data; struct MonoMethod * invoke; try { code_size = 0; { int ret; D.25842 = &domain->lock.mutex; ret = pthread_mutex_lock (D.25842); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25845 = ret != 0; D.25846 = (long int) D.25845; D.25847 = __builtin_expect (D.25846, 0); if (D.25847 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1459, "ret == 0"); : } D.25850 = domain->runtime_info; D.25851 = MEM[(struct MonoJitDomainInfo *)D.25850].delegate_trampoline_hash; ptr = monoeg_g_hash_table_lookup (D.25851, klass); { int ret; D.25842 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.25842); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25854 = ret != 0; D.25855 = (long int) D.25854; D.25856 = __builtin_expect (D.25855, 0); if (D.25856 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1461, "ret == 0"); : } if (ptr != 0B) goto ; else goto ; : D.25861 = ptr; return D.25861; : invoke = mono_get_delegate_invoke (klass); D.25862 = invoke == 0B; D.25863 = (long int) D.25862; D.25864 = __builtin_expect (D.25863, 0); if (D.25864 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1467, "invoke"); : tramp_data = mono_domain_alloc (domain, 12); *tramp_data = invoke; D.25867 = tramp_data + 4; D.25868 = mono_method_signature (invoke); D.25869 = mono_arch_get_delegate_invoke_impl (D.25868, 1); *D.25867 = D.25869; D.25870 = tramp_data + 8; D.25871 = mono_method_signature (invoke); D.25872 = mono_arch_get_delegate_invoke_impl (D.25871, 0); *D.25870 = D.25872; ptr = mono_create_specific_trampoline (tramp_data, 7, domain, &code_size); code_size.64 = code_size; D.25874 = code_size.64 == 0; D.25875 = (long int) D.25874; D.25876 = __builtin_expect (D.25875, 0); if (D.25876 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1475, "code_size"); : { int ret; D.25842 = &domain->lock.mutex; ret = pthread_mutex_lock (D.25842); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25881 = ret != 0; D.25882 = (long int) D.25881; D.25883 = __builtin_expect (D.25882, 0); if (D.25883 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1478, "ret == 0"); : } D.25850 = domain->runtime_info; D.25851 = MEM[(struct MonoJitDomainInfo *)D.25850].delegate_trampoline_hash; monoeg_g_hash_table_insert_replace (D.25851, klass, ptr, 0); { int ret; D.25842 = &domain->lock.mutex; ret = pthread_mutex_unlock (D.25842); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25888 = ret != 0; D.25889 = (long int) D.25888; D.25890 = __builtin_expect (D.25889, 0); if (D.25890 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1481, "ret == 0"); : } D.25861 = ptr; return D.25861; } finally { code_size = {CLOBBER}; } } mono_create_rgctx_lazy_fetch_trampoline (guint32 offset) { _Bool D.25897; long int D.25898; long int D.25899; struct GHashTable * rgctx_lazy_fetch_trampoline_hash.65; const void * offset.66; _Bool D.25909; long int D.25910; long int D.25911; void * D.25916; int mono_aot_only.67; struct MonoTrampInfo * info.68; struct MonoDomain * D.25922; _Bool D.25925; long int D.25926; long int D.25927; struct GHashTable * rgctx_lazy_fetch_trampoline_hash.69; struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.70; void * offset.71; _Bool D.25935; long int D.25936; long int D.25937; struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.72; unsigned int D.25941; void * D.25942; _Bool D.25945; long int D.25946; long int D.25947; int inited.73; int num_trampolines.74; int num_trampolines.75; static gboolean inited = 0; static int num_trampolines = 0; struct MonoTrampInfo * info; void * tramp; void * ptr; try { { int ret; ret = pthread_mutex_lock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25897 = ret != 0; D.25898 = (long int) D.25897; D.25899 = __builtin_expect (D.25898, 0); if (D.25899 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1498, "ret == 0"); : } rgctx_lazy_fetch_trampoline_hash.65 = rgctx_lazy_fetch_trampoline_hash; if (rgctx_lazy_fetch_trampoline_hash.65 != 0B) goto ; else goto ; : rgctx_lazy_fetch_trampoline_hash.65 = rgctx_lazy_fetch_trampoline_hash; offset.66 = (const void *) offset; tramp = monoeg_g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash.65, offset.66); goto ; : tramp = 0B; : { int ret; ret = pthread_mutex_unlock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25909 = ret != 0; D.25910 = (long int) D.25909; D.25911 = __builtin_expect (D.25910, 0); if (D.25911 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1503, "ret == 0"); : } if (tramp != 0B) goto ; else goto ; : D.25916 = tramp; return D.25916; : mono_aot_only.67 = mono_aot_only; if (mono_aot_only.67 != 0) goto ; else goto ; : ptr = mono_aot_get_lazy_fetch_trampoline (offset); goto ; : tramp = mono_arch_create_rgctx_lazy_fetch_trampoline (offset, &info, 0); info.68 = info; mono_tramp_info_register (info.68); D.25922 = mono_get_root_domain (); ptr = mono_create_ftnptr (D.25922, tramp); : { int ret; ret = pthread_mutex_lock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25925 = ret != 0; D.25926 = (long int) D.25925; D.25927 = __builtin_expect (D.25926, 0); if (D.25927 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1515, "ret == 0"); : } rgctx_lazy_fetch_trampoline_hash.65 = rgctx_lazy_fetch_trampoline_hash; if (rgctx_lazy_fetch_trampoline_hash.65 == 0B) goto ; else goto ; : rgctx_lazy_fetch_trampoline_hash.69 = monoeg_g_hash_table_new (0B, 0B); rgctx_lazy_fetch_trampoline_hash = rgctx_lazy_fetch_trampoline_hash.69; rgctx_lazy_fetch_trampoline_hash_addr.70 = monoeg_g_hash_table_new (0B, 0B); rgctx_lazy_fetch_trampoline_hash_addr = rgctx_lazy_fetch_trampoline_hash_addr.70; : rgctx_lazy_fetch_trampoline_hash.65 = rgctx_lazy_fetch_trampoline_hash; offset.71 = (void *) offset; monoeg_g_hash_table_insert_replace (rgctx_lazy_fetch_trampoline_hash.65, offset.71, ptr, 0); D.25935 = offset == 4294967295; D.25936 = (long int) D.25935; D.25937 = __builtin_expect (D.25936, 0); if (D.25937 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1521, "offset != -1"); : rgctx_lazy_fetch_trampoline_hash_addr.72 = rgctx_lazy_fetch_trampoline_hash_addr; D.25941 = offset + 1; D.25942 = (void *) D.25941; monoeg_g_hash_table_insert_replace (rgctx_lazy_fetch_trampoline_hash_addr.72, ptr, D.25942, 0); { int ret; ret = pthread_mutex_unlock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25945 = ret != 0; D.25946 = (long int) D.25945; D.25947 = __builtin_expect (D.25946, 0); if (D.25947 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1523, "ret == 0"); : } inited.73 = inited; if (inited.73 == 0) goto ; else goto ; : mono_counters_register ("RGCTX num lazy fetch trampolines", 2048, &num_trampolines); inited = 1; : num_trampolines.74 = num_trampolines; num_trampolines.75 = num_trampolines.74 + 1; num_trampolines = num_trampolines.75; D.25916 = ptr; return D.25916; } finally { info = {CLOBBER}; } } mono_create_monitor_enter_trampoline () { int mono_aot_only.76; void * code.77; void * code.78; void * D.25964; static void * code; mono_aot_only.76 = mono_aot_only; if (mono_aot_only.76 != 0) goto ; else goto ; : code.77 = code; if (code.77 == 0B) goto ; else goto ; : code.78 = mono_aot_get_trampoline ("monitor_enter_trampoline"); code = code.78; : D.25964 = code; return D.25964; : code = 0B; monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1559); D.25964 = code; return D.25964; } mono_create_monitor_exit_trampoline () { int mono_aot_only.79; void * code.80; void * code.81; void * D.25973; static void * code; mono_aot_only.79 = mono_aot_only; if (mono_aot_only.79 != 0) goto ; else goto ; : code.80 = code; if (code.80 == 0B) goto ; else goto ; : code.81 = mono_aot_get_trampoline ("monitor_exit_trampoline"); code = code.81; : D.25973 = code; return D.25973; : code = 0B; monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1589); D.25973 = code; return D.25973; } mono_create_llvm_imt_trampoline (struct MonoDomain * domain, struct MonoMethod * m, int vt_offset) { void * D.25975; monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1608); D.25975 = 0B; return D.25975; } mono_find_class_init_trampoline_by_addr (const void * addr) { _Bool D.25979; long int D.25980; long int D.25981; struct GHashTable * class_init_hash_addr.82; _Bool D.25990; long int D.25991; long int D.25992; struct MonoVTable * D.25995; struct MonoVTable * res; { int ret; ret = pthread_mutex_lock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25979 = ret != 0; D.25980 = (long int) D.25979; D.25981 = __builtin_expect (D.25980, 0); if (D.25981 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1619, "ret == 0"); : } class_init_hash_addr.82 = class_init_hash_addr; if (class_init_hash_addr.82 != 0B) goto ; else goto ; : class_init_hash_addr.82 = class_init_hash_addr; res = monoeg_g_hash_table_lookup (class_init_hash_addr.82, addr); goto ; : res = 0B; : { int ret; ret = pthread_mutex_unlock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.25990 = ret != 0; D.25991 = (long int) D.25990; D.25992 = __builtin_expect (D.25991, 0); if (D.25992 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1624, "ret == 0"); : } D.25995 = res; return D.25995; } mono_find_rgctx_lazy_fetch_trampoline_by_addr (const void * addr) { _Bool D.25999; long int D.26000; long int D.26001; struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.83; void * D.26007; _Bool D.26014; long int D.26015; long int D.26016; guint32 D.26019; int offset; { int ret; ret = pthread_mutex_lock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret); : D.25999 = ret != 0; D.26000 = (long int) D.25999; D.26001 = __builtin_expect (D.26000, 0); if (D.26001 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1633, "ret == 0"); : } rgctx_lazy_fetch_trampoline_hash_addr.83 = rgctx_lazy_fetch_trampoline_hash_addr; if (rgctx_lazy_fetch_trampoline_hash_addr.83 != 0B) goto ; else goto ; : rgctx_lazy_fetch_trampoline_hash_addr.83 = rgctx_lazy_fetch_trampoline_hash_addr; D.26007 = monoeg_g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash_addr.83, addr); offset = (int) D.26007; if (offset != 0) goto ; else goto ; : offset = offset + -1; goto ; : offset = -1; : goto ; : offset = -1; : { int ret; ret = pthread_mutex_unlock (&trampolines_mutex.mutex); if (ret != 0) goto ; else goto ; : monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret); : D.26014 = ret != 0; D.26015 = (long int) D.26014; D.26016 = __builtin_expect (D.26015, 0); if (D.26016 != 0) goto ; else goto ; : monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1644, "ret == 0"); : } D.26019 = (guint32) offset; return D.26019; } mono_get_generic_trampoline_name (MonoTrampolineType tramp_type) { char * D.26021; const char * D.26022; D.26022 = tramp_names[tramp_type]; D.26021 = monoeg_g_strdup_printf ("generic_trampoline_%s", D.26022); return D.26021; } mono_get_rgctx_fetch_trampoline_name (int slot) { _Bool D.26024; char * D.26025; const char * iftmp.84; gboolean mrgctx; int index; D.26024 = slot < 0; mrgctx = (gboolean) D.26024; index = slot & 2147483647; if (mrgctx != 0) goto ; else goto ; : iftmp.84 = "mrgctx"; goto ; : iftmp.84 = "rgctx"; : D.26025 = monoeg_g_strdup_printf ("rgctx_fetch_trampoline_%s_%d", iftmp.84, index); return D.26025; } mini_get_nullified_class_init_trampoline () { void * nullified_class_init_trampoline.85; int mono_aot_only.86; struct MonoTrampInfo * info.87; void * D.26039; static void * nullified_class_init_trampoline; nullified_class_init_trampoline.85 = nullified_class_init_trampoline; if (nullified_class_init_trampoline.85 == 0B) goto ; else goto ; : { void * tramp; struct MonoTrampInfo * info; try { mono_aot_only.86 = mono_aot_only; if (mono_aot_only.86 != 0) goto ; else goto ; : tramp = mono_aot_get_trampoline ("nullified_class_init_trampoline"); goto ; : tramp = mono_arch_get_nullified_class_init_trampoline (&info); info.87 = info; mono_tramp_info_register (info.87); : mono_memory_barrier (); nullified_class_init_trampoline = tramp; } finally { info = {CLOBBER}; } } : D.26039 = nullified_class_init_trampoline; return D.26039; } mono_memory_barrier () { __sync_synchronize (); }