gpointer mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *method, gpointer addr) { guint8 *code, *start; int this_pos = s390_r2; MonoDomain *domain = mono_domain_get (); start = addr; if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret)) this_pos = s390_r3; start = code = mono_domain_code_reserve (domain, 28); s390_basr (code, s390_r13, 0); s390_j (code, 4); s390_word (code, addr); s390_l (code, s390_r1, 0, s390_r13, 4); s390_ahi (code, this_pos, sizeof(MonoObject)); s390_br (code, s390_r1); g_assert ((code - start) <= 28); mono_arch_flush_icache (start, code - start); return start; }
void mono_trace_enter_method (MonoMethod *method, char *ebp) { int i, j; MonoClass *klass; MonoObject *o; MonoJitArgumentInfo *arg_info; MonoMethodSignature *sig; char *fname; MonoGenericSharingContext *gsctx = NULL; if (!trace_spec.enabled) return; while (output_lock != 0 || InterlockedCompareExchange (&output_lock, 1, 0) != 0) mono_thread_info_yield (); fname = mono_method_full_name (method, TRUE); indent (1); printf ("ENTER: %s(", fname); g_free (fname); if (!ebp) { printf (") ip: %p\n", RETURN_ADDRESS_N (1)); goto unlock; } sig = mono_method_signature (method); arg_info = alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1)); if (method->is_inflated) { /* FIXME: Might be better to pass the ji itself */ MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), RETURN_ADDRESS (), NULL); if (ji) { gsctx = mono_jit_info_get_generic_sharing_context (ji); if (gsctx && gsctx->is_gsharedvt) { /* Needs a ctx to get precise method */ printf (") <gsharedvt>\n"); goto unlock; } } } mono_arch_get_argument_info (sig, sig->param_count, arg_info); if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret)) { g_assert (!mono_method_signature (method)->ret->byref); printf ("VALUERET:%p, ", *((gpointer *)(ebp + 8))); } if (mono_method_signature (method)->hasthis) { gpointer *this = (gpointer *)(ebp + arg_info [0].offset); if (method->klass->valuetype) { printf ("value:%p, ", *arg_in_stack_slot(this, gpointer *)); } else {
void mono_trace_enter_method (MonoMethod *method, char *ebp) { int i, j; MonoClass *class; MonoObject *o; MonoJitArgumentInfo *arg_info; MonoMethodSignature *sig; char *fname; if (!trace_spec.enabled) return; fname = mono_method_full_name (method, TRUE); indent (1); printf ("ENTER: %s(", fname); g_free (fname); if (!ebp) { printf (") ip: %p\n", __builtin_return_address (1)); return; } sig = mono_method_signature (method); arg_info = alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1)); mono_arch_get_argument_info (sig, sig->param_count, arg_info); if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret)) { g_assert (!mono_method_signature (method)->ret->byref); printf ("VALUERET:%p, ", *((gpointer *)(ebp + 8))); } if (mono_method_signature (method)->hasthis) { gpointer *this = (gpointer *)(ebp + arg_info [0].offset); if (method->klass->valuetype) { printf ("value:%p, ", *arg_in_stack_slot(this, gpointer *)); } else {
gboolean mono_arch_tail_call_supported (MonoCompile *cfg, MonoMethodSignature *caller_sig, MonoMethodSignature *callee_sig) { return mono_metadata_signature_equal (caller_sig, callee_sig) && !MONO_TYPE_ISSTRUCT (callee_sig->ret); }
void * mono_arch_create_method_pointer (MonoMethod *method) { MonoMethodSignature *sig; MonoJitInfo *ji; guint8 *p, *code_buffer; guint i, align = 0, simple_type, retSize, reg_save = 0, stackval_arg_pos, local_pos, float_pos, local_start, reg_param = 0, stack_param, this_flag, arg_pos, fpr_param, parSize; guint32 simpletype; size_data sz; int *vtbuf, cpos, vt_cur; sz.code_size = 1024; sz.stack_size = 1024; stack_param = 0; fpr_param = 0; arg_pos = 0; sig = method->signature; p = code_buffer = g_malloc (sz.code_size); DEBUG (printf ("\nDelegate [start emiting] %s at 0x%08x\n", method->name,p)); /*----------------------------------------------------------*/ /* prolog */ /*----------------------------------------------------------*/ s390_stmg(p, s390_r6, STK_BASE, STK_BASE, S390_REG_SAVE_OFFSET); s390_lg (p, s390_r7, 0, STK_BASE, MINV_POS); s390_lgr (p, s390_r0, STK_BASE); s390_aghi(p, STK_BASE, -(sz.stack_size+MINV_POS)); s390_stg (p, s390_r0, 0, STK_BASE, 0); s390_la (p, s390_r8, 0, STK_BASE, 4); s390_lgr (p, s390_r10, s390_r8); s390_lghi(p, s390_r9, sz.stack_size+92); s390_lghi(p, s390_r11, 0); s390_mvcl(p, s390_r8, s390_r10); /*----------------------------------------------------------*/ /* Let's fill MonoInvocation - first zero some fields */ /*----------------------------------------------------------*/ s390_lghi (p, s390_r0, 0); s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex))); s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex_handler))); s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, parent))); s390_lghi (p, s390_r0, 1); s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, invoke_trap))); /*----------------------------------------------------------*/ /* set method pointer */ /*----------------------------------------------------------*/ s390_bras (p, s390_r13, 4); s390_llong(p, method); s390_lg (p, s390_r0, 0, s390_r13, 0); s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, method))); local_start = local_pos = MINV_POS + sizeof (MonoInvocation) + (sig->param_count + 1) * sizeof (stackval); this_flag = (sig->hasthis ? 1 : 0); /*----------------------------------------------------------*/ /* if we are returning a structure, checks it's length to */ /* see if there's a "hidden" parameter that points to the */ /* area. If necessary save this hidden parameter for later */ /*----------------------------------------------------------*/ if (MONO_TYPE_ISSTRUCT(sig->ret)) { if (sig->pinvoke) retSize = mono_class_native_size (sig->ret->data.klass, &align); else retSize = mono_class_value_size (sig->ret->data.klass, &align); switch(retSize) { case 0: case 1: case 2: case 4: case 8: sz.retStruct = 0; break; default: sz.retStruct = 1; s390_lgr(p, s390_r8, s390_r2); reg_save = 1; } } else { reg_save = 0; } if (this_flag) { s390_stg (p, s390_r2 + reg_save, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, obj))); reg_param++; } else { s390_stg (p, s390_r2 + reg_save, 0, STK_BASE, local_pos); local_pos += sizeof(int); s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, obj))); } s390_stmg (p, s390_r3 + reg_param, s390_r6, STK_BASE, local_pos); local_pos += 4 * sizeof(long); float_pos = local_pos; s390_std (p, s390_f0, 0, STK_BASE, local_pos); local_pos += sizeof(double); s390_std (p, s390_f2, 0, STK_BASE, local_pos); local_pos += sizeof(double); /*----------------------------------------------------------*/ /* prepare space for valuetypes */ /*----------------------------------------------------------*/ vt_cur = local_pos; vtbuf = alloca (sizeof(int)*sig->param_count); cpos = 0; for (i = 0; i < sig->param_count; i++) { MonoType *type = sig->params [i]; vtbuf [i] = -1; DEBUG(printf("par: %d type: %d ref: %d\n",i,type->type,type->byref)); if (type->type == MONO_TYPE_VALUETYPE) { MonoClass *klass = type->data.klass; gint size; if (klass->enumtype) continue; size = mono_class_native_size (klass, &align); cpos += align - 1; cpos &= ~(align - 1); vtbuf [i] = cpos; cpos += size; } } cpos += 3; cpos &= ~3; local_pos += cpos; /*----------------------------------------------------------*/ /* set MonoInvocation::stack_args */ /*----------------------------------------------------------*/ stackval_arg_pos = MINV_POS + sizeof (MonoInvocation); s390_la (p, s390_r0, 0, STK_BASE, stackval_arg_pos); s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, stack_args))); /*----------------------------------------------------------*/ /* add stackval arguments */ /*----------------------------------------------------------*/ for (i = 0; i < sig->param_count; ++i) { if (sig->params [i]->byref) { ADD_ISTACK_PARM(0, 1); } else { simple_type = sig->params [i]->type; enum_savechk: switch (simple_type) { case MONO_TYPE_I8: ADD_ISTACK_PARM(-1, 2); break; case MONO_TYPE_R4: ADD_RSTACK_PARM(1); break; case MONO_TYPE_R8: ADD_RSTACK_PARM(2); break; case MONO_TYPE_VALUETYPE: if (sig->params [i]->data.klass->enumtype) { simple_type = sig->params [i]->data.klass->enum_basetype->type; goto enum_savechk; } if (sig->pinvoke) parSize = mono_class_native_size (sig->params [i]->data.klass, &align); else parSize = mono_class_value_size (sig->params [i]->data.klass, &align); switch(parSize) { case 0: case 1: case 2: case 4: ADD_PSTACK_PARM(0, 1); break; case 8: ADD_PSTACK_PARM(-1, 2); break; default: ADD_TSTACK_PARM; } break; default: ADD_ISTACK_PARM(0, 1); } } if (vtbuf [i] >= 0) { s390_la (p, s390_r3, 0, STK_BASE, vt_cur); s390_stg (p, s390_r3, 0, STK_BASE, stackval_arg_pos); s390_la (p, s390_r3, 0, STK_BASE, stackval_arg_pos); vt_cur += vtbuf [i]; } else { s390_la (p, s390_r3, 0, STK_BASE, stackval_arg_pos); } /*--------------------------------------*/ /* Load the parameter registers for the */ /* call to stackval_from_data */ /*--------------------------------------*/ s390_bras (p, s390_r13, 8); s390_llong(p, sig->params [i]); s390_llong(p, sig->pinvoke); s390_llong(p, stackval_from_data); s390_lg (p, s390_r2, 0, s390_r13, 0); s390_lg (p, s390_r5, 0, s390_r13, 4); s390_lg (p, s390_r1, 0, s390_r13, 8); s390_basr (p, s390_r14, s390_r1); stackval_arg_pos += sizeof(stackval); /* fixme: alignment */ DEBUG (printf ("arg_pos %d --> ", arg_pos)); if (sig->pinvoke) arg_pos += mono_type_native_stack_size (sig->params [i], &align); else arg_pos += mono_type_stack_size (sig->params [i], &align); DEBUG (printf ("%d\n", stackval_arg_pos)); } /*----------------------------------------------------------*/ /* Set return area pointer. */ /*----------------------------------------------------------*/ s390_la (p, s390_r10, 0, STK_BASE, stackval_arg_pos); s390_stg(p, s390_r10, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, retval))); if (sig->ret->type == MONO_TYPE_VALUETYPE && !sig->ret->byref) { MonoClass *klass = sig->ret->data.klass; if (!klass->enumtype) { s390_la (p, s390_r9, 0, s390_r10, sizeof(stackval)); s390_st (p, s390_r9, 0,STK_BASE, stackval_arg_pos); stackval_arg_pos += sizeof(stackval); } } /*----------------------------------------------------------*/ /* call ves_exec_method */ /*----------------------------------------------------------*/ s390_bras (p, s390_r13, 4); s390_llong(p, ves_exec_method); s390_lg (p, s390_r1, 0, s390_r13, 0); s390_la (p, s390_r2, 0, STK_BASE, MINV_POS); s390_basr (p, s390_r14, s390_r1); /*----------------------------------------------------------*/ /* move retval from stackval to proper place (r3/r4/...) */ /*----------------------------------------------------------*/ DEBUG(printf("retType: %d byRef: %d\n",sig->ret->type,sig->ret->byref)); if (sig->ret->byref) { DEBUG (printf ("ret by ref\n")); s390_stg(p, s390_r2, 0, s390_r10, 0); } else { enum_retvalue: switch (sig->ret->type) { case MONO_TYPE_VOID: break; case MONO_TYPE_BOOLEAN: case MONO_TYPE_U1: s390_lghi(p, s390_r2, 0); s390_ic (p, s390_r2, 0, s390_r10, 0); break; case MONO_TYPE_I2: case MONO_TYPE_U2: s390_lh (p, s390_r2, 0,s390_r10, 0); break; case MONO_TYPE_I4: case MONO_TYPE_U4: case MONO_TYPE_I: case MONO_TYPE_U: s390_lgf(p, s390_r2, 0, s390_r10, 0); break; case MONO_TYPE_OBJECT: case MONO_TYPE_STRING: case MONO_TYPE_CLASS: case MONO_TYPE_I8: s390_lg (p, s390_r2, 0, s390_r10, 0); break; case MONO_TYPE_R4: s390_le (p, s390_f0, 0, s390_r10, 0); break; case MONO_TYPE_R8: s390_ld (p, s390_f0, 0, s390_r10, 0); break; case MONO_TYPE_VALUETYPE: if (sig->ret->data.klass->enumtype) { simpletype = sig->ret->data.klass->enum_basetype->type; goto enum_retvalue; } /*---------------------------------*/ /* Call stackval_to_data to return */ /* the structure */ /*---------------------------------*/ s390_bras (p, s390_r13, 8); s390_llong(p, sig->ret); s390_llong(p, sig->pinvoke); s390_llong(p, stackval_to_data); s390_lg (p, s390_r2, 0, s390_r13, 0); s390_lg (p, s390_r3, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, retval))); if (sz.retStruct) { /*------------------------------------------*/ /* Get stackval_to_data to set result area */ /*------------------------------------------*/ s390_lgr (p, s390_r4, s390_r8); } else { /*------------------------------------------*/ /* Give stackval_to_data a temp result area */ /*------------------------------------------*/ s390_la (p, s390_r4, 0, STK_BASE, stackval_arg_pos); } s390_lg (p, s390_r5, 0,s390_r13, 4); s390_lg (p, s390_r1, 0, s390_r13, 8); s390_basr (p, s390_r14, s390_r1); switch (retSize) { case 0: break; case 1: s390_lghi(p, s390_r2, 0); s390_ic (p, s390_r2, 0, s390_r10, 0); break; case 2: s390_lh (p, s390_r2, 0, s390_r10, 0); break; case 4: s390_lgf(p, s390_r2, 0, s390_r10, 0); break; case 8: s390_lg (p, s390_r2, 0, s390_r10, 0); break; default: ; /*-------------------------------------------------*/ /* stackval_to_data has placed data in result area */ /*-------------------------------------------------*/ } break; default: g_error ("Type 0x%x not handled yet in thunk creation", sig->ret->type); break; } } /*----------------------------------------------------------*/ /* epilog */ /*----------------------------------------------------------*/ s390_lg (p, STK_BASE, 0, STK_BASE, 0); s390_lg (p, s390_r4, 0, STK_BASE, S390_RET_ADDR_OFFSET); s390_lmg (p, s390_r6, STK_BASE, STK_BASE, S390_REG_SAVE_OFFSET); s390_br (p, s390_r4); DEBUG (printf ("emited code size: %d\n", p - code_buffer)); DEBUG (printf ("Delegate [end emiting]\n")); ji = g_new0 (MonoJitInfo, 1); ji->method = method; ji->code_size = p - code_buffer; ji->code_start = code_buffer; mono_jit_info_table_add (mono_get_root_domain (), ji); return ji->code_start; }