зеркало из https://github.com/mono/mono.git
[mini] Use MonoClass getters on non-AMD64 platforms (#7799)
Best effort to replace direct MonoClass field access by getters.
This commit is contained in:
Родитель
506fc0b522
Коммит
2709d2309e
|
@ -312,7 +312,7 @@ mono_arch_get_throw_exception_generic (int size, MonoTrampInfo **info,
|
|||
s390_lgr (code, s390_r3, s390_r2);
|
||||
if (corlib) {
|
||||
S390_SET (code, s390_r1, (guint8 *)mono_exception_from_token);
|
||||
S390_SET (code, s390_r2, (guint8 *)mono_defaults.exception_class->image);
|
||||
S390_SET (code, s390_r2, (guint8 *)m_class_get_image (mono_defaults.exception_class));
|
||||
s390_basr (code, s390_r14, s390_r1);
|
||||
}
|
||||
|
||||
|
|
|
@ -303,7 +303,7 @@ mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
|
|||
|
||||
sparc_set (code, MONO_TOKEN_TYPE_DEF, sparc_o7);
|
||||
sparc_add (code, FALSE, sparc_i0, sparc_o7, sparc_o1);
|
||||
sparc_set (code, mono_defaults.exception_class->image, sparc_o0);
|
||||
sparc_set (code, m_class_get_image (mono_defaults.exception_class), sparc_o0);
|
||||
sparc_set (code, mono_exception_from_token, sparc_o7);
|
||||
sparc_jmpl (code, sparc_o7, sparc_g0, sparc_callsite);
|
||||
sparc_nop (code);
|
||||
|
|
|
@ -499,7 +499,7 @@ mono_x86_throw_corlib_exception (mgreg_t *regs, guint32 ex_token_index,
|
|||
guint32 ex_token = MONO_TOKEN_TYPE_DEF | ex_token_index;
|
||||
MonoException *ex;
|
||||
|
||||
ex = mono_exception_from_token (mono_defaults.exception_class->image, ex_token);
|
||||
ex = mono_exception_from_token (m_class_get_image (mono_defaults.exception_class), ex_token);
|
||||
|
||||
eip -= pc_offset;
|
||||
|
||||
|
|
|
@ -1226,9 +1226,9 @@ is_hfa (MonoType *t, int *out_nfields, int *out_esize)
|
|||
if (!is_hfa (ftype, &nested_nfields, &nested_esize))
|
||||
return FALSE;
|
||||
if (nested_esize == 4)
|
||||
ftype = &mono_defaults.single_class->byval_arg;
|
||||
ftype = m_class_get_byval_arg (mono_defaults.single_class);
|
||||
else
|
||||
ftype = &mono_defaults.double_class->byval_arg;
|
||||
ftype = m_class_get_byval_arg (mono_defaults.double_class);
|
||||
if (prev_ftype && prev_ftype->type != ftype->type)
|
||||
return FALSE;
|
||||
prev_ftype = ftype;
|
||||
|
@ -2142,7 +2142,7 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
|
||||
if (IS_HARD_FLOAT) {
|
||||
for (i = 0; i < 2; i++) {
|
||||
MonoInst *inst = mono_compile_create_var (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL);
|
||||
MonoInst *inst = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.double_class), OP_LOCAL);
|
||||
inst->flags |= MONO_INST_VOLATILE;
|
||||
|
||||
cfg->arch.vfp_scratch_slots [i] = (gpointer) inst;
|
||||
|
@ -2153,7 +2153,7 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
cfg->ret_var_is_local = TRUE;
|
||||
|
||||
if (cinfo->ret.storage == RegTypeStructByAddr) {
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG);
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_ARG);
|
||||
if (G_UNLIKELY (cfg->verbose_level > 1)) {
|
||||
g_print ("vret_addr = ");
|
||||
mono_print_ins (cfg->vret_addr);
|
||||
|
@ -2162,13 +2162,13 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
|
||||
if (cfg->gen_sdb_seq_points) {
|
||||
if (cfg->compile_aot) {
|
||||
MonoInst *ins = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
MonoInst *ins = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
ins->flags |= MONO_INST_VOLATILE;
|
||||
cfg->arch.seq_point_info_var = ins;
|
||||
|
||||
if (!cfg->soft_breakpoints) {
|
||||
/* Allocate a separate variable for this to save 1 load per seq point */
|
||||
ins = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
ins = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
ins->flags |= MONO_INST_VOLATILE;
|
||||
cfg->arch.ss_trigger_page_var = ins;
|
||||
}
|
||||
|
@ -2176,11 +2176,11 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
if (cfg->soft_breakpoints) {
|
||||
MonoInst *ins;
|
||||
|
||||
ins = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
ins = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
ins->flags |= MONO_INST_VOLATILE;
|
||||
cfg->arch.seq_point_ss_method_var = ins;
|
||||
|
||||
ins = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
ins = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
ins->flags |= MONO_INST_VOLATILE;
|
||||
cfg->arch.seq_point_bp_method_var = ins;
|
||||
}
|
||||
|
@ -2343,7 +2343,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
* the location pointed to by it after call in emit_move_return_value ().
|
||||
*/
|
||||
if (!cfg->arch.vret_addr_loc) {
|
||||
cfg->arch.vret_addr_loc = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
cfg->arch.vret_addr_loc = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
/* Prevent it from being register allocated or optimized away */
|
||||
((MonoInst*)cfg->arch.vret_addr_loc)->flags |= MONO_INST_VOLATILE;
|
||||
}
|
||||
|
@ -2371,7 +2371,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
if (i >= sig->hasthis)
|
||||
t = sig->params [i - sig->hasthis];
|
||||
else
|
||||
t = &mono_defaults.int_class->byval_arg;
|
||||
t = m_class_get_byval_arg (mono_defaults.int_class);
|
||||
t = mini_get_underlying_type (t);
|
||||
|
||||
if ((sig->call_convention == MONO_CALL_VARARG) && (i == sig->sentinelpos)) {
|
||||
|
@ -2535,7 +2535,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
* This is not very nice, and we should really try to fix the allocator.
|
||||
*/
|
||||
|
||||
MonoInst *float_arg = mono_compile_create_var (cfg, &mono_defaults.single_class->byval_arg, OP_LOCAL);
|
||||
MonoInst *float_arg = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.single_class), OP_LOCAL);
|
||||
|
||||
/* Make sure the instruction isn't seen as pointless and removed.
|
||||
*/
|
||||
|
@ -2626,7 +2626,7 @@ mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src)
|
|||
FloatArgData *fad;
|
||||
|
||||
/* See RegTypeFP in mono_arch_emit_call () */
|
||||
MonoInst *float_arg = mono_compile_create_var (cfg, &mono_defaults.single_class->byval_arg, OP_LOCAL);
|
||||
MonoInst *float_arg = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.single_class), OP_LOCAL);
|
||||
float_arg->flags |= MONO_INST_VOLATILE;
|
||||
MONO_EMIT_NEW_UNALU (cfg, OP_FMOVE, float_arg->dreg, load->dreg);
|
||||
|
||||
|
@ -6863,7 +6863,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
|
|||
patch_info->ip.i = code - cfg->native_code;
|
||||
ARM_BL (code, 0);
|
||||
cfg->thunk_area += THUNK_SIZE;
|
||||
*(guint32*)(gpointer)code = exc_class->type_token - MONO_TOKEN_TYPE_DEF;
|
||||
*(guint32*)(gpointer)code = m_class_get_type_token (exc_class) - MONO_TOKEN_TYPE_DEF;
|
||||
code += 4;
|
||||
break;
|
||||
}
|
||||
|
@ -7026,7 +7026,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC
|
|||
unwind_ops = mono_arch_get_cie_program ();
|
||||
|
||||
#ifdef DEBUG_IMT
|
||||
g_print ("Building IMT trampoline for class %s %s entries %d code size %d code at %p end %p vtable %p fail_tramp %p\n", vtable->klass->name_space, vtable->klass->name, count, size, start, ((guint8*)start) + size, vtable, fail_tramp);
|
||||
g_print ("Building IMT trampoline for class %s %s entries %d code size %d code at %p end %p vtable %p fail_tramp %p\n", m_class_get_name_space (vtable->klass), m_class_get_name (vtable->klass), count, size, start, ((guint8*)start) + size, vtable, fail_tramp);
|
||||
for (i = 0; i < count; ++i) {
|
||||
MonoIMTCheckItem *item = imt_entries [i];
|
||||
g_print ("method %d (%p) %s vtable slot %p is_equals %d chunk size %d\n", i, item->key, ((MonoMethod*)item->key)->name, &vtable->vtable [item->value.vtable_slot], item->is_equals, item->chunk_size);
|
||||
|
@ -7182,7 +7182,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC
|
|||
|
||||
#ifdef DEBUG_IMT
|
||||
{
|
||||
char *buff = g_strdup_printf ("thunk_for_class_%s_%s_entries_%d", vtable->klass->name_space, vtable->klass->name, count);
|
||||
char *buff = g_strdup_printf ("thunk_for_class_%s_%s_entries_%d", m_class_get_name_space (vtable->klass), m_class_get_name (vtable->klass), count);
|
||||
mono_disassemble_code (NULL, (guint8*)start, size, buff);
|
||||
g_free (buff);
|
||||
}
|
||||
|
|
|
@ -1130,9 +1130,9 @@ is_hfa (MonoType *t, int *out_nfields, int *out_esize, int *field_offsets)
|
|||
if (!is_hfa (ftype, &nested_nfields, &nested_esize, nested_field_offsets))
|
||||
return FALSE;
|
||||
if (nested_esize == 4)
|
||||
ftype = &mono_defaults.single_class->byval_arg;
|
||||
ftype = m_class_get_byval_arg (mono_defaults.single_class);
|
||||
else
|
||||
ftype = &mono_defaults.double_class->byval_arg;
|
||||
ftype = m_class_get_byval_arg (mono_defaults.double_class);
|
||||
if (prev_ftype && prev_ftype->type != ftype->type)
|
||||
return FALSE;
|
||||
prev_ftype = ftype;
|
||||
|
@ -1337,7 +1337,7 @@ get_call_info (MonoMemPool *mp, MonoMethodSignature *sig)
|
|||
cinfo->gr = PARAM_REGS;
|
||||
cinfo->fr = FP_PARAM_REGS;
|
||||
/* Emit the signature cookie just before the implicit arguments */
|
||||
add_param (cinfo, &cinfo->sig_cookie, &mono_defaults.int_class->byval_arg);
|
||||
add_param (cinfo, &cinfo->sig_cookie, m_class_get_byval_arg (mono_defaults.int_class));
|
||||
}
|
||||
|
||||
add_param (cinfo, ainfo, sig->params [pindex]);
|
||||
|
@ -1362,7 +1362,7 @@ get_call_info (MonoMemPool *mp, MonoMethodSignature *sig)
|
|||
cinfo->gr = PARAM_REGS;
|
||||
cinfo->fr = FP_PARAM_REGS;
|
||||
/* Emit the signature cookie just before the implicit arguments */
|
||||
add_param (cinfo, &cinfo->sig_cookie, &mono_defaults.int_class->byval_arg);
|
||||
add_param (cinfo, &cinfo->sig_cookie, m_class_get_byval_arg (mono_defaults.int_class));
|
||||
}
|
||||
|
||||
cinfo->stack_usage = ALIGN_TO (cinfo->stack_usage, MONO_ARCH_FRAME_ALIGNMENT);
|
||||
|
@ -1991,7 +1991,7 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
cinfo = cfg->arch.cinfo;
|
||||
|
||||
if (cinfo->ret.storage == ArgVtypeByRef) {
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
cfg->vret_addr->flags |= MONO_INST_VOLATILE;
|
||||
}
|
||||
|
||||
|
@ -1999,16 +1999,16 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
MonoInst *ins;
|
||||
|
||||
if (cfg->compile_aot) {
|
||||
ins = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
ins = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
ins->flags |= MONO_INST_VOLATILE;
|
||||
cfg->arch.seq_point_info_var = ins;
|
||||
}
|
||||
|
||||
ins = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
ins = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
ins->flags |= MONO_INST_VOLATILE;
|
||||
cfg->arch.ss_tramp_var = ins;
|
||||
|
||||
ins = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
ins = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
ins->flags |= MONO_INST_VOLATILE;
|
||||
cfg->arch.bp_tramp_var = ins;
|
||||
}
|
||||
|
@ -2457,7 +2457,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
* the location pointed to by it after call in emit_move_return_value ().
|
||||
*/
|
||||
if (!cfg->arch.vret_addr_loc) {
|
||||
cfg->arch.vret_addr_loc = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
cfg->arch.vret_addr_loc = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
/* Prevent it from being register allocated or optimized away */
|
||||
((MonoInst*)cfg->arch.vret_addr_loc)->flags |= MONO_INST_VOLATILE;
|
||||
}
|
||||
|
@ -2597,7 +2597,7 @@ mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src)
|
|||
load = src;
|
||||
} else {
|
||||
/* Make a copy of the argument */
|
||||
vtaddr = mono_compile_create_var (cfg, &ins->klass->byval_arg, OP_LOCAL);
|
||||
vtaddr = mono_compile_create_var (cfg, m_class_get_byval_arg (ins->klass), OP_LOCAL);
|
||||
|
||||
MONO_INST_NEW (cfg, load, OP_LDADDR);
|
||||
load->inst_p0 = vtaddr;
|
||||
|
@ -5075,7 +5075,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
|
|||
|
||||
/* r0 = type token */
|
||||
exc_class = mono_class_load_from_name (mono_defaults.corlib, "System", ji->data.name);
|
||||
code = emit_imm (code, ARMREG_R0, exc_class->type_token - MONO_TOKEN_TYPE_DEF);
|
||||
code = emit_imm (code, ARMREG_R0, m_class_get_type_token (exc_class) - MONO_TOKEN_TYPE_DEF);
|
||||
/* r1 = throw ip */
|
||||
arm_movx (code, ARMREG_R1, ARMREG_IP1);
|
||||
/* Branch to the corlib exception throwing trampoline */
|
||||
|
@ -5112,7 +5112,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC
|
|||
guint8 *buf, *code;
|
||||
|
||||
#if DEBUG_IMT
|
||||
printf ("building IMT trampoline for class %s %s entries %d code size %d code at %p end %p vtable %p\n", vtable->klass->name_space, vtable->klass->name, count, size, start, ((guint8*)start) + size, vtable);
|
||||
printf ("building IMT trampoline for class %s %s entries %d code size %d code at %p end %p vtable %p\n", m_class_get_name_space (vtable->klass), m_class_get_name (vtable->klass), count, size, start, ((guint8*)start) + size, vtable);
|
||||
for (i = 0; i < count; ++i) {
|
||||
MonoIMTCheckItem *item = imt_entries [i];
|
||||
printf ("method %d (%p) %s vtable slot %p is_equals %d chunk size %d\n", i, item->key, item->key->name, &vtable->vtable [item->value.vtable_slot], item->is_equals, item->chunk_size);
|
||||
|
|
|
@ -338,34 +338,35 @@ get_vtype_size (MonoType *t)
|
|||
static LLVMTypeRef
|
||||
simd_class_to_llvm_type (EmitContext *ctx, MonoClass *klass)
|
||||
{
|
||||
if (!strcmp (klass->name, "Vector2d")) {
|
||||
const char *klass_name = m_class_get_name (klass);
|
||||
if (!strcmp (klass_name, "Vector2d")) {
|
||||
return LLVMVectorType (LLVMDoubleType (), 2);
|
||||
} else if (!strcmp (klass->name, "Vector2l")) {
|
||||
} else if (!strcmp (klass_name, "Vector2l")) {
|
||||
return LLVMVectorType (LLVMInt64Type (), 2);
|
||||
} else if (!strcmp (klass->name, "Vector2ul")) {
|
||||
} else if (!strcmp (klass_name, "Vector2ul")) {
|
||||
return LLVMVectorType (LLVMInt64Type (), 2);
|
||||
} else if (!strcmp (klass->name, "Vector4i")) {
|
||||
} else if (!strcmp (klass_name, "Vector4i")) {
|
||||
return LLVMVectorType (LLVMInt32Type (), 4);
|
||||
} else if (!strcmp (klass->name, "Vector4ui")) {
|
||||
} else if (!strcmp (klass_name, "Vector4ui")) {
|
||||
return LLVMVectorType (LLVMInt32Type (), 4);
|
||||
} else if (!strcmp (klass->name, "Vector4f")) {
|
||||
} else if (!strcmp (klass_name, "Vector4f")) {
|
||||
return LLVMVectorType (LLVMFloatType (), 4);
|
||||
} else if (!strcmp (klass->name, "Vector8s")) {
|
||||
} else if (!strcmp (klass_name, "Vector8s")) {
|
||||
return LLVMVectorType (LLVMInt16Type (), 8);
|
||||
} else if (!strcmp (klass->name, "Vector8us")) {
|
||||
} else if (!strcmp (klass_name, "Vector8us")) {
|
||||
return LLVMVectorType (LLVMInt16Type (), 8);
|
||||
} else if (!strcmp (klass->name, "Vector16sb")) {
|
||||
} else if (!strcmp (klass_name, "Vector16sb")) {
|
||||
return LLVMVectorType (LLVMInt8Type (), 16);
|
||||
} else if (!strcmp (klass->name, "Vector16b")) {
|
||||
} else if (!strcmp (klass_name, "Vector16b")) {
|
||||
return LLVMVectorType (LLVMInt8Type (), 16);
|
||||
} else if (!strcmp (klass->name, "Vector2")) {
|
||||
} else if (!strcmp (klass_name, "Vector2")) {
|
||||
/* System.Numerics */
|
||||
return LLVMVectorType (LLVMFloatType (), 4);
|
||||
} else if (!strcmp (klass->name, "Vector3")) {
|
||||
} else if (!strcmp (klass_name, "Vector3")) {
|
||||
return LLVMVectorType (LLVMFloatType (), 4);
|
||||
} else if (!strcmp (klass->name, "Vector4")) {
|
||||
} else if (!strcmp (klass_name, "Vector4")) {
|
||||
return LLVMVectorType (LLVMFloatType (), 4);
|
||||
} else if (!strcmp (klass->name, "Vector`1")) {
|
||||
} else if (!strcmp (klass_name, "Vector`1")) {
|
||||
MonoType *etype = mono_class_get_generic_class (klass)->context.class_inst->type_argv [0];
|
||||
switch (etype->type) {
|
||||
case MONO_TYPE_I1:
|
||||
|
@ -389,7 +390,7 @@ simd_class_to_llvm_type (EmitContext *ctx, MonoClass *klass)
|
|||
return NULL;
|
||||
}
|
||||
} else {
|
||||
printf ("%s\n", klass->name);
|
||||
printf ("%s\n", klass_name);
|
||||
NOT_IMPLEMENTED;
|
||||
return NULL;
|
||||
}
|
||||
|
@ -427,7 +428,7 @@ create_llvm_type_for_type (MonoLLVMModule *module, MonoClass *klass)
|
|||
MonoType *t;
|
||||
LLVMTypeRef ltype;
|
||||
|
||||
t = &klass->byval_arg;
|
||||
t = m_class_get_byval_arg (klass);
|
||||
|
||||
if (mini_type_is_hfa (t, &nfields, &esize)) {
|
||||
/*
|
||||
|
@ -435,7 +436,7 @@ create_llvm_type_for_type (MonoLLVMModule *module, MonoClass *klass)
|
|||
* registers.
|
||||
*/
|
||||
/* SIMD types have size 16 in mono_class_value_size () */
|
||||
if (klass->simd_type)
|
||||
if (m_class_is_simd_type (klass))
|
||||
nfields = 16/ esize;
|
||||
size = nfields;
|
||||
eltypes = g_new (LLVMTypeRef, size);
|
||||
|
@ -449,7 +450,7 @@ create_llvm_type_for_type (MonoLLVMModule *module, MonoClass *klass)
|
|||
eltypes [i] = LLVMInt8Type ();
|
||||
}
|
||||
|
||||
name = mono_type_full_name (&klass->byval_arg);
|
||||
name = mono_type_full_name (m_class_get_byval_arg (klass));
|
||||
ltype = LLVMStructCreateNamed (module->context, name);
|
||||
LLVMStructSetBody (ltype, eltypes, size, FALSE);
|
||||
g_free (eltypes);
|
||||
|
@ -517,7 +518,7 @@ type_to_llvm_type (EmitContext *ctx, MonoType *t)
|
|||
if (MONO_CLASS_IS_SIMD (ctx->cfg, klass))
|
||||
return simd_class_to_llvm_type (ctx, klass);
|
||||
|
||||
if (klass->enumtype)
|
||||
if (m_class_is_enumtype (klass))
|
||||
return type_to_llvm_type (ctx, mono_class_enum_basetype (klass));
|
||||
|
||||
ltype = (LLVMTypeRef)g_hash_table_lookup (ctx->module->llvm_types, klass);
|
||||
|
@ -2133,7 +2134,7 @@ emit_cond_system_exception (EmitContext *ctx, MonoBasicBlock *bb, const char *ex
|
|||
ctx->builder = builder = create_builder (ctx);
|
||||
LLVMPositionBuilderAtEnd (ctx->builder, ex2_bb);
|
||||
|
||||
args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token - MONO_TOKEN_TYPE_DEF, FALSE);
|
||||
args [0] = LLVMConstInt (LLVMInt32Type (), m_class_get_type_token (exc_class) - MONO_TOKEN_TYPE_DEF, FALSE);
|
||||
emit_call (ctx, bb, &builder, callee, args, 1);
|
||||
LLVMBuildUnreachable (builder);
|
||||
|
||||
|
@ -2186,7 +2187,7 @@ emit_cond_system_exception (EmitContext *ctx, MonoBasicBlock *bb, const char *ex
|
|||
}
|
||||
}
|
||||
|
||||
args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token - MONO_TOKEN_TYPE_DEF, FALSE);
|
||||
args [0] = LLVMConstInt (LLVMInt32Type (), m_class_get_type_token (exc_class) - MONO_TOKEN_TYPE_DEF, FALSE);
|
||||
|
||||
/*
|
||||
* The LLVM mono branch contains changes so a block address can be passed as an
|
||||
|
@ -3219,7 +3220,7 @@ process_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref,
|
|||
set_failure (ctx, "can't encode patch");
|
||||
return;
|
||||
}
|
||||
if (cfg->llvm_only && call->method->klass->image->assembly == ctx->module->assembly) {
|
||||
if (cfg->llvm_only && m_class_get_image (call->method->klass)->assembly == ctx->module->assembly) {
|
||||
/*
|
||||
* Collect instructions representing the callee into a hash so they can be replaced
|
||||
* by the llvm method for the callee if the callee turns out to be direct
|
||||
|
@ -3280,7 +3281,7 @@ process_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref,
|
|||
}
|
||||
}
|
||||
|
||||
if (!cfg->llvm_only && call->method && strstr (call->method->klass->name, "AsyncVoidMethodBuilder")) {
|
||||
if (!cfg->llvm_only && call->method && strstr (m_class_get_name (call->method->klass), "AsyncVoidMethodBuilder")) {
|
||||
/* LLVM miscompiles async methods */
|
||||
set_failure (ctx, "#13734");
|
||||
return;
|
||||
|
@ -3627,7 +3628,7 @@ emit_llvmonly_throw (EmitContext *ctx, MonoBasicBlock *bb, gboolean rethrow, LLV
|
|||
const char *icall_name = rethrow ? "mono_llvm_rethrow_exception" : "mono_llvm_throw_exception";
|
||||
LLVMValueRef callee = rethrow ? ctx->module->rethrow : ctx->module->throw_icall;
|
||||
|
||||
LLVMTypeRef exc_type = type_to_llvm_type (ctx, &mono_get_exception_class ()->byval_arg);
|
||||
LLVMTypeRef exc_type = type_to_llvm_type (ctx, m_class_get_byval_arg (mono_get_exception_class ()));
|
||||
|
||||
if (!callee) {
|
||||
LLVMTypeRef fun_sig = LLVMFunctionType1 (LLVMVoidType (), exc_type, FALSE);
|
||||
|
@ -3668,8 +3669,8 @@ emit_throw (EmitContext *ctx, MonoBasicBlock *bb, gboolean rethrow, LLVMValueRef
|
|||
|
||||
if (!callee) {
|
||||
throw_sig = mono_metadata_signature_alloc (mono_get_corlib (), 1);
|
||||
throw_sig->ret = &mono_get_void_class ()->byval_arg;
|
||||
throw_sig->params [0] = &mono_get_object_class ()->byval_arg;
|
||||
throw_sig->ret = m_class_get_byval_arg (mono_get_void_class ());
|
||||
throw_sig->params [0] = m_class_get_byval_arg (mono_get_object_class ());
|
||||
if (ctx->cfg->compile_aot) {
|
||||
callee = get_callee (ctx, sig_to_llvm_sig (ctx, throw_sig), MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
|
||||
} else {
|
||||
|
@ -3694,7 +3695,7 @@ emit_throw (EmitContext *ctx, MonoBasicBlock *bb, gboolean rethrow, LLVMValueRef
|
|||
ctx->module->throw_icall = callee;
|
||||
#endif
|
||||
}
|
||||
arg = convert (ctx, exc, type_to_llvm_type (ctx, &mono_get_object_class ()->byval_arg));
|
||||
arg = convert (ctx, exc, type_to_llvm_type (ctx, m_class_get_byval_arg (mono_get_object_class ())));
|
||||
emit_call (ctx, bb, &ctx->builder, callee, &arg, 1);
|
||||
}
|
||||
|
||||
|
@ -4682,7 +4683,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
|
|||
g_assert (lhs);
|
||||
values [ins->dreg] = lhs;
|
||||
|
||||
if (var && var->klass->byval_arg.type == MONO_TYPE_R4) {
|
||||
if (var && m_class_get_byval_arg (var->klass)->type == MONO_TYPE_R4) {
|
||||
/*
|
||||
* This is added by the spilling pass in case of the JIT,
|
||||
* but we have to do it ourselves.
|
||||
|
@ -5731,7 +5732,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
|
|||
}
|
||||
|
||||
if (!addresses [ins->dreg])
|
||||
addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
|
||||
addresses [ins->dreg] = build_alloca (ctx, m_class_get_byval_arg (klass));
|
||||
args [0] = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
|
||||
args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
|
||||
args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
|
||||
|
@ -5765,7 +5766,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
|
|||
|
||||
switch (ins->opcode) {
|
||||
case OP_STOREV_MEMBASE:
|
||||
if (cfg->gen_write_barriers && klass->has_references && ins->inst_destbasereg != cfg->frame_reg &&
|
||||
if (cfg->gen_write_barriers && m_class_has_references (klass) && ins->inst_destbasereg != cfg->frame_reg &&
|
||||
LLVMGetInstructionOpcode (values [ins->inst_destbasereg]) != LLVMAlloca) {
|
||||
/* Decomposed earlier */
|
||||
g_assert_not_reached ();
|
||||
|
@ -5774,7 +5775,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
|
|||
if (!addresses [ins->sreg1]) {
|
||||
/* SIMD */
|
||||
g_assert (values [ins->sreg1]);
|
||||
dst = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (type_to_llvm_type (ctx, &klass->byval_arg), 0));
|
||||
dst = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (type_to_llvm_type (ctx, m_class_get_byval_arg (klass)), 0));
|
||||
LLVMBuildStore (builder, values [ins->sreg1], dst);
|
||||
done = TRUE;
|
||||
} else {
|
||||
|
@ -5784,15 +5785,15 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
|
|||
break;
|
||||
case OP_LOADV_MEMBASE:
|
||||
if (!addresses [ins->dreg])
|
||||
addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
|
||||
addresses [ins->dreg] = build_alloca (ctx, m_class_get_byval_arg (klass));
|
||||
src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
|
||||
dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
|
||||
break;
|
||||
case OP_VMOVE:
|
||||
if (!addresses [ins->sreg1])
|
||||
addresses [ins->sreg1] = build_alloca (ctx, &klass->byval_arg);
|
||||
addresses [ins->sreg1] = build_alloca (ctx, m_class_get_byval_arg (klass));
|
||||
if (!addresses [ins->dreg])
|
||||
addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
|
||||
addresses [ins->dreg] = build_alloca (ctx, m_class_get_byval_arg (klass));
|
||||
src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
|
||||
dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
|
||||
break;
|
||||
|
@ -5896,11 +5897,11 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb)
|
|||
*/
|
||||
#if defined(TARGET_X86) || defined(TARGET_AMD64)
|
||||
case OP_XZERO: {
|
||||
values [ins->dreg] = LLVMConstNull (type_to_llvm_type (ctx, &ins->klass->byval_arg));
|
||||
values [ins->dreg] = LLVMConstNull (type_to_llvm_type (ctx, m_class_get_byval_arg (ins->klass)));
|
||||
break;
|
||||
}
|
||||
case OP_LOADX_MEMBASE: {
|
||||
LLVMTypeRef t = type_to_llvm_type (ctx, &ins->klass->byval_arg);
|
||||
LLVMTypeRef t = type_to_llvm_type (ctx, m_class_get_byval_arg (ins->klass));
|
||||
LLVMValueRef src;
|
||||
|
||||
src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
|
||||
|
@ -7140,7 +7141,7 @@ emit_method_inner (EmitContext *ctx)
|
|||
case OP_FPHI:
|
||||
case OP_VPHI:
|
||||
case OP_XPHI: {
|
||||
LLVMTypeRef phi_type = llvm_type_to_stack_type (cfg, type_to_llvm_type (ctx, &ins->klass->byval_arg));
|
||||
LLVMTypeRef phi_type = llvm_type_to_stack_type (cfg, type_to_llvm_type (ctx, m_class_get_byval_arg (ins->klass)));
|
||||
|
||||
if (!ctx_ok (ctx))
|
||||
return;
|
||||
|
@ -7148,7 +7149,7 @@ emit_method_inner (EmitContext *ctx)
|
|||
if (ins->opcode == OP_VPHI) {
|
||||
/* Treat valuetype PHI nodes as operating on the address itself */
|
||||
g_assert (ins->klass);
|
||||
phi_type = LLVMPointerType (type_to_llvm_type (ctx, &ins->klass->byval_arg), 0);
|
||||
phi_type = LLVMPointerType (type_to_llvm_type (ctx, m_class_get_byval_arg (ins->klass)), 0);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -7470,7 +7471,7 @@ emit_method_inner (EmitContext *ctx)
|
|||
if (ctx->module->idx_to_lmethod)
|
||||
g_hash_table_insert (ctx->module->idx_to_lmethod, GINT_TO_POINTER (cfg->method_index), ctx->lmethod);
|
||||
|
||||
if (ctx->llvm_only && cfg->orig_method->klass->valuetype && !(cfg->orig_method->flags & METHOD_ATTRIBUTE_STATIC))
|
||||
if (ctx->llvm_only && m_class_is_valuetype (cfg->orig_method->klass) && !(cfg->orig_method->flags & METHOD_ATTRIBUTE_STATIC))
|
||||
emit_unbox_tramp (ctx, ctx->method_name, ctx->method_type, ctx->lmethod, cfg->method_index);
|
||||
}
|
||||
|
||||
|
@ -7502,7 +7503,7 @@ mono_llvm_create_vars (MonoCompile *cfg)
|
|||
* Creating vret_addr forces CEE_SETRET to store the result into it,
|
||||
* so we don't have to generate any code in our OP_SETRET case.
|
||||
*/
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, &mono_get_intptr_class ()->byval_arg, OP_ARG);
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_get_intptr_class ()), OP_ARG);
|
||||
if (G_UNLIKELY (cfg->verbose_level > 1)) {
|
||||
printf ("vret_addr = ");
|
||||
mono_print_ins (cfg->vret_addr);
|
||||
|
@ -7551,7 +7552,7 @@ mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
/* Simply remember the arguments */
|
||||
switch (ainfo->storage) {
|
||||
case LLVMArgNormal: {
|
||||
MonoType *t = (sig->hasthis && i == 0) ? &mono_get_intptr_class ()->byval_arg : ainfo->type;
|
||||
MonoType *t = (sig->hasthis && i == 0) ? m_class_get_byval_arg (mono_get_intptr_class ()) : ainfo->type;
|
||||
int opcode;
|
||||
|
||||
opcode = mono_type_to_regmove (cfg, t);
|
||||
|
|
|
@ -205,7 +205,7 @@ mips_emit_exc_by_name(guint8 *code, const char *name)
|
|||
|
||||
exc_class = mono_class_load_from_name (mono_defaults.corlib, "System", name);
|
||||
|
||||
mips_load_const (code, mips_a0, exc_class->type_token);
|
||||
mips_load_const (code, mips_a0, m_class_get_type_token (exc_class));
|
||||
addr = mono_get_throw_corlib_exception ();
|
||||
mips_call (code, mips_t9, addr);
|
||||
return code;
|
||||
|
@ -1560,7 +1560,7 @@ mono_arch_allocate_vars (MonoCompile *cfg)
|
|||
MonoType *arg_type;
|
||||
|
||||
if (sig->hasthis && (i == 0))
|
||||
arg_type = &mono_defaults.object_class->byval_arg;
|
||||
arg_type = m_class_get_byval_arg (mono_defaults.object_class);
|
||||
else
|
||||
arg_type = sig->params [i - sig->hasthis];
|
||||
|
||||
|
@ -1611,7 +1611,7 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
sig = mono_method_signature (cfg->method);
|
||||
|
||||
if (MONO_TYPE_ISSTRUCT (sig->ret)) {
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG);
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_ARG);
|
||||
if (G_UNLIKELY (cfg->verbose_level > 1)) {
|
||||
printf ("vret_addr = ");
|
||||
mono_print_ins (cfg->vret_addr);
|
||||
|
@ -1684,7 +1684,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
if (i >= sig->hasthis)
|
||||
t = sig->params [i - sig->hasthis];
|
||||
else
|
||||
t = &mono_defaults.int_class->byval_arg;
|
||||
t = m_class_get_byval_arg (mono_defaults.int_class);
|
||||
t = mini_get_underlying_type (t);
|
||||
|
||||
if ((sig->call_convention == MONO_CALL_VARARG) && (i == sig->sentinelpos)) {
|
||||
|
@ -1894,16 +1894,16 @@ mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src)
|
|||
MONO_EMIT_NEW_UNALU (cfg, OP_FMOVE, dreg, tmpr);
|
||||
mono_call_inst_add_outarg_reg (cfg, call, dreg, ainfo->reg, TRUE);
|
||||
} else {
|
||||
MonoInst *vtcopy = mono_compile_create_var (cfg, &src->klass->byval_arg, OP_LOCAL);
|
||||
MonoInst *vtcopy = mono_compile_create_var (cfg, m_class_get_byval_arg (src->klass), OP_LOCAL);
|
||||
MonoInst *load;
|
||||
guint32 size;
|
||||
|
||||
/* FIXME: alignment? */
|
||||
if (call->signature->pinvoke) {
|
||||
size = mono_type_native_stack_size (&src->klass->byval_arg, NULL);
|
||||
size = mono_type_native_stack_size (m_class_get_byval_arg (src->klass), NULL);
|
||||
vtcopy->backend.is_pinvoke = 1;
|
||||
} else {
|
||||
size = mini_type_stack_size (&src->klass->byval_arg, NULL);
|
||||
size = mini_type_stack_size (m_class_get_byval_arg (src->klass), NULL);
|
||||
}
|
||||
if (size > 0)
|
||||
g_assert (ovf_size > 0);
|
||||
|
|
|
@ -903,9 +903,9 @@ is_struct_returnable_via_regs (MonoClass *klass, gboolean is_pinvoke)
|
|||
gpointer iter = NULL;
|
||||
MonoClassField *f;
|
||||
if (is_pinvoke)
|
||||
size = mono_type_native_stack_size (&klass->byval_arg, 0);
|
||||
size = mono_type_native_stack_size (m_class_get_byval_arg (klass), 0);
|
||||
else
|
||||
size = mini_type_stack_size (&klass->byval_arg, 0);
|
||||
size = mini_type_stack_size (m_class_get_byval_arg (klass), 0);
|
||||
if (size == 0)
|
||||
return TRUE;
|
||||
if (size > PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS)
|
||||
|
@ -1565,7 +1565,7 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
MonoMethodSignature *sig = mono_method_signature (cfg->method);
|
||||
|
||||
if (MONO_TYPE_ISSTRUCT (sig->ret)) {
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG);
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_ARG);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1606,7 +1606,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
if (i >= sig->hasthis)
|
||||
t = sig->params [i - sig->hasthis];
|
||||
else
|
||||
t = &mono_defaults.int_class->byval_arg;
|
||||
t = m_class_get_byval_arg (mono_defaults.int_class);
|
||||
t = mini_get_underlying_type (t);
|
||||
|
||||
if (!sig->pinvoke && (sig->call_convention == MONO_CALL_VARARG) && (i == sig->sentinelpos))
|
||||
|
@ -1814,16 +1814,16 @@ mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src)
|
|||
MONO_EMIT_NEW_UNALU (cfg, OP_FMOVE, dreg, tmpr);
|
||||
mono_call_inst_add_outarg_reg (cfg, call, dreg, ainfo->reg, TRUE);
|
||||
} else {
|
||||
MonoInst *vtcopy = mono_compile_create_var (cfg, &src->klass->byval_arg, OP_LOCAL);
|
||||
MonoInst *vtcopy = mono_compile_create_var (cfg, m_class_get_byval_arg (src->klass), OP_LOCAL);
|
||||
MonoInst *load;
|
||||
guint32 size;
|
||||
|
||||
/* FIXME: alignment? */
|
||||
if (call->signature->pinvoke) {
|
||||
size = mono_type_native_stack_size (&src->klass->byval_arg, NULL);
|
||||
size = mono_type_native_stack_size (m_class_get_byval_arg (src->klass), NULL);
|
||||
vtcopy->backend.is_pinvoke = 1;
|
||||
} else {
|
||||
size = mini_type_stack_size (&src->klass->byval_arg, NULL);
|
||||
size = mini_type_stack_size (m_class_get_byval_arg (src->klass), NULL);
|
||||
}
|
||||
if (size > 0)
|
||||
g_assert (ovf_size > 0);
|
||||
|
@ -5551,7 +5551,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
|
|||
|
||||
ppc_patch (ip, code);
|
||||
/*mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_EXC_NAME, patch_info->data.target);*/
|
||||
ppc_load (code, ppc_r3, exc_class->type_token);
|
||||
ppc_load (code, ppc_r3, m_class_get_type_token (exc_class));
|
||||
/* we got here from a conditional call, so the calling ip is set in lr */
|
||||
ppc_mflr (code, ppc_r4);
|
||||
patch_info->type = MONO_PATCH_INFO_INTERNAL_METHOD;
|
||||
|
|
|
@ -920,7 +920,7 @@ enum_parmtype:
|
|||
obj, *(gint32 *)((char *)obj + sizeof (MonoObject)));
|
||||
} else
|
||||
fprintf (trFd, "[%s.%s:%p]",
|
||||
klass->name_space, klass->name, obj);
|
||||
m_class_get_name_space (klass), m_class_get_name (klass), obj);
|
||||
fprintf (trFd, "], ");
|
||||
} else {
|
||||
fprintf (trFd, "[OBJECT:null], ");
|
||||
|
@ -952,7 +952,7 @@ enum_parmtype:
|
|||
int i;
|
||||
MonoMarshalType *info;
|
||||
|
||||
if (type->data.klass->enumtype) {
|
||||
if (m_class_is_enumtype (type->data.klass)) {
|
||||
simpleType = mono_class_enum_basetype (type->data.klass)->type;
|
||||
fprintf (trFd, "{VALUETYPE} - ");
|
||||
goto enum_parmtype;
|
||||
|
@ -1046,7 +1046,7 @@ enter_method (MonoMethod *method, RegParm *rParm, char *sp)
|
|||
if (sig->hasthis) {
|
||||
gpointer *this_arg = (gpointer *) rParm->gr[iParm];
|
||||
obj = (MonoObject *) this_arg;
|
||||
switch(method->klass->this_arg.type) {
|
||||
switch(m_class_get_this_arg (method->klass)->type) {
|
||||
case MONO_TYPE_VALUETYPE:
|
||||
if (obj) {
|
||||
guint64 *value = (guint64 *) ((uintptr_t)this_arg + sizeof(MonoObject));
|
||||
|
@ -1063,7 +1063,7 @@ enter_method (MonoMethod *method, RegParm *rParm, char *sp)
|
|||
decodeParmString((MonoString *)obj);
|
||||
} else {
|
||||
fprintf (trFd, "this:%p[%s.%s], ",
|
||||
obj, klass->name_space, klass->name);
|
||||
obj, m_class_get_name_space (klass), m_class_get_name (klass));
|
||||
}
|
||||
} else
|
||||
fprintf (trFd, "vtable:[NULL], ");
|
||||
|
@ -1071,7 +1071,7 @@ enter_method (MonoMethod *method, RegParm *rParm, char *sp)
|
|||
fprintf (trFd, "this:[NULL], ");
|
||||
break;
|
||||
default :
|
||||
fprintf (trFd, "this[%s]: %p, ",cvtMonoType(method->klass->this_arg.type),this_arg);
|
||||
fprintf (trFd, "this[%s]: %p, ",cvtMonoType(m_class_get_this_arg (method->klass)->type),this_arg);
|
||||
}
|
||||
oParm++;
|
||||
}
|
||||
|
@ -1233,7 +1233,7 @@ handle_enum:
|
|||
} else if (o->vtable->klass == mono_defaults.int64_class) {
|
||||
fprintf (trFd, "[INT64:%p:%ld]", o, *((gint64 *)((char *)o + sizeof (MonoObject))));
|
||||
} else
|
||||
fprintf (trFd, "[%s.%s:%p]", o->vtable->klass->name_space, o->vtable->klass->name, o);
|
||||
fprintf (trFd, "[%s.%s:%p]", m_class_get_name_space (o->vtable->klass), m_class_get_name (o->vtable->klass), o);
|
||||
} else
|
||||
fprintf (trFd, "[OBJECT:%p]", o);
|
||||
|
||||
|
@ -1269,7 +1269,7 @@ handle_enum:
|
|||
}
|
||||
case MONO_TYPE_VALUETYPE: {
|
||||
MonoMarshalType *info;
|
||||
if (type->data.klass->enumtype) {
|
||||
if (m_class_is_enumtype (type->data.klass)) {
|
||||
type = mono_class_enum_basetype (type->data.klass);
|
||||
goto handle_enum;
|
||||
} else {
|
||||
|
@ -1750,11 +1750,11 @@ enum_retvalue:
|
|||
/* Fall through */
|
||||
case MONO_TYPE_VALUETYPE: {
|
||||
MonoClass *klass = mono_class_from_mono_type (sig->ret);
|
||||
if (klass->enumtype) {
|
||||
if (m_class_is_enumtype (klass)) {
|
||||
simpleType = mono_class_enum_basetype (klass)->type;
|
||||
goto enum_retvalue;
|
||||
}
|
||||
size = mini_type_stack_size_full (&klass->byval_arg, NULL, sig->pinvoke);
|
||||
size = mini_type_stack_size_full (m_class_get_byval_arg (klass), NULL, sig->pinvoke);
|
||||
|
||||
cinfo->struct_ret = 1;
|
||||
cinfo->ret.size = size;
|
||||
|
@ -2307,7 +2307,7 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
cinfo = get_call_info (cfg->mempool, sig);
|
||||
|
||||
if (cinfo->struct_ret) {
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG);
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_ARG);
|
||||
if (G_UNLIKELY (cfg->verbose_level > 1)) {
|
||||
printf ("vret_addr = ");
|
||||
mono_print_ins (cfg->vret_addr);
|
||||
|
@ -2449,7 +2449,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
if (i >= sig->hasthis)
|
||||
t = sig->params [i - sig->hasthis];
|
||||
else
|
||||
t = &mono_defaults.int_class->byval_arg;
|
||||
t = m_class_get_byval_arg (mono_defaults.int_class);
|
||||
t = mini_get_underlying_type (t);
|
||||
|
||||
in = call->args [i];
|
||||
|
@ -2487,7 +2487,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
}
|
||||
else
|
||||
if (sig->pinvoke)
|
||||
size = mono_type_native_stack_size (&in->klass->byval_arg, &align);
|
||||
size = mono_type_native_stack_size (m_class_get_byval_arg (in->klass), &align);
|
||||
else {
|
||||
/*
|
||||
* Other backends use mono_type_stack_size (), but that
|
||||
|
@ -2631,7 +2631,7 @@ mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src)
|
|||
if (cfg->compute_gc_maps) {
|
||||
MonoInst *def;
|
||||
|
||||
EMIT_NEW_GC_PARAM_SLOT_LIVENESS_DEF (cfg, def, ainfo->offset, &ins->klass->byval_arg);
|
||||
EMIT_NEW_GC_PARAM_SLOT_LIVENESS_DEF (cfg, def, ainfo->offset, m_class_get_byval_arg (ins->klass));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2762,7 +2762,7 @@ handle_enum:
|
|||
save_mode = SAVE_R8;
|
||||
break;
|
||||
case MONO_TYPE_VALUETYPE:
|
||||
if (mono_method_signature (method)->ret->data.klass->enumtype) {
|
||||
if (m_class_is_enumtype (mono_method_signature (method)->ret->data.klass)) {
|
||||
rtype = mono_class_enum_basetype (mono_method_signature (method)->ret->data.klass)->type;
|
||||
goto handle_enum;
|
||||
}
|
||||
|
@ -6648,7 +6648,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
|
|||
/*---------------------------------------------*/
|
||||
/* Patch the parameter passed to the handler */
|
||||
/*---------------------------------------------*/
|
||||
S390_SET (code, s390_r2, exc_class->type_token);
|
||||
S390_SET (code, s390_r2, m_class_get_type_token (exc_class));
|
||||
/*---------------------------------------------*/
|
||||
/* Load return address & parameter register */
|
||||
/*---------------------------------------------*/
|
||||
|
|
|
@ -912,7 +912,7 @@ mono_arch_allocate_vars (MonoCompile *cfg)
|
|||
ArgStorage storage;
|
||||
|
||||
if (sig->hasthis && (i == 0))
|
||||
arg_type = &mono_defaults.object_class->byval_arg;
|
||||
arg_type = m_class_get_byval_arg (mono_defaults.object_class);
|
||||
else
|
||||
arg_type = sig->params [i - sig->hasthis];
|
||||
|
||||
|
@ -1030,7 +1030,7 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
sig = mono_method_signature (cfg->method);
|
||||
|
||||
if (MONO_TYPE_ISSTRUCT ((sig->ret))) {
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG);
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_ARG);
|
||||
if (G_UNLIKELY (cfg->verbose_level > 1)) {
|
||||
printf ("vret_addr = ");
|
||||
mono_print_ins (cfg->vret_addr);
|
||||
|
@ -1046,7 +1046,7 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
}
|
||||
|
||||
/* Add a properly aligned dword for use by int<->float conversion opcodes */
|
||||
cfg->arch.float_spill_slot = mono_compile_create_var (cfg, &mono_defaults.double_class->byval_arg, OP_ARG);
|
||||
cfg->arch.float_spill_slot = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.double_class), OP_ARG);
|
||||
((MonoInst*)cfg->arch.float_spill_slot)->flags |= MONO_INST_VOLATILE;
|
||||
}
|
||||
|
||||
|
@ -1173,7 +1173,7 @@ emit_pass_vtype (MonoCompile *cfg, MonoCallInst *call, CallInfo *cinfo, ArgInfo
|
|||
align = sizeof (gpointer);
|
||||
}
|
||||
else if (pinvoke)
|
||||
size = mono_type_native_stack_size (&in->klass->byval_arg, &align);
|
||||
size = mono_type_native_stack_size (m_class_get_byval_arg (in->klass), &align);
|
||||
else {
|
||||
/*
|
||||
* Other backends use mono_type_stack_size (), but that
|
||||
|
@ -1303,7 +1303,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
in = call->args [i];
|
||||
|
||||
if (sig->hasthis && (i == 0))
|
||||
arg_type = &mono_defaults.object_class->byval_arg;
|
||||
arg_type = m_class_get_byval_arg (mono_defaults.object_class);
|
||||
else
|
||||
arg_type = sig->params [i - sig->hasthis];
|
||||
|
||||
|
@ -2130,7 +2130,7 @@ emit_load_volatile_arguments (MonoCompile *cfg, guint32 *code)
|
|||
inst = cfg->args [i];
|
||||
|
||||
if (sig->hasthis && (i == 0))
|
||||
arg_type = &mono_defaults.object_class->byval_arg;
|
||||
arg_type = m_class_get_byval_arg (mono_defaults.object_class);
|
||||
else
|
||||
arg_type = sig->params [i - sig->hasthis];
|
||||
|
||||
|
@ -3959,7 +3959,7 @@ mono_arch_emit_prolog (MonoCompile *cfg)
|
|||
inst = cfg->args [i];
|
||||
|
||||
if (sig->hasthis && (i == 0))
|
||||
arg_type = &mono_defaults.object_class->byval_arg;
|
||||
arg_type = m_class_get_byval_arg (mono_defaults.object_class);
|
||||
else
|
||||
arg_type = sig->params [i - sig->hasthis];
|
||||
|
||||
|
@ -4225,7 +4225,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
|
|||
sparc_patch ((guint32*)(cfg->native_code + patch_info->ip.i), code);
|
||||
|
||||
exc_class = mono_class_load_from_name (mono_defaults.corlib, "System", patch_info->data.name);
|
||||
type_idx = exc_class->type_token - MONO_TOKEN_TYPE_DEF;
|
||||
type_idx = m_class_get_type_token (exc_class) - MONO_TOKEN_TYPE_DEF;
|
||||
throw_ip = patch_info->ip.i;
|
||||
|
||||
/* Find a throw sequence for the same exception class */
|
||||
|
|
|
@ -804,7 +804,7 @@ list_frames (MonoStackFrameInfo *info, MonoContext *ctx, gpointer data)
|
|||
while (method->is_inflated)
|
||||
method = ((MonoMethodInflated*)method)->declaring;
|
||||
|
||||
char *assembly_name = g_strdup (method->klass->image->module_name);
|
||||
char *assembly_name = g_strdup (m_class_get_image (method->klass)->module_name);
|
||||
inplace_tolower (assembly_name);
|
||||
|
||||
if (method->wrapper_type == MONO_WRAPPER_NONE) {
|
||||
|
|
|
@ -231,7 +231,7 @@ add_valuetype (MonoMethodSignature *sig, ArgInfo *ainfo, MonoType *type,
|
|||
MonoClass *klass;
|
||||
|
||||
klass = mono_class_from_mono_type (type);
|
||||
size = mini_type_stack_size_full (&klass->byval_arg, NULL, sig->pinvoke);
|
||||
size = mini_type_stack_size_full (m_class_get_byval_arg (klass), NULL, sig->pinvoke);
|
||||
|
||||
#if defined(TARGET_WIN32)
|
||||
/*
|
||||
|
@ -1158,17 +1158,17 @@ mono_arch_create_vars (MonoCompile *cfg)
|
|||
if (cinfo->ret.storage == ArgValuetypeInReg)
|
||||
cfg->ret_var_is_local = TRUE;
|
||||
if ((cinfo->ret.storage != ArgValuetypeInReg) && (MONO_TYPE_ISSTRUCT (sig_ret) || mini_is_gsharedvt_variable_type (sig_ret))) {
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG);
|
||||
cfg->vret_addr = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_ARG);
|
||||
}
|
||||
|
||||
if (cfg->gen_sdb_seq_points) {
|
||||
MonoInst *ins;
|
||||
|
||||
ins = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
ins = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
ins->flags |= MONO_INST_VOLATILE;
|
||||
cfg->arch.ss_tramp_var = ins;
|
||||
|
||||
ins = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
|
||||
ins = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL);
|
||||
ins->flags |= MONO_INST_VOLATILE;
|
||||
cfg->arch.bp_tramp_var = ins;
|
||||
}
|
||||
|
@ -1291,7 +1291,7 @@ mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig)
|
|||
if (i >= sig->hasthis)
|
||||
t = sig->params [i - sig->hasthis];
|
||||
else
|
||||
t = &mono_defaults.int_class->byval_arg;
|
||||
t = m_class_get_byval_arg (mono_defaults.int_class);
|
||||
|
||||
linfo->args [i].storage = LLVMArgNone;
|
||||
|
||||
|
@ -1354,7 +1354,7 @@ emit_gc_param_slot_def (MonoCompile *cfg, int sp_offset, MonoType *t)
|
|||
|
||||
/* On x86, the offsets are from the sp value before the start of the call sequence */
|
||||
if (t == NULL)
|
||||
t = &mono_defaults.int_class->byval_arg;
|
||||
t = m_class_get_byval_arg (mono_defaults.int_class);
|
||||
EMIT_NEW_GC_PARAM_SLOT_LIVENESS_DEF (cfg, def, sp_offset, t);
|
||||
}
|
||||
}
|
||||
|
@ -1427,7 +1427,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
if (i >= sig->hasthis)
|
||||
t = sig->params [i - sig->hasthis];
|
||||
else
|
||||
t = &mono_defaults.int_class->byval_arg;
|
||||
t = m_class_get_byval_arg (mono_defaults.int_class);
|
||||
orig_type = t;
|
||||
t = mini_get_underlying_type (t);
|
||||
|
||||
|
@ -1459,7 +1459,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
align = sizeof (gpointer);
|
||||
}
|
||||
else {
|
||||
size = mini_type_stack_size_full (&in->klass->byval_arg, &align, sig->pinvoke);
|
||||
size = mini_type_stack_size_full (m_class_get_byval_arg (in->klass), &align, sig->pinvoke);
|
||||
}
|
||||
|
||||
if (size > 0 || ainfo->pass_empty_struct) {
|
||||
|
@ -1516,9 +1516,9 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
|
|||
/* this */
|
||||
if (call->need_unbox_trampoline)
|
||||
/* The unbox trampoline transforms this into a managed pointer */
|
||||
emit_gc_param_slot_def (cfg, ainfo->offset, &mono_defaults.int_class->this_arg);
|
||||
emit_gc_param_slot_def (cfg, ainfo->offset, m_class_get_this_arg (mono_defaults.int_class));
|
||||
else
|
||||
emit_gc_param_slot_def (cfg, ainfo->offset, &mono_defaults.object_class->byval_arg);
|
||||
emit_gc_param_slot_def (cfg, ainfo->offset, m_class_get_byval_arg (mono_defaults.object_class));
|
||||
} else {
|
||||
emit_gc_param_slot_def (cfg, ainfo->offset, orig_type);
|
||||
}
|
||||
|
@ -5435,7 +5435,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
|
|||
exc_throw_start [nthrows] = code;
|
||||
}
|
||||
|
||||
x86_push_imm (code, exc_class->type_token - MONO_TOKEN_TYPE_DEF);
|
||||
x86_push_imm (code, m_class_get_type_token (exc_class) - MONO_TOKEN_TYPE_DEF);
|
||||
patch_info->data.name = "mono_arch_throw_corlib_exception";
|
||||
patch_info->type = MONO_PATCH_INFO_INTERNAL_METHOD;
|
||||
patch_info->ip.i = code - cfg->native_code;
|
||||
|
@ -5632,7 +5632,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC
|
|||
|
||||
#if DEBUG_IMT
|
||||
{
|
||||
char *buff = g_strdup_printf ("thunk_for_class_%s_%s_entries_%d", vtable->klass->name_space, vtable->klass->name, count);
|
||||
char *buff = g_strdup_printf ("thunk_for_class_%s_%s_entries_%d", m_class_get_name_space (vtable->klass), m_class_get_name (vtable->klass), count);
|
||||
mono_disassemble_code (NULL, (guint8*)start, code - start, buff);
|
||||
g_free (buff);
|
||||
}
|
||||
|
@ -5640,7 +5640,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC
|
|||
if (mono_jit_map_is_enabled ()) {
|
||||
char *buff;
|
||||
if (vtable)
|
||||
buff = g_strdup_printf ("imt_%s_%s_entries_%d", vtable->klass->name_space, vtable->klass->name, count);
|
||||
buff = g_strdup_printf ("imt_%s_%s_entries_%d", m_class_get_name_space (vtable->klass), m_class_get_name (vtable->klass), count);
|
||||
else
|
||||
buff = g_strdup_printf ("imt_trampoline_entries_%d", count);
|
||||
mono_emit_jit_tramp (start, code - start, buff);
|
||||
|
@ -6121,7 +6121,7 @@ static MonoInst*
|
|||
get_float_to_x_spill_area (MonoCompile *cfg)
|
||||
{
|
||||
if (!cfg->fconv_to_r8_x_var) {
|
||||
cfg->fconv_to_r8_x_var = mono_compile_create_var (cfg, &mono_defaults.double_class->byval_arg, OP_LOCAL);
|
||||
cfg->fconv_to_r8_x_var = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.double_class), OP_LOCAL);
|
||||
cfg->fconv_to_r8_x_var->flags |= MONO_INST_VOLATILE; /*FIXME, use the don't regalloc flag*/
|
||||
}
|
||||
return cfg->fconv_to_r8_x_var;
|
||||
|
|
Загрузка…
Ссылка в новой задаче