From 3aeab61192b632202d60de2061d4faede8c89ed7 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Aleksey=20Kliger=20=28=CE=BBgeek=29?= Date: Fri, 23 Mar 2018 11:01:10 -0400 Subject: [PATCH] [mini] Use MonoClass getters in a few files (#7771) * [metadata] Use getters in a few ilgen files * [mini] Use MonoClass getters in several files * [mini] Use MonoClass getters in mini-generic-sharing.c * [debugger-agent] Use MonoClass getters * [monodis] Use MonoClass getters in get.c --- mono/dis/get.c | 40 +++---- mono/metadata/marshal-ilgen.c | 4 +- mono/metadata/method-builder-ilgen.c | 2 +- mono/mini/alias-analysis.c | 10 +- mono/mini/aot-runtime-wasm.c | 4 +- mono/mini/aot-runtime.c | 81 ++++++------- mono/mini/branch-opts.c | 2 +- mono/mini/cfgdump.c | 8 +- mono/mini/debugger-agent.c | 183 +++++++++++++++--------------- mono/mini/decompose.c | 16 +-- mono/mini/driver.c | 2 +- mono/mini/dwarfwriter.c | 52 ++++----- mono/mini/exceptions-amd64.c | 2 +- mono/mini/jit-icalls.c | 54 ++++----- mono/mini/memory-access.c | 10 +- mono/mini/mini-amd64.c | 32 +++--- mono/mini/mini-codegen.c | 6 +- mono/mini/mini-exceptions.c | 20 ++-- mono/mini/mini-generic-sharing.c | 214 ++++++++++++++++++----------------- mono/mini/mini-native-types.c | 35 +++--- mono/mini/mini-profiler.c | 2 +- mono/mini/mini-runtime.c | 14 +-- mono/mini/mini-trampolines.c | 22 ++-- mono/mini/mini.c | 61 +++++----- mono/mini/mini.h | 2 +- mono/mini/simd-intrinsics.c | 61 +++++----- mono/mini/ssa.c | 2 +- mono/mini/trace.c | 8 +- mono/mini/type-checking.c | 97 ++++++++-------- 29 files changed, 530 insertions(+), 516 deletions(-) diff --git a/mono/dis/get.c b/mono/dis/get.c index 0a71c94016c..dfd5267f831 100755 --- a/mono/dis/get.c +++ b/mono/dis/get.c @@ -500,7 +500,7 @@ dis_stringify_array (MonoImage *m, MonoArrayType *array, gboolean is_def) { char *type, *arr_str, *ret; - type = dis_stringify_type (m, &array->eklass->byval_arg, is_def); + type = dis_stringify_type (m, m_class_get_byval_arg (array->eklass), is_def); arr_str = stringify_array (array->rank, array->numsizes, array->numlobounds, array->sizes, array->lobounds); ret = g_strconcat (type, arr_str, NULL); @@ -827,7 +827,7 @@ get_generic_param (MonoImage *m, MonoGenericContainer *container) first = 0; } else g_string_append (result, ", "); - sig = dis_stringify_type (m, &((*constr)->byval_arg), TRUE); + sig = dis_stringify_type (m, m_class_get_byval_arg (*constr), TRUE); g_string_append (result, sig); g_free (sig); } @@ -1054,22 +1054,22 @@ get_escaped_class_name (MonoClass *c) { char *result, *esname; - if (c->type_token == mono_metadata_make_token (MONO_TABLE_TYPEDEF, 1)) + if (m_class_get_type_token (c) == mono_metadata_make_token (MONO_TABLE_TYPEDEF, 1)) /* */ return NULL; - if (c->rank || c->byval_arg.type == MONO_TYPE_PTR) + if (m_class_get_rank (c) || m_class_get_byval_arg (c)->type == MONO_TYPE_PTR) g_assert (0); - esname = get_escaped_name (c->name); + esname = get_escaped_name (m_class_get_name (c)); - if (c->nested_in){ - char *part_a = get_escaped_class_name (c->nested_in); + if (m_class_get_nested_in (c)){ + char *part_a = get_escaped_class_name (m_class_get_nested_in (c)); result = g_strdup_printf ("%s/%s", part_a, esname); g_free (part_a); - } else if (*c->name_space) - result = g_strdup_printf ("%s.%s", c->name_space, esname); + } else if (*m_class_get_name_space (c)) + result = g_strdup_printf ("%s.%s", m_class_get_name_space (c), esname); else result = g_strdup (esname); @@ -1081,27 +1081,27 @@ char * dis_stringify_object_with_class (MonoImage *m, MonoClass *c, gboolean prefix, gboolean is_def) { /* FIXME: handle MONO_TYPE_OBJECT ... */ - MonoType *type = &c->byval_arg; + MonoType *type = m_class_get_byval_arg (c); const char *otype = type->type == MONO_TYPE_VALUETYPE ? "valuetype " : "class " ; char *assemblyref = NULL, *result, *esname, *generic = NULL; - if (c->type_token == mono_metadata_make_token (MONO_TABLE_TYPEDEF, 1)) + if (m_class_get_type_token (c) == mono_metadata_make_token (MONO_TABLE_TYPEDEF, 1)) /* */ return NULL; - if (m != c->image) { - if (c->image->assembly_name) { + if (m != m_class_get_image (c)) { + if (m_class_get_image (c)->assembly_name) { /* we cheat */ - if (substitute_with_mscorlib_p && !strcmp ("corlib", c->image->assembly_name)) + if (substitute_with_mscorlib_p && !strcmp ("corlib", m_class_get_image (c)->assembly_name)) assemblyref = g_strdup_printf ("[%s]", "mscorlib"); else { - char *esc = get_escaped_name (c->image->assembly->aname.name); + char *esc = get_escaped_name (m_class_get_image (c)->assembly->aname.name); assemblyref = g_strdup_printf ("[%s]", esc); g_free (esc); } } else { - assemblyref = g_strdup_printf ("[.module %s]", c->image->module_name); + assemblyref = g_strdup_printf ("[.module %s]", m_class_get_image (c)->module_name); } } @@ -1195,7 +1195,7 @@ dis_stringify_type (MonoImage *m, MonoType *type, gboolean is_def) } case MONO_TYPE_SZARRAY: { char *child_type; - child_type = dis_stringify_type (m, &type->data.klass->byval_arg, is_def); + child_type = dis_stringify_type (m, m_class_get_byval_arg (type->data.klass), is_def); bare = g_strdup_printf ("%s[]", child_type); g_free (child_type); @@ -1224,7 +1224,7 @@ dis_stringify_type (MonoImage *m, MonoType *type, gboolean is_def) MonoGenericInst *inst; int i; char *generic_type = dis_stringify_type ( - m, &type->data.generic_class->container_class->byval_arg, is_def); + m, m_class_get_byval_arg (type->data.generic_class->container_class), is_def); inst = type->data.generic_class->context.class_inst; for (i = 0; i < inst->type_argc; i++){ char *t = dis_stringify_type (m, inst->type_argv [i], is_def); @@ -1950,7 +1950,7 @@ get_method_core (MonoImage *m, guint32 token, gboolean fullsig, MonoGenericConta if (mono_method_signature (mh)->is_inflated) container = mono_method_get_generic_container (((MonoMethodInflated *) mh)->declaring); esname = get_escaped_name (mh->name); - sig = dis_stringify_type (m, &mh->klass->byval_arg, TRUE); + sig = dis_stringify_type (m, m_class_get_byval_arg (mh->klass), TRUE); char *token_comment = get_token_comment (NULL, token); name = g_strdup_printf ("%s%s%s%s", sig ? sig : "", token_comment ? token_comment : "", sig ? "::" : "", esname); g_free (sig); @@ -2052,7 +2052,7 @@ get_methoddef (MonoImage *m, guint32 idx) mh = mono_get_method_checked (m, MONO_TOKEN_METHOD_DEF | idx, NULL, NULL, error); if (mh) { - sig = dis_stringify_type (m, &mh->klass->byval_arg, FALSE); + sig = dis_stringify_type (m, m_class_get_byval_arg (mh->klass), FALSE); name = g_strdup_printf ("%s%s%s", sig ? sig : "", sig ? "::" : "", diff --git a/mono/metadata/marshal-ilgen.c b/mono/metadata/marshal-ilgen.c index 9882ccabfda..155578629c9 100644 --- a/mono/metadata/marshal-ilgen.c +++ b/mono/metadata/marshal-ilgen.c @@ -4069,9 +4069,9 @@ emit_thunk_invoke_wrapper_ilgen (MonoMethodBuilder *mb, MonoMethod *method, Mono if (mono_threads_is_blocking_transition_enabled ()) { /* local 4, dummy local used to get a stack address for suspend funcs */ - coop_gc_stack_dummy = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg); + coop_gc_stack_dummy = mono_mb_add_local (mb, m_class_get_byval_arg (mono_defaults.int_class)); /* local 5, the local to be used when calling the suspend funcs */ - coop_gc_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg); + coop_gc_var = mono_mb_add_local (mb, m_class_get_byval_arg (mono_defaults.int_class)); } /* clear exception arg */ diff --git a/mono/metadata/method-builder-ilgen.c b/mono/metadata/method-builder-ilgen.c index 457845e3f66..52cb0c51489 100644 --- a/mono/metadata/method-builder-ilgen.c +++ b/mono/metadata/method-builder-ilgen.c @@ -84,7 +84,7 @@ create_method_ilgen (MonoMethodBuilder *mb, MonoMethodSignature *signature, int g_assert (mb != NULL); - image = mb->method->klass->image; + image = m_class_get_image (mb->method->klass); if (mb->dynamic) { method = mb->method; diff --git a/mono/mini/alias-analysis.c b/mono/mini/alias-analysis.c index ac19225a067..b6d57d3fa80 100644 --- a/mono/mini/alias-analysis.c +++ b/mono/mini/alias-analysis.c @@ -43,12 +43,12 @@ static gboolean lower_load (MonoCompile *cfg, MonoInst *load, MonoInst *ldaddr) { MonoInst *var = (MonoInst *)ldaddr->inst_p0; - MonoType *type = &var->klass->byval_arg; + MonoType *type = m_class_get_byval_arg (var->klass); int replaced_op = mono_type_to_load_membase (cfg, type); if (load->opcode == OP_LOADV_MEMBASE && load->klass != var->klass) { if (cfg->verbose_level > 2) - printf ("Incompatible load_vtype classes %s x %s\n", load->klass->name, var->klass->name); + printf ("Incompatible load_vtype classes %s x %s\n", m_class_get_name (load->klass), m_class_get_name (var->klass)); return FALSE; } @@ -73,12 +73,12 @@ static gboolean lower_store (MonoCompile *cfg, MonoInst *store, MonoInst *ldaddr) { MonoInst *var = (MonoInst *)ldaddr->inst_p0; - MonoType *type = &var->klass->byval_arg; + MonoType *type = m_class_get_byval_arg (var->klass); int replaced_op = mono_type_to_store_membase (cfg, type); if (store->opcode == OP_STOREV_MEMBASE && store->klass != var->klass) { if (cfg->verbose_level > 2) - printf ("Incompatible store_vtype classes %s x %s\n", store->klass->name, store->klass->name); + printf ("Incompatible store_vtype classes %s x %s\n", m_class_get_name (store->klass), m_class_get_name (store->klass)); return FALSE; } @@ -108,7 +108,7 @@ static gboolean lower_store_imm (MonoCompile *cfg, MonoInst *store, MonoInst *ldaddr) { MonoInst *var = (MonoInst *)ldaddr->inst_p0; - MonoType *type = &var->klass->byval_arg; + MonoType *type = m_class_get_byval_arg (var->klass); int store_op = mono_type_to_store_membase (cfg, type); if (store_op == OP_STOREV_MEMBASE || store_op == OP_STOREX_MEMBASE) return FALSE; diff --git a/mono/mini/aot-runtime-wasm.c b/mono/mini/aot-runtime-wasm.c index 18febb2b73b..b7a07544f6e 100644 --- a/mono/mini/aot-runtime-wasm.c +++ b/mono/mini/aot-runtime-wasm.c @@ -77,14 +77,14 @@ handle_enum: case MONO_TYPE_VOID: return 'V'; case MONO_TYPE_VALUETYPE: - if (t->data.klass->enumtype) { + if (m_class_is_enum_type (t->data.klass)) { t = mono_class_enum_basetype (t->data.klass); goto handle_enum; } return 'I'; case MONO_TYPE_GENERICINST: - if (t->data.klass->valuetype) + if (m_class_is_valuetype (t->data.klass)) return 'S'; return 'I'; default: diff --git a/mono/mini/aot-runtime.c b/mono/mini/aot-runtime.c index 63faa88e30d..893e4f092d7 100644 --- a/mono/mini/aot-runtime.c +++ b/mono/mini/aot-runtime.c @@ -397,7 +397,7 @@ decode_generic_inst (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoEr g_free (type_argv); return NULL; } - type_argv [i] = &pclass->byval_arg; + type_argv [i] = m_class_get_byval_arg (pclass); } inst = mono_metadata_get_generic_inst (type_argc, type_argv); @@ -492,7 +492,7 @@ decode_klass_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError ctx.class_inst = decode_generic_inst (module, p, &p, error); if (!ctx.class_inst) return NULL; - type = mono_class_inflate_generic_type_checked (&gclass->byval_arg, &ctx, error); + type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (gclass), &ctx, error); if (!type) return NULL; klass = mono_class_from_mono_type (type); @@ -516,7 +516,7 @@ decode_klass_ref (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError if (!par_klass) return NULL; - t = mini_get_shared_gparam (&par_klass->byval_arg, gshared_constraint); + t = mini_get_shared_gparam (m_class_get_byval_arg (par_klass), gshared_constraint); mono_metadata_free_type (gshared_constraint); klass = mono_class_from_mono_type (t); } else { @@ -703,7 +703,7 @@ decode_type (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError *err ctx.class_inst = decode_generic_inst (module, p, &p, error); if (!ctx.class_inst) goto fail; - type = mono_class_inflate_generic_type_checked (&gclass->byval_arg, &ctx, error); + type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (gclass), &ctx, error); if (!type) goto fail; klass = mono_class_from_mono_type (type); @@ -740,7 +740,7 @@ decode_type (MonoAotModule *module, guint8 *buf, guint8 **endbuf, MonoError *err MonoClass *klass = decode_klass_ref (module, p, &p, error); if (!klass) goto fail; - t->data.generic_param = klass->byval_arg.data.generic_param; + t->data.generic_param = m_class_get_byval_arg (klass)->data.generic_param; break; } default: @@ -922,12 +922,13 @@ decode_method_ref_with_target (MonoAotModule *module, MethodRef *ref, MonoMethod MonoClass *klass = decode_klass_ref (module, p, &p, error); if (!klass) return FALSE; + MonoType *type = m_class_get_byval_arg (klass); if (wrapper_type == MONO_WRAPPER_LDFLD) - ref->method = mono_marshal_get_ldfld_wrapper (&klass->byval_arg); + ref->method = mono_marshal_get_ldfld_wrapper (type); else if (wrapper_type == MONO_WRAPPER_LDFLDA) - ref->method = mono_marshal_get_ldflda_wrapper (&klass->byval_arg); + ref->method = mono_marshal_get_ldflda_wrapper (type); else if (wrapper_type == MONO_WRAPPER_STFLD) - ref->method = mono_marshal_get_stfld_wrapper (&klass->byval_arg); + ref->method = mono_marshal_get_stfld_wrapper (type); else { mono_error_set_bad_image_by_name (error, module->aot_name, "Unknown AOT wrapper type %d", wrapper_type); return FALSE; @@ -1306,10 +1307,10 @@ decode_method_ref_with_target (MonoAotModule *module, MethodRef *ref, MonoMethod method_type = decode_value (p, &p); switch (method_type) { case 0: - ref->method = mono_class_get_method_from_name (klass, ".ctor", klass->rank); + ref->method = mono_class_get_method_from_name (klass, ".ctor", m_class_get_rank (klass)); break; case 1: - ref->method = mono_class_get_method_from_name (klass, ".ctor", klass->rank * 2); + ref->method = mono_class_get_method_from_name (klass, ".ctor", m_class_get_rank (klass) * 2); break; case 2: ref->method = mono_class_get_method_from_name (klass, "Get", -1); @@ -2460,7 +2461,7 @@ mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int sl { int i; MonoClass *klass = vtable->klass; - MonoAotModule *amodule = (MonoAotModule *)klass->image->aot_module; + MonoAotModule *amodule = (MonoAotModule *)m_class_get_image (klass)->aot_module; guint8 *info, *p; MonoCachedClassInfo class_info; gboolean err; @@ -2471,10 +2472,10 @@ mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int sl error_init (error); - if (MONO_CLASS_IS_INTERFACE (klass) || klass->rank || !amodule) + if (MONO_CLASS_IS_INTERFACE (klass) || m_class_get_rank (klass) || !amodule) return NULL; - info = &amodule->blob [mono_aot_get_offset (amodule->class_info_offsets, mono_metadata_token_index (klass->type_token) - 1)]; + info = &amodule->blob [mono_aot_get_offset (amodule->class_info_offsets, mono_metadata_token_index (m_class_get_type_token (klass)) - 1)]; p = info; err = decode_cached_class_info (amodule, &class_info, p, &p); @@ -2503,14 +2504,14 @@ mono_aot_get_method_from_vt_slot (MonoDomain *domain, MonoVTable *vtable, int sl gboolean mono_aot_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res) { - MonoAotModule *amodule = (MonoAotModule *)klass->image->aot_module; + MonoAotModule *amodule = (MonoAotModule *)m_class_get_image (klass)->aot_module; guint8 *p; gboolean err; - if (klass->rank || !klass->type_token || !amodule) + if (m_class_get_rank (klass) || !m_class_get_type_token (klass) || !amodule) return FALSE; - p = (guint8*)&amodule->blob [mono_aot_get_offset (amodule->class_info_offsets, mono_metadata_token_index (klass->type_token) - 1)]; + p = (guint8*)&amodule->blob [mono_aot_get_offset (amodule->class_info_offsets, mono_metadata_token_index (m_class_get_type_token (klass)) - 1)]; err = decode_cached_class_info (amodule, res, p, &p); if (!err) @@ -3223,7 +3224,7 @@ decode_exception_debug_info (MonoAotModule *amodule, MonoDomain *domain, p += map_size; } - if (amodule != jinfo->d.method->klass->image->aot_module) { + if (amodule != m_class_get_image (jinfo->d.method->klass)->aot_module) { mono_aot_lock (); if (!ji_to_amodule) ji_to_amodule = g_hash_table_new (NULL, NULL); @@ -3256,7 +3257,7 @@ mono_aot_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len) if (ji->async) amodule = (MonoAotModule *)ji->d.aot_info; else - amodule = (MonoAotModule *)jinfo_get_method (ji)->klass->image->aot_module; + amodule = (MonoAotModule *)m_class_get_image (jinfo_get_method (ji)->klass)->aot_module; g_assert (amodule); g_assert (ji->from_aot); @@ -3711,7 +3712,7 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin mono_error_cleanup (error); /* FIXME don't swallow the error */ if (!ji->data.klass) goto cleanup; - ji->data.name = ji->data.klass->name; + ji->data.name = m_class_get_name (ji->data.klass); break; case MONO_PATCH_INFO_METHOD_REL: ji->data.offset = decode_value (p, &p); @@ -3788,7 +3789,7 @@ decode_patch (MonoAotModule *aot_module, MonoMemPool *mp, MonoJumpInfo *ji, guin mono_error_cleanup (error); /* FIXME don't swallow the error */ if (!klass) goto cleanup; - template_->data = &klass->byval_arg; + template_->data = m_class_get_byval_arg (klass); break; } case MONO_PATCH_INFO_FIELD: @@ -4116,7 +4117,7 @@ find_aot_method_in_amodule (MonoAotModule *code_amodule, MonoMethod *method, gui // The reference to the metadata amodule will differ among multiple dedup methods // which mangle to the same name but live in different assemblies. This leads to // the caching breaking. The solution seems to be to cache using the "metadata" amodule. - MonoAotModule *metadata_amodule = (MonoAotModule *)method->klass->image->aot_module; + MonoAotModule *metadata_amodule = (MonoAotModule *)m_class_get_image (method->klass)->aot_module; if (!metadata_amodule || metadata_amodule->out_of_date || !code_amodule || code_amodule->out_of_date) return 0xffffff; @@ -4224,8 +4225,8 @@ find_aot_method (MonoMethod *method, MonoAotModule **out_amodule) } /* Try the method's module first */ - *out_amodule = (MonoAotModule *)method->klass->image->aot_module; - index = find_aot_method_in_amodule ((MonoAotModule *)method->klass->image->aot_module, method, hash); + *out_amodule = (MonoAotModule *)m_class_get_image (method->klass)->aot_module; + index = find_aot_method_in_amodule ((MonoAotModule *)m_class_get_image (method->klass)->aot_module, method, hash); if (index != 0xffffff) return index; @@ -4246,7 +4247,7 @@ find_aot_method (MonoMethod *method, MonoAotModule **out_amodule) for (i = 0; i < modules->len; ++i) { MonoAotModule *amodule = (MonoAotModule *)g_ptr_array_index (modules, i); - if (amodule != method->klass->image->aot_module) + if (amodule != m_class_get_image (method->klass)->aot_module) index = find_aot_method_in_amodule (amodule, method, hash); if (index != 0xffffff) { *out_amodule = amodule; @@ -4493,7 +4494,7 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error) MonoClass *klass = method->klass; MonoMethod *orig_method = method; guint32 method_index; - MonoAotModule *amodule = (MonoAotModule *)klass->image->aot_module; + MonoAotModule *amodule = (MonoAotModule *)m_class_get_image (klass)->aot_module; guint8 *code; gboolean cache_result = FALSE; ERROR_DECL_VALUE (inner_error); @@ -4504,12 +4505,12 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error) /* Non shared AOT code can't be used in other appdomains */ return NULL; - if (enable_aot_cache && !amodule && domain->entry_assembly && klass->image == mono_defaults.corlib) { + if (enable_aot_cache && !amodule && domain->entry_assembly && m_class_get_image (klass) == mono_defaults.corlib) { /* This cannot be AOTed during startup, so do it now */ if (!mscorlib_aot_loaded) { mscorlib_aot_loaded = TRUE; - load_aot_module (klass->image->assembly, NULL); - amodule = (MonoAotModule *)klass->image->aot_module; + load_aot_module (m_class_get_image (klass)->assembly, NULL); + amodule = (MonoAotModule *)m_class_get_image (klass)->aot_module; } } @@ -4533,7 +4534,7 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error) if (mono_aot_only && method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK) return mono_aot_get_method (domain, mono_marshal_method_from_wrapper (method), error); - g_assert (klass->inited); + g_assert (m_class_is_inited (klass)); /* Find method index */ method_index = 0xffffff; @@ -4575,7 +4576,7 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error) * be statically enumerated, and each wrapper ends up calling the same * method in Array. */ - if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED && method->klass->rank && strstr (method->name, "System.Collections.Generic")) { + if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED && m_class_get_rank (method->klass) && strstr (method->name, "System.Collections.Generic")) { MonoMethod *m = mono_aot_get_array_helper_from_wrapper (method); code = (guint8 *)mono_aot_get_method (domain, m, &inner_error); @@ -4602,7 +4603,7 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error) g_assert (m); memset (&ctx, 0, sizeof (ctx)); - args [0] = &mono_defaults.object_class->byval_arg; + args [0] = m_class_get_byval_arg (mono_defaults.object_class); ctx.method_inst = mono_metadata_get_generic_inst (1, args); m = mono_marshal_get_native_wrapper (mono_class_inflate_generic_method_checked (m, &ctx, error), TRUE, TRUE); @@ -4619,12 +4620,14 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error) return code; } + const char *klass_name_space = m_class_get_name_space (method->klass); + const char *klass_name = m_class_get_name (method->klass); /* Same for CompareExchange and Exchange */ /* Same for Volatile.Read/Write */ - if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE && method->klass->image == mono_defaults.corlib && - ((!strcmp (method->klass->name_space, "System.Threading") && !strcmp (method->klass->name, "Interlocked") && (!strcmp (method->name, "CompareExchange") || !strcmp (method->name, "Exchange")) && MONO_TYPE_IS_REFERENCE (mini_type_get_underlying_type (mono_method_signature (method)->params [1]))) || - (!strcmp (method->klass->name_space, "System.Threading") && !strcmp (method->klass->name, "Volatile") && (!strcmp (method->name, "Read") && MONO_TYPE_IS_REFERENCE (mini_type_get_underlying_type (mono_method_signature (method)->ret)))) || - (!strcmp (method->klass->name_space, "System.Threading") && !strcmp (method->klass->name, "Volatile") && (!strcmp (method->name, "Write") && MONO_TYPE_IS_REFERENCE (mini_type_get_underlying_type (mono_method_signature (method)->params [1])))))) { + if (method_index == 0xffffff && method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE && m_class_get_image (method->klass) == mono_defaults.corlib && + ((!strcmp (klass_name_space, "System.Threading") && !strcmp (klass_name, "Interlocked") && (!strcmp (method->name, "CompareExchange") || !strcmp (method->name, "Exchange")) && MONO_TYPE_IS_REFERENCE (mini_type_get_underlying_type (mono_method_signature (method)->params [1]))) || + (!strcmp (klass_name_space, "System.Threading") && !strcmp (klass_name, "Volatile") && (!strcmp (method->name, "Read") && MONO_TYPE_IS_REFERENCE (mini_type_get_underlying_type (mono_method_signature (method)->ret)))) || + (!strcmp (klass_name_space, "System.Threading") && !strcmp (klass_name, "Volatile") && (!strcmp (method->name, "Write") && MONO_TYPE_IS_REFERENCE (mini_type_get_underlying_type (mono_method_signature (method)->params [1])))))) { MonoMethod *m; MonoGenericContext ctx; MonoType *args [16]; @@ -4637,7 +4640,7 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error) g_assert (m); memset (&ctx, 0, sizeof (ctx)); - args [0] = &mono_defaults.object_class->byval_arg; + args [0] = m_class_get_byval_arg (mono_defaults.object_class); ctx.method_inst = mono_metadata_get_generic_inst (1, args); m = mono_marshal_get_native_wrapper (mono_class_inflate_generic_method_checked (m, &ctx, error), TRUE, TRUE); @@ -4664,7 +4667,7 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error) if (info->subtype == WRAPPER_SUBTYPE_ARRAY_ACCESSOR) { MonoMethod *array_method = info->d.array_accessor.method; - if (MONO_TYPE_IS_REFERENCE (&array_method->klass->element_class->byval_arg)) { + if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (m_class_get_element_class (array_method->klass)))) { int rank; if (!strcmp (array_method->name, "Set")) @@ -4739,7 +4742,7 @@ mono_aot_get_method (MonoDomain *domain, MonoMethod *method, MonoError *error) method_index = mono_metadata_token_index (method->token) - 1; } - code = (guint8 *)load_method (domain, amodule, klass->image, method, method->token, method_index, error); + code = (guint8 *)load_method (domain, amodule, m_class_get_image (klass), method, method->token, method_index, error); if (!is_ok (error)) return NULL; if (code && cache_result) { @@ -5680,7 +5683,7 @@ mono_aot_get_unbox_trampoline (MonoMethod *method) } g_assert (method_index != 0xffffff); } else { - amodule = (MonoAotModule *)method->klass->image->aot_module; + amodule = (MonoAotModule *)m_class_get_image (method->klass)->aot_module; g_assert (amodule); } diff --git a/mono/mini/branch-opts.c b/mono/mini/branch-opts.c index 4280c595ef7..0ac008af4d6 100644 --- a/mono/mini/branch-opts.c +++ b/mono/mini/branch-opts.c @@ -94,7 +94,7 @@ mono_branch_optimize_exception_target (MonoCompile *cfg, MonoBasicBlock *bb, con jump->inst_true_bb = targetbb; if (cfg->verbose_level > 2) - g_print ("found exception to optimize - returning branch to BB%d (%s) (instead of throw) for method %s:%s\n", targetbb->block_num, clause->data.catch_class->name, cfg->method->klass->name, cfg->method->name); + g_print ("found exception to optimize - returning branch to BB%d (%s) (instead of throw) for method %s:%s\n", targetbb->block_num, m_class_get_name (clause->data.catch_class), m_class_get_name (cfg->method->klass), cfg->method->name); return jump; } diff --git a/mono/mini/cfgdump.c b/mono/mini/cfgdump.c index 36c9ffac877..3cd62c5afb1 100644 --- a/mono/mini/cfgdump.c +++ b/mono/mini/cfgdump.c @@ -137,7 +137,7 @@ add_pool_entry (MonoCompile *cfg, ConstantPoolEntry *entry) case PT_KLASS: { MonoClass *klass = (MonoClass *) entry->data; write_byte (cfg, POOL_KLASS); - write_string (cfg, klass->name); + write_string (cfg, m_class_get_name (klass)); write_byte (cfg, KLASS); break; } @@ -242,7 +242,7 @@ mono_cfg_dump_begin_group (MonoCompile *cfg) return; write_byte (cfg, BEGIN_GROUP); char *title = (char *) mono_mempool_alloc0 (cfg->mempool, 0x2000); - sprintf (title, "%s::%s", cfg->method->klass->name, cfg->method->name); + sprintf (title, "%s::%s", m_class_get_name (cfg->method->klass), cfg->method->name); write_pool (cfg, create_cp_entry (cfg, (void *) title, PT_STRING)); write_pool (cfg, create_cp_entry (cfg, (void *) cfg->method->name, PT_STRING)); write_pool (cfg, create_cp_entry (cfg, (void *) cfg->method, PT_METHOD)); @@ -433,7 +433,7 @@ constant_pool_hash (ConstantPoolEntry *entry) return g_str_hash (method->name) ^ g_str_hash (method->klass); } case PT_KLASS: - return g_str_hash (((MonoClass *) entry->data)->name); + return g_str_hash (m_class_get_name ((MonoClass *) entry->data)); case PT_OPTYPE: return instruction_hash ((MonoInst *) entry->data); case PT_SIGNATURE: { @@ -503,7 +503,7 @@ void mono_cfg_dump_create_context (MonoCompile *cfg) if (strcmp (cfg->method->name, name) != 0) return; - g_debug ("cfg_dump: create context for \"%s::%s\"", cfg->method->klass->name, cfg->method->name); + g_debug ("cfg_dump: create context for \"%s::%s\"", m_class_get_name (cfg->method->klass), cfg->method->name); int fd = create_socket (DEFAULT_HOST, DEFAULT_PORT); if (fd < 0) { g_warning ("cfg_dump: couldn't create socket: %s::%d", DEFAULT_HOST, DEFAULT_PORT); diff --git a/mono/mini/debugger-agent.c b/mono/mini/debugger-agent.c index 74531d6bf53..97cbe7bebdf 100644 --- a/mono/mini/debugger-agent.c +++ b/mono/mini/debugger-agent.c @@ -2375,7 +2375,7 @@ decode_typeid (guint8 *buf, guint8 **endbuf, guint8 *limit, MonoDomain **domain, if (G_UNLIKELY (log_level >= 2) && klass) { char *s; - s = mono_type_full_name (&klass->byval_arg); + s = mono_type_full_name (m_class_get_byval_arg (klass)); DEBUG_PRINTF (2, "[dbg] recv class [%s]\n", s); g_free (s); } @@ -2435,7 +2435,7 @@ buffer_add_typeid (Buffer *buf, MonoDomain *domain, MonoClass *klass) if (G_UNLIKELY (log_level >= 2) && klass) { char *s; - s = mono_type_full_name (&klass->byval_arg); + s = mono_type_full_name (m_class_get_byval_arg (klass)); if (is_debugger_thread ()) DEBUG_PRINTF (2, "[dbg] send class [%s]\n", s); else @@ -3506,7 +3506,7 @@ create_event_list (EventKind event, GPtrArray *reqs, MonoJitInfo *ji, EventInfo if (assemblies) { for (k = 0; assemblies [k]; ++k) - if (assemblies [k] == jinfo_get_method (ji)->klass->image->assembly) + if (assemblies [k] == m_class_get_image (jinfo_get_method (ji)->klass)->assembly) found = TRUE; } if (!found) @@ -3553,7 +3553,7 @@ create_event_list (EventKind event, GPtrArray *reqs, MonoJitInfo *ji, EventInfo } else if (mod->kind == MOD_KIND_TYPE_NAME_ONLY && ei && ei->klass) { char *s; - s = mono_type_full_name (&ei->klass->byval_arg); + s = mono_type_full_name (m_class_get_byval_arg (ei->klass)); if (!g_hash_table_lookup (mod->data.type_names, s)) filtered = TRUE; g_free (s); @@ -4797,7 +4797,7 @@ ss_update (SingleStepReq *req, MonoJitInfo *ji, SeqPoint *sp, DebuggerTlsData *t static gboolean breakpoint_matches_assembly (MonoBreakpoint *bp, MonoAssembly *assembly) { - return bp->method && bp->method->klass->image->assembly == assembly; + return bp->method && m_class_get_image (bp->method->klass)->assembly == assembly; } static gpointer @@ -4858,7 +4858,7 @@ get_async_method_builder (StackFrame *frame) if (!this_addr) return NULL; - if (frame->method->klass->valuetype) { + if (m_class_is_valuetype (frame->method->klass)) { guint8 *vtaddr = *(guint8**)this_addr; builder = (char*)vtaddr + builder_field->offset - sizeof (MonoObject); } else { @@ -5321,7 +5321,7 @@ process_single_step_inner (DebuggerTlsData *tls, gboolean from_signal) if (ss_req->user_assemblies) { gboolean found = FALSE; for (int k = 0; ss_req->user_assemblies[k]; k++) - if (ss_req->user_assemblies[k] == method->klass->image->assembly) { + if (ss_req->user_assemblies[k] == m_class_get_image (method->klass)->assembly) { found = TRUE; break; } @@ -6125,7 +6125,7 @@ mono_debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx for (l = agent_config.onthrow; l; l = l->next) { char *ex_type = (char *)l->data; - char *f = mono_type_full_name (&exc->object.vtable->klass->byval_arg); + char *f = mono_type_full_name (m_class_get_byval_arg (exc->object.vtable->klass)); if (!strcmp (ex_type, "") || !strcmp (ex_type, f)) found = TRUE; @@ -6176,7 +6176,7 @@ mono_debugger_agent_handle_exception (MonoException *exc, MonoContext *throw_ctx if (assemblies) { for (k = 0; assemblies [k]; ++k) - if (assemblies [k] == jinfo_get_method (catch_ji)->klass->image->assembly) + if (assemblies [k] == m_class_get_image (jinfo_get_method (catch_ji)->klass)->assembly) found = TRUE; } if (!found) @@ -6358,17 +6358,17 @@ buffer_add_value_full (Buffer *buf, MonoType *t, void *addr, MonoDomain *domain, if (!obj) { buffer_add_byte (buf, VALUE_TYPE_ID_NULL); } else { - if (obj->vtable->klass->valuetype) { - t = &obj->vtable->klass->byval_arg; + if (m_class_is_valuetype (obj->vtable->klass)) { + t = m_class_get_byval_arg (obj->vtable->klass); addr = mono_object_unbox (obj); boxed_vtype = TRUE; goto handle_vtype; - } else if (obj->vtable->klass->rank) { - buffer_add_byte (buf, obj->vtable->klass->byval_arg.type); - } else if (obj->vtable->klass->byval_arg.type == MONO_TYPE_GENERICINST) { + } else if (m_class_get_rank (obj->vtable->klass)) { + buffer_add_byte (buf, m_class_get_byval_arg (obj->vtable->klass)->type); + } else if (m_class_get_byval_arg (obj->vtable->klass)->type == MONO_TYPE_GENERICINST) { buffer_add_byte (buf, MONO_TYPE_CLASS); } else { - buffer_add_byte (buf, obj->vtable->klass->byval_arg.type); + buffer_add_byte (buf, m_class_get_byval_arg (obj->vtable->klass)->type); } buffer_add_objid (buf, obj); } @@ -6404,7 +6404,7 @@ buffer_add_value_full (Buffer *buf, MonoType *t, void *addr, MonoDomain *domain, } buffer_add_byte (buf, MONO_TYPE_VALUETYPE); - buffer_add_byte (buf, klass->enumtype); + buffer_add_byte (buf, m_class_is_enumtype (klass)); buffer_add_typeid (buf, domain, klass); nfields = 0; @@ -6494,7 +6494,7 @@ decode_vtype (MonoType *t, MonoDomain *domain, guint8 *addr, guint8 *buf, guint8 if (t && klass != mono_class_from_mono_type (t)) { char *name = mono_type_full_name (t); - char *name2 = mono_type_full_name (&klass->byval_arg); + char *name2 = mono_type_full_name (m_class_get_byval_arg (klass)); DEBUG_PRINTF (1, "[%p] Expected value of type %s, got %s.\n", (gpointer) (gsize) mono_native_thread_id_get (), name, name2); g_free (name); g_free (name2); @@ -6605,7 +6605,7 @@ decode_value_internal (MonoType *t, int type, MonoDomain *domain, guint8 *addr, if (!obj) return ERR_INVALID_ARGUMENT; if (obj->vtable->klass != mono_class_from_mono_type (t)) { - DEBUG_PRINTF (1, "Expected type '%s', got object '%s'\n", mono_type_full_name (t), obj->vtable->klass->name); + DEBUG_PRINTF (1, "Expected type '%s', got object '%s'\n", mono_type_full_name (t), m_class_get_name (obj->vtable->klass)); return ERR_INVALID_ARGUMENT; } memcpy (addr, mono_object_unbox (obj), mono_class_value_size (obj->vtable->klass, NULL)); @@ -6629,7 +6629,7 @@ decode_value_internal (MonoType *t, int type, MonoDomain *domain, guint8 *addr, if (obj) { if (!obj_is_of_type (obj, t)) { - DEBUG_PRINTF (1, "Expected type '%s', got '%s'\n", mono_type_full_name (t), obj->vtable->klass->name); + DEBUG_PRINTF (1, "Expected type '%s', got '%s'\n", mono_type_full_name (t), m_class_get_name (obj->vtable->klass)); return ERR_INVALID_ARGUMENT; } } @@ -6979,7 +6979,7 @@ clear_assembly_from_modifier (EventRequest *req, Modifier *m, MonoAssembly *asse { int i; - if (m->kind == MOD_KIND_EXCEPTION_ONLY && m->data.exc_class && m->data.exc_class->image->assembly == assembly) + if (m->kind == MOD_KIND_EXCEPTION_ONLY && m->data.exc_class && m_class_get_image (m->data.exc_class)->assembly == assembly) m->kind = MOD_KIND_NONE; if (m->kind == MOD_KIND_ASSEMBLY_ONLY && m->data.assemblies) { int count = 0, match_count = 0, pos; @@ -7117,7 +7117,7 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 * Invoke this method directly, currently only Environment.Exit () is supported. */ this_arg = NULL; - DEBUG_PRINTF (1, "[%p] Invoking method '%s' on receiver '%s'.\n", (gpointer) (gsize) mono_native_thread_id_get (), mono_method_full_name (invoke->method, TRUE), this_arg ? this_arg->vtable->klass->name : ""); + DEBUG_PRINTF (1, "[%p] Invoking method '%s' on receiver '%s'.\n", (gpointer) (gsize) mono_native_thread_id_get (), mono_method_full_name (invoke->method, TRUE), this_arg ? m_class_get_name (this_arg->vtable->klass) : ""); mono_runtime_try_invoke (invoke->method, NULL, invoke->args, &exc, error); mono_error_assert_ok (error); @@ -7130,11 +7130,11 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 return err; sig = mono_method_signature (m); - if (m->klass->valuetype) + if (m_class_is_valuetype (m->klass)) this_buf = (guint8 *)g_alloca (mono_class_instance_size (m->klass)); else this_buf = (guint8 *)g_alloca (sizeof (MonoObject*)); - if (m->klass->valuetype && (m->flags & METHOD_ATTRIBUTE_STATIC)) { + if (m_class_is_valuetype (m->klass) && (m->flags & METHOD_ATTRIBUTE_STATIC)) { /* Should be null */ int type = decode_byte (p, &p, end); if (type != VALUE_TYPE_ID_NULL) { @@ -7142,7 +7142,7 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 return ERR_INVALID_ARGUMENT; } memset (this_buf, 0, mono_class_instance_size (m->klass)); - } else if (m->klass->valuetype && !strcmp (m->name, ".ctor")) { + } else if (m_class_is_valuetype (m->klass) && !strcmp (m->name, ".ctor")) { /* Could be null */ guint8 *tmp_p; @@ -7151,17 +7151,17 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 memset (this_buf, 0, mono_class_instance_size (m->klass)); p = tmp_p; } else { - err = decode_value (&m->klass->byval_arg, domain, this_buf, p, &p, end); + err = decode_value (m_class_get_byval_arg (m->klass), domain, this_buf, p, &p, end); if (err != ERR_NONE) return err; } } else { - err = decode_value (&m->klass->byval_arg, domain, this_buf, p, &p, end); + err = decode_value (m_class_get_byval_arg (m->klass), domain, this_buf, p, &p, end); if (err != ERR_NONE) return err; } - if (!m->klass->valuetype) + if (!m_class_is_valuetype (m->klass)) this_arg = *(MonoObject**)this_buf; else this_arg = NULL; @@ -7173,28 +7173,28 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 } m = mono_object_get_virtual_method (this_arg, m); /* Transform this to the format the rest of the code expects it to be */ - if (m->klass->valuetype) { + if (m_class_is_valuetype (m->klass)) { this_buf = (guint8 *)g_alloca (mono_class_instance_size (m->klass)); memcpy (this_buf, mono_object_unbox (this_arg), mono_class_instance_size (m->klass)); } - } else if ((m->flags & METHOD_ATTRIBUTE_VIRTUAL) && !m->klass->valuetype && invoke->flags & INVOKE_FLAG_VIRTUAL) { + } else if ((m->flags & METHOD_ATTRIBUTE_VIRTUAL) && !m_class_is_valuetype (m->klass) && invoke->flags & INVOKE_FLAG_VIRTUAL) { if (!this_arg) { DEBUG_PRINTF (1, "[%p] Error: invoke with INVOKE_FLAG_VIRTUAL flag set without this argument.\n", (gpointer) (gsize) mono_native_thread_id_get ()); return ERR_INVALID_ARGUMENT; } m = mono_object_get_virtual_method (this_arg, m); - if (m->klass->valuetype) { + if (m_class_is_valuetype (m->klass)) { this_buf = (guint8 *)g_alloca (mono_class_instance_size (m->klass)); memcpy (this_buf, mono_object_unbox (this_arg), mono_class_instance_size (m->klass)); } } - DEBUG_PRINTF (1, "[%p] Invoking method '%s' on receiver '%s'.\n", (gpointer) (gsize) mono_native_thread_id_get (), mono_method_full_name (m, TRUE), this_arg ? this_arg->vtable->klass->name : ""); + DEBUG_PRINTF (1, "[%p] Invoking method '%s' on receiver '%s'.\n", (gpointer) (gsize) mono_native_thread_id_get (), mono_method_full_name (m, TRUE), this_arg ? m_class_get_name (this_arg->vtable->klass) : ""); if (this_arg && this_arg->vtable->domain != domain) NOT_IMPLEMENTED; - if (!m->klass->valuetype && !(m->flags & METHOD_ATTRIBUTE_STATIC) && !this_arg) { + if (!m_class_is_valuetype (m->klass) && !(m->flags & METHOD_ATTRIBUTE_STATIC) && !this_arg) { if (!strcmp (m->name, ".ctor")) { if (mono_class_is_abstract (m->klass)) return ERR_INVALID_ARGUMENT; @@ -7208,7 +7208,7 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 } } - if (this_arg && !obj_is_of_type (this_arg, &m->klass->byval_arg)) + if (this_arg && !obj_is_of_type (this_arg, m_class_get_byval_arg (m->klass))) return ERR_INVALID_ARGUMENT; nargs = decode_int (p, &p, end); @@ -7269,17 +7269,17 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 #endif mono_stopwatch_start (&watch); - res = mono_runtime_try_invoke (m, m->klass->valuetype ? (gpointer) this_buf : (gpointer) this_arg, args, &exc, error); + res = mono_runtime_try_invoke (m, m_class_is_valuetype (m->klass) ? (gpointer) this_buf : (gpointer) this_arg, args, &exc, error); if (!mono_error_ok (error) && exc == NULL) { exc = (MonoObject*) mono_error_convert_to_exception (error); } else { mono_error_cleanup (error); /* FIXME report error */ } mono_stopwatch_stop (&watch); - DEBUG_PRINTF (1, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", (gpointer) (gsize) mono_native_thread_id_get (), res, exc ? exc->vtable->klass->name : NULL, (long)mono_stopwatch_elapsed_ms (&watch)); + DEBUG_PRINTF (1, "[%p] Invoke result: %p, exc: %s, time: %ld ms.\n", (gpointer) (gsize) mono_native_thread_id_get (), res, exc ? m_class_get_name (exc->vtable->klass) : NULL, (long)mono_stopwatch_elapsed_ms (&watch)); if (exc) { buffer_add_byte (buf, 0); - buffer_add_value (buf, &mono_defaults.object_class->byval_arg, &exc, domain); + buffer_add_value (buf, m_class_get_byval_arg (mono_defaults.object_class), &exc, domain); } else { gboolean out_this = FALSE; gboolean out_args = FALSE; @@ -7290,19 +7290,19 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 out_args = TRUE; buffer_add_byte (buf, 1 + (out_this ? 2 : 0) + (out_args ? 4 : 0)); if (m->string_ctor) { - buffer_add_value (buf, &mono_get_string_class ()->byval_arg, &res, domain); + buffer_add_value (buf, m_class_get_byval_arg (mono_get_string_class ()), &res, domain); } else if (sig->ret->type == MONO_TYPE_VOID && !m->string_ctor) { if (!strcmp (m->name, ".ctor")) { - if (!m->klass->valuetype) - buffer_add_value (buf, &mono_defaults.object_class->byval_arg, &this_arg, domain); + if (!m_class_is_valuetype (m->klass)) + buffer_add_value (buf, m_class_get_byval_arg (mono_defaults.object_class), &this_arg, domain); else - buffer_add_value (buf, &m->klass->byval_arg, this_buf, domain); + buffer_add_value (buf, m_class_get_byval_arg (m->klass), this_buf, domain); } else { - buffer_add_value (buf, &mono_defaults.void_class->byval_arg, NULL, domain); + buffer_add_value (buf, m_class_get_byval_arg (mono_defaults.void_class), NULL, domain); } } else if (MONO_TYPE_IS_REFERENCE (sig->ret)) { buffer_add_value (buf, sig->ret, &res, domain); - } else if (mono_class_from_mono_type (sig->ret)->valuetype || sig->ret->type == MONO_TYPE_PTR || sig->ret->type == MONO_TYPE_FNPTR) { + } else if (m_class_is_valuetype (mono_class_from_mono_type (sig->ret)) || sig->ret->type == MONO_TYPE_PTR || sig->ret->type == MONO_TYPE_FNPTR) { if (mono_class_is_nullable (mono_class_from_mono_type (sig->ret))) { MonoClass *k = mono_class_from_mono_type (sig->ret); guint8 *nullable_buf = (guint8 *)g_alloca (mono_class_value_size (k, NULL)); @@ -7319,7 +7319,7 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8 } if (out_this) /* Return the new value of the receiver after the call */ - buffer_add_value (buf, &m->klass->byval_arg, this_buf, domain); + buffer_add_value (buf, m_class_get_byval_arg (m->klass), this_buf, domain); if (out_args) { buffer_add_int (buf, nargs); for (i = 0; i < nargs; ++i) { @@ -7993,7 +7993,7 @@ event_commands (int command, guint8 *p, guint8 *end, Buffer *buf) req->modifiers [i].subclasses = decode_byte (p, &p, end); else req->modifiers [i].subclasses = TRUE; - DEBUG_PRINTF (1, "[dbg] \tEXCEPTION_ONLY filter (%s%s%s%s).\n", exc_class ? exc_class->name : "all", req->modifiers [i].caught ? ", caught" : "", req->modifiers [i].uncaught ? ", uncaught" : "", req->modifiers [i].subclasses ? ", include-subclasses" : ""); + DEBUG_PRINTF (1, "[dbg] \tEXCEPTION_ONLY filter (%s%s%s%s).\n", exc_class ? m_class_get_name (exc_class) : "all", req->modifiers [i].caught ? ", caught" : "", req->modifiers [i].uncaught ? ", uncaught" : "", req->modifiers [i].subclasses ? ", include-subclasses" : ""); if (exc_class) { req->modifiers [i].data.exc_class = exc_class; @@ -8206,7 +8206,7 @@ domain_commands (int command, guint8 *p, guint8 *end, Buffer *buf) if (err != ERR_NONE) return err; - buffer_add_assemblyid (buf, domain, domain->domain->mbr.obj.vtable->klass->image->assembly); + buffer_add_assemblyid (buf, domain, m_class_get_image (domain->domain->mbr.obj.vtable->klass)->assembly); break; } case CMD_APPDOMAIN_CREATE_STRING: { @@ -8247,7 +8247,7 @@ domain_commands (int command, guint8 *p, guint8 *end, Buffer *buf) o = mono_object_new_checked (domain, klass, error); mono_error_assert_ok (error); - err = decode_value (&klass->byval_arg, domain, (guint8 *)mono_object_unbox (o), p, &p, end); + err = decode_value (m_class_get_byval_arg (klass), domain, (guint8 *)mono_object_unbox (o), p, &p, end); if (err != ERR_NONE) return err; @@ -8538,8 +8538,10 @@ collect_interfaces (MonoClass *klass, GHashTable *ifaces, MonoError *error) if (!mono_error_ok (error)) return; - for (i = 0; i < klass->interface_count; i++) { - ic = klass->interfaces [i]; + int klass_interface_count = m_class_get_interface_count (klass); + MonoClass **klass_interfaces = m_class_get_interfaces (klass); + for (i = 0; i < klass_interface_count; i++) { + ic = klass_interfaces [i]; g_hash_table_insert (ifaces, ic, ic); collect_interfaces (ic, ifaces, error); @@ -8562,24 +8564,24 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint switch (command) { case CMD_TYPE_GET_INFO: { - buffer_add_string (buf, klass->name_space); - buffer_add_string (buf, klass->name); + buffer_add_string (buf, m_class_get_name_space (klass)); + buffer_add_string (buf, m_class_get_name (klass)); // FIXME: byref - name = mono_type_get_name_full (&klass->byval_arg, MONO_TYPE_NAME_FORMAT_FULL_NAME); + name = mono_type_get_name_full (m_class_get_byval_arg (klass), MONO_TYPE_NAME_FORMAT_FULL_NAME); buffer_add_string (buf, name); g_free (name); - buffer_add_assemblyid (buf, domain, klass->image->assembly); - buffer_add_moduleid (buf, domain, klass->image); - buffer_add_typeid (buf, domain, klass->parent); - if (klass->rank || klass->byval_arg.type == MONO_TYPE_PTR) - buffer_add_typeid (buf, domain, klass->element_class); + buffer_add_assemblyid (buf, domain, m_class_get_image (klass)->assembly); + buffer_add_moduleid (buf, domain, m_class_get_image (klass)); + buffer_add_typeid (buf, domain, m_class_get_parent (klass)); + if (m_class_get_rank (klass) || m_class_get_byval_arg (klass)->type == MONO_TYPE_PTR) + buffer_add_typeid (buf, domain, m_class_get_element_class (klass)); else buffer_add_id (buf, 0); - buffer_add_int (buf, klass->type_token); - buffer_add_byte (buf, klass->rank); + buffer_add_int (buf, m_class_get_type_token (klass)); + buffer_add_byte (buf, m_class_get_rank (klass)); buffer_add_int (buf, mono_class_get_flags (klass)); b = 0; - type = &klass->byval_arg; + type = m_class_get_byval_arg (klass); // FIXME: Can't decide whenever a class represents a byref type if (FALSE) b |= (1 << 0); @@ -8589,7 +8591,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint b |= (1 << 2); if (type->type == MONO_TYPE_VALUETYPE) b |= (1 << 3); - if (klass->enumtype) + if (m_class_is_enumtype (klass)) b |= (1 << 4); if (mono_class_is_gtd (klass)) b |= (1 << 5); @@ -8713,7 +8715,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint return ERR_LOADER_ERROR; } - err = buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo); + err = buffer_add_cattrs (buf, domain, m_class_get_image (klass), attr_klass, cinfo); if (err != ERR_NONE) return err; break; @@ -8736,7 +8738,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint return ERR_LOADER_ERROR; } - err = buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo); + err = buffer_add_cattrs (buf, domain, m_class_get_image (klass), attr_klass, cinfo); if (err != ERR_NONE) return err; break; @@ -8759,7 +8761,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint return ERR_LOADER_ERROR; } - err = buffer_add_cattrs (buf, domain, klass->image, attr_klass, cinfo); + err = buffer_add_cattrs (buf, domain, m_class_get_image (klass), attr_klass, cinfo); if (err != ERR_NONE) return err; break; @@ -8803,7 +8805,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint /* Check that the field belongs to the object */ found = FALSE; - for (k = klass; k; k = k->parent) { + for (k = klass; k; k = m_class_get_parent (k)) { if (k == f->parent) { found = TRUE; break; @@ -8845,7 +8847,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint /* Check that the field belongs to the object */ found = FALSE; - for (k = klass; k; k = k->parent) { + for (k = klass; k; k = m_class_get_parent (k)) { if (k == f->parent) { found = TRUE; break; @@ -8874,7 +8876,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint break; } case CMD_TYPE_GET_OBJECT: { - MonoObject *o = (MonoObject*)mono_type_get_object_checked (domain, &klass->byval_arg, error); + MonoObject *o = (MonoObject*)mono_type_get_object_checked (domain, m_class_get_byval_arg (klass), error); if (!mono_error_ok (error)) { mono_error_cleanup (error); return ERR_INVALID_OBJECT; @@ -8946,7 +8948,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint tclass = klass; - for (parent = tclass; parent; parent = parent->parent) { + for (parent = tclass; parent; parent = m_class_get_parent (parent)) { mono_class_setup_interfaces (parent, error); if (!mono_error_ok (error)) return ERR_LOADER_ERROR; @@ -8990,8 +8992,9 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint while ((method = mono_class_get_methods (iclass, &iter))) { buffer_add_methodid (buf, domain, method); } + MonoMethod **klass_vtable = m_class_get_vtable (klass); for (i = 0; i < nmethods; ++i) - buffer_add_methodid (buf, domain, klass->vtable [i + ioffset]); + buffer_add_methodid (buf, domain, klass_vtable [i + ioffset]); } break; } @@ -9359,7 +9362,7 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g MonoString *s; char *s2; - s = mono_ldstr_checked (domain, method->klass->image, mono_metadata_token_index (token), error); + s = mono_ldstr_checked (domain, m_class_get_image (method->klass), mono_metadata_token_index (token), error); mono_error_assert_ok (error); /* FIXME don't swallow the error */ s2 = mono_string_to_utf8_checked (s, error); @@ -9385,7 +9388,7 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g break; } } else { - val = mono_ldtoken_checked (method->klass->image, token, &handle_class, NULL, error); + val = mono_ldtoken_checked (m_class_get_image (method->klass), token, &handle_class, NULL, error); if (!val) g_error ("Could not load token due to %s", mono_error_get_message (error)); } @@ -9434,7 +9437,7 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g return ERR_LOADER_ERROR; } - err = buffer_add_cattrs (buf, domain, method->klass->image, attr_klass, cinfo); + err = buffer_add_cattrs (buf, domain, m_class_get_image (method->klass), attr_klass, cinfo); if (err != ERR_NONE) return err; break; @@ -9461,7 +9464,7 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g g_free (type_argv); return ERR_INVALID_ARGUMENT; } - type_argv [i] = &klass->byval_arg; + type_argv [i] = m_class_get_byval_arg (klass); } ginst = mono_metadata_get_generic_inst (type_argc, type_argv); g_free (type_argv); @@ -9769,34 +9772,34 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) case CMD_STACK_FRAME_GET_THIS: { if (frame->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) return ERR_ABSENT_INFORMATION; - if (frame->api_method->klass->valuetype) { + if (m_class_is_valuetype (frame->api_method->klass)) { if (!sig->hasthis) { MonoObject *p = NULL; - buffer_add_value (buf, &mono_defaults.object_class->byval_arg, &p, frame->domain); + buffer_add_value (buf, m_class_get_byval_arg (mono_defaults.object_class), &p, frame->domain); } else { if (frame->ji->is_interp) { guint8 *addr; addr = mini_get_interp_callbacks ()->frame_get_this (frame->interp_frame); - buffer_add_value_full (buf, &frame->actual_method->klass->this_arg, addr, frame->domain, FALSE, NULL); + buffer_add_value_full (buf, m_class_get_this_arg (frame->actual_method->klass), addr, frame->domain, FALSE, NULL); } else { - add_var (buf, jit, &frame->actual_method->klass->this_arg, jit->this_var, &frame->ctx, frame->domain, TRUE); + add_var (buf, jit, m_class_get_this_arg (frame->actual_method->klass), jit->this_var, &frame->ctx, frame->domain, TRUE); } } } else { if (!sig->hasthis) { MonoObject *p = NULL; - buffer_add_value (buf, &frame->actual_method->klass->byval_arg, &p, frame->domain); + buffer_add_value (buf, m_class_get_byval_arg (frame->actual_method->klass), &p, frame->domain); } else { if (frame->ji->is_interp) { guint8 *addr; addr = mini_get_interp_callbacks ()->frame_get_this (frame->interp_frame); - buffer_add_value_full (buf, &frame->api_method->klass->byval_arg, addr, frame->domain, FALSE, NULL); + buffer_add_value_full (buf, m_class_get_byval_arg (frame->api_method->klass), addr, frame->domain, FALSE, NULL); } else { - add_var (buf, jit, &frame->api_method->klass->byval_arg, jit->this_var, &frame->ctx, frame->domain, TRUE); + add_var (buf, jit, m_class_get_byval_arg (frame->api_method->klass), jit->this_var, &frame->ctx, frame->domain, TRUE); } } } @@ -9872,7 +9875,7 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) MonoType *t; MonoDebugVarInfo *var; - t = &frame->actual_method->klass->byval_arg; + t = m_class_get_byval_arg (frame->actual_method->klass); /* Checked by the sender */ g_assert (MONO_TYPE_ISSTRUCT (t)); @@ -9885,12 +9888,12 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) guint8 *addr; addr = mini_get_interp_callbacks ()->frame_get_this (frame->interp_frame); - set_interp_var (&frame->actual_method->klass->this_arg, addr, val_buf); + set_interp_var (m_class_get_this_arg (frame->actual_method->klass), addr, val_buf); } else { var = jit->this_var; g_assert (var); - set_var (&frame->actual_method->klass->this_arg, var, &frame->ctx, frame->domain, val_buf, frame->reg_locations, &tls->restore_state.ctx); + set_var (m_class_get_this_arg (frame->actual_method->klass), var, &frame->ctx, frame->domain, val_buf, frame->reg_locations, &tls->restore_state.ctx); } break; } @@ -9916,12 +9919,12 @@ array_commands (int command, guint8 *p, guint8 *end, Buffer *buf) switch (command) { case CMD_ARRAY_REF_GET_LENGTH: - buffer_add_int (buf, arr->obj.vtable->klass->rank); + buffer_add_int (buf, m_class_get_rank (arr->obj.vtable->klass)); if (!arr->bounds) { buffer_add_int (buf, arr->max_length); buffer_add_int (buf, 0); } else { - for (i = 0; i < arr->obj.vtable->klass->rank; ++i) { + for (i = 0; i < m_class_get_rank (arr->obj.vtable->klass); ++i) { buffer_add_int (buf, arr->bounds [i].length); buffer_add_int (buf, arr->bounds [i].lower_bound); } @@ -9938,7 +9941,7 @@ array_commands (int command, guint8 *p, guint8 *end, Buffer *buf) esize = mono_array_element_size (arr->obj.vtable->klass); for (i = index; i < index + len; ++i) { elem = (gpointer*)((char*)arr->vector + (i * esize)); - buffer_add_value (buf, &arr->obj.vtable->klass->element_class->byval_arg, elem, arr->obj.vtable->domain); + buffer_add_value (buf, m_class_get_byval_arg (m_class_get_element_class (arr->obj.vtable->klass)), elem, arr->obj.vtable->domain); } break; case CMD_ARRAY_REF_SET_VALUES: @@ -9953,7 +9956,7 @@ array_commands (int command, guint8 *p, guint8 *end, Buffer *buf) for (i = index; i < index + len; ++i) { elem = (gpointer*)((char*)arr->vector + (i * esize)); - decode_value (&arr->obj.vtable->klass->element_class->byval_arg, arr->obj.vtable->domain, (guint8 *)elem, p, &p, end); + decode_value (m_class_get_byval_arg (m_class_get_element_class (arr->obj.vtable->klass)), arr->obj.vtable->domain, (guint8 *)elem, p, &p, end); } break; default: @@ -10032,10 +10035,10 @@ pointer_commands (int command, guint8 *p, guint8 *end, Buffer *buf) if (err != ERR_NONE) return err; - if (klass->byval_arg.type != MONO_TYPE_PTR) + if (m_class_get_byval_arg (klass)->type != MONO_TYPE_PTR) return ERR_INVALID_ARGUMENT; - buffer_add_value (buf, &klass->element_class->byval_arg, (gpointer)addr, domain); + buffer_add_value (buf, m_class_get_byval_arg (m_class_get_element_class (klass)), (gpointer)addr, domain); break; default: @@ -10098,7 +10101,7 @@ object_commands (int command, guint8 *p, guint8 *end, Buffer *buf) /* Check that the field belongs to the object */ found = FALSE; - for (k = obj_type; k; k = k->parent) { + for (k = obj_type; k; k = m_class_get_parent (k)) { if (k == f->parent) { found = TRUE; break; @@ -10159,7 +10162,7 @@ object_commands (int command, guint8 *p, guint8 *end, Buffer *buf) /* Check that the field belongs to the object */ found = FALSE; - for (k = obj_type; k; k = k->parent) { + for (k = obj_type; k; k = m_class_get_parent (k)) { if (k == f->parent) { found = TRUE; break; diff --git a/mono/mini/decompose.c b/mono/mini/decompose.c index a9b59ace2a8..13336a8de96 100644 --- a/mono/mini/decompose.c +++ b/mono/mini/decompose.c @@ -1217,10 +1217,10 @@ mono_decompose_vtype_opts (MonoCompile *cfg) dest_var = get_vreg_to_inst (cfg, ins->dreg); if (!src_var) - src_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->dreg); + src_var = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (ins->klass), OP_LOCAL, ins->dreg); if (!dest_var) - dest_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->dreg); + dest_var = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (ins->klass), OP_LOCAL, ins->dreg); // FIXME: if (src_var->backend.is_pinvoke) @@ -1238,7 +1238,7 @@ mono_decompose_vtype_opts (MonoCompile *cfg) g_assert (ins->klass); - EMIT_NEW_VARLOADA_VREG (cfg, dest, ins->dreg, &ins->klass->byval_arg); + EMIT_NEW_VARLOADA_VREG (cfg, dest, ins->dreg, m_class_get_byval_arg (ins->klass)); mini_emit_initobj (cfg, dest, NULL, ins->klass); if (cfg->compute_gc_maps) { @@ -1267,10 +1267,10 @@ mono_decompose_vtype_opts (MonoCompile *cfg) if (!src_var) { g_assert (ins->klass); - src_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->sreg1); + src_var = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (ins->klass), OP_LOCAL, ins->sreg1); } - EMIT_NEW_VARLOADA_VREG ((cfg), (src), ins->sreg1, &ins->klass->byval_arg); + EMIT_NEW_VARLOADA_VREG ((cfg), (src), ins->sreg1, m_class_get_byval_arg (ins->klass)); dreg = alloc_preg (cfg); EMIT_NEW_BIALU_IMM (cfg, dest, OP_ADD_IMM, dreg, ins->inst_destbasereg, ins->inst_offset); @@ -1286,7 +1286,7 @@ mono_decompose_vtype_opts (MonoCompile *cfg) // FIXME-VT: // FIXME: if (!dest_var) - dest_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->dreg); + dest_var = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (ins->klass), OP_LOCAL, ins->dreg); dreg = alloc_preg (cfg); EMIT_NEW_BIALU_IMM (cfg, src, OP_ADD_IMM, dreg, ins->inst_basereg, ins->inst_offset); @@ -1302,7 +1302,7 @@ mono_decompose_vtype_opts (MonoCompile *cfg) src_var = get_vreg_to_inst (cfg, ins->sreg1); if (!src_var) - src_var = mono_compile_create_var_for_vreg (cfg, &ins->klass->byval_arg, OP_LOCAL, ins->sreg1); + src_var = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (ins->klass), OP_LOCAL, ins->sreg1); EMIT_NEW_VARLOADA (cfg, src, src_var, src_var->inst_vtype); mono_arch_emit_outarg_vt (cfg, ins, src); @@ -1456,7 +1456,7 @@ inline static MonoInst * mono_get_domainvar (MonoCompile *cfg) { if (!cfg->domainvar) - cfg->domainvar = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL); + cfg->domainvar = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL); return cfg->domainvar; } diff --git a/mono/mini/driver.c b/mono/mini/driver.c index 9f444a18129..406be9cd7a7 100644 --- a/mono/mini/driver.c +++ b/mono/mini/driver.c @@ -616,7 +616,7 @@ interp_regression_step (MonoImage *image, int verbose, int *total_run, int *tota continue; MonoClass *klass = centry->ctor->klass; - if (strcmp (klass->name, "CategoryAttribute")) + if (strcmp (m_class_get_name (klass), "CategoryAttribute")) continue; MonoObject *obj = mono_custom_attrs_get_attr_checked (ainfo, klass, error); diff --git a/mono/mini/dwarfwriter.c b/mono/mini/dwarfwriter.c index 9d4a591f48d..8cc4eae3551 100644 --- a/mono/mini/dwarfwriter.c +++ b/mono/mini/dwarfwriter.c @@ -931,8 +931,8 @@ emit_class_dwarf_info (MonoDwarfWriter *w, MonoClass *klass, gboolean vtype) if (die) return die; - if (!((klass->byval_arg.type == MONO_TYPE_CLASS) || (klass->byval_arg.type == MONO_TYPE_OBJECT) || klass->byval_arg.type == MONO_TYPE_GENERICINST || klass->enumtype || (klass->byval_arg.type == MONO_TYPE_VALUETYPE && vtype) || - (klass->byval_arg.type >= MONO_TYPE_BOOLEAN && klass->byval_arg.type <= MONO_TYPE_R8 && !vtype))) + if (!((m_class_get_byval_arg (klass)->type == MONO_TYPE_CLASS) || (m_class_get_byval_arg (klass)->type == MONO_TYPE_OBJECT) || m_class_get_byval_arg (klass)->type == MONO_TYPE_GENERICINST || m_class_is_enumtype (klass) || (m_class_get_byval_arg (klass)->type == MONO_TYPE_VALUETYPE && vtype) || + (m_class_get_byval_arg (klass)->type >= MONO_TYPE_BOOLEAN && m_class_get_byval_arg (klass)->type <= MONO_TYPE_R8 && !vtype))) return NULL; /* @@ -944,10 +944,10 @@ emit_class_dwarf_info (MonoDwarfWriter *w, MonoClass *klass, gboolean vtype) */ if (emit_namespace) { emit_uleb128 (w, ABBREV_NAMESPACE); - emit_string (w, klass->name_space); + emit_string (w, m_class_get_name_space (klass)); } - full_name = g_strdup_printf ("%s%s%s", klass->name_space, klass->name_space ? "." : "", klass->name); + full_name = g_strdup_printf ("%s%s%s", m_class_get_name_space (klass), m_class_get_name_space (klass) ? "." : "", m_class_get_name (klass)); /* * gdb doesn't support namespaces for non-C++ dwarf objects, so use _ * to separate components. @@ -965,7 +965,7 @@ emit_class_dwarf_info (MonoDwarfWriter *w, MonoClass *klass, gboolean vtype) g_hash_table_insert (w->class_to_reference_die, klass, reference_die); g_hash_table_insert (cache, klass, die); - if (klass->enumtype) { + if (m_class_is_enumtype (klass)) { int size = mono_class_value_size (mono_class_from_mono_type (mono_class_enum_basetype (klass)), NULL); emit_label (w, die); @@ -1033,8 +1033,8 @@ emit_class_dwarf_info (MonoDwarfWriter *w, MonoClass *klass, gboolean vtype) guint8 *p; char *parent_die; - if (klass->parent) - parent_die = emit_class_dwarf_info (w, klass->parent, FALSE); + if (m_class_get_parent (klass)) + parent_die = emit_class_dwarf_info (w, m_class_get_parent (klass), FALSE); else parent_die = NULL; @@ -1054,7 +1054,7 @@ emit_class_dwarf_info (MonoDwarfWriter *w, MonoClass *klass, gboolean vtype) emit_uleb128 (w, has_children ? ABBREV_STRUCT_TYPE : ABBREV_STRUCT_TYPE_NOCHILDREN); emit_string (w, full_name); - emit_uleb128 (w, klass->instance_size); + emit_uleb128 (w, m_class_get_instance_size (klass)); if (parent_die) { emit_uleb128 (w, ABBREV_INHERITANCE); @@ -1081,7 +1081,7 @@ emit_class_dwarf_info (MonoDwarfWriter *w, MonoClass *klass, gboolean vtype) /* location */ p = buf; *p ++= DW_OP_plus_uconst; - if (klass->valuetype && vtype) + if (m_class_is_valuetype (klass) && vtype) encode_uleb128 (field->offset - sizeof (MonoObject), p, &p); else encode_uleb128 (field->offset, p, &p); @@ -1141,7 +1141,7 @@ get_type_die (MonoDwarfWriter *w, MonoType *t) /* Should return a pointer type to a reference */ } // FIXME: - t = &mono_defaults.int_class->byval_arg; + t = m_class_get_byval_arg (mono_defaults.int_class); } for (j = 0; j < G_N_ELEMENTS (basic_types); ++j) if (basic_types [j].type == t->type) @@ -1158,7 +1158,7 @@ get_type_die (MonoDwarfWriter *w, MonoType *t) tdie = ".LDIE_OBJECT"; break; case MONO_TYPE_VALUETYPE: - if (klass->enumtype) + if (m_class_is_enumtype (klass)) tdie = get_class_die (w, klass, FALSE); else tdie = ".LDIE_I4"; @@ -1201,7 +1201,7 @@ emit_type (MonoDwarfWriter *w, MonoType *t) emit_class_dwarf_info (w, klass, FALSE); } // FIXME: - t = &mono_defaults.int_class->byval_arg; + t = m_class_get_byval_arg (mono_defaults.int_class); } for (j = 0; j < G_N_ELEMENTS (basic_types); ++j) if (basic_types [j].type == t->type) @@ -1220,7 +1220,7 @@ emit_type (MonoDwarfWriter *w, MonoType *t) case MONO_TYPE_ARRAY: break; case MONO_TYPE_VALUETYPE: - if (klass->enumtype) + if (m_class_is_enumtype (klass)) emit_class_dwarf_info (w, klass, FALSE); break; case MONO_TYPE_GENERICINST: @@ -1316,10 +1316,10 @@ token_handler (MonoDisHelper *dh, MonoMethod *method, guint32 token) if (method->wrapper_type) { klass = (MonoClass *)data; } else { - klass = mono_class_get_checked (method->klass->image, token, error); + klass = mono_class_get_checked (m_class_get_image (method->klass), token, error); g_assert (mono_error_ok (error)); /* FIXME error handling */ } - res = g_strdup_printf ("<%s>", klass->name); + res = g_strdup_printf ("<%s>", m_class_get_name (klass)); break; case CEE_NEWOBJ: case CEE_CALL: @@ -1328,7 +1328,7 @@ token_handler (MonoDisHelper *dh, MonoMethod *method, guint32 token) cmethod = (MonoMethod *)data; } else { ERROR_DECL (error); - cmethod = mono_get_method_checked (method->klass->image, token, NULL, NULL, error); + cmethod = mono_get_method_checked (m_class_get_image (method->klass), token, NULL, NULL, error); if (!cmethod) g_error ("Could not load method due to %s", mono_error_get_message (error)); /* FIXME don't swallow the error */ } @@ -1352,7 +1352,7 @@ token_handler (MonoDisHelper *dh, MonoMethod *method, guint32 token) if (method->wrapper_type) { field = (MonoClassField *)data; } else { - field = mono_field_from_token_checked (method->klass->image, token, &klass, NULL, error); + field = mono_field_from_token_checked (m_class_get_image (method->klass), token, &klass, NULL, error); g_assert (mono_error_ok (error)); /* FIXME error handling */ } desc = mono_field_full_name (field); @@ -1411,7 +1411,7 @@ disasm_ins (MonoMethod *method, const guchar *ip, const guint8 **endip) token = read32 (ip + 2); data = mono_method_get_wrapper_data (method, token); - dis = g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip - header->code), ((MonoClass*)data)->name); + dis = g_strdup_printf ("IL_%04x: mono_classconst <%s>", (int)(ip - header->code), m_class_get_name ((MonoClass*)data)); ip += 6; break; } @@ -1778,10 +1778,10 @@ mono_dwarf_writer_emit_method (MonoDwarfWriter *w, MonoCompile *cfg, MonoMethod MonoType *t; if (i == 0 && sig->hasthis) { - if (method->klass->valuetype) - t = &method->klass->this_arg; + if (m_class_is_valuetype (method->klass)) + t = m_class_get_this_arg (method->klass); else - t = &method->klass->byval_arg; + t = m_class_get_byval_arg (method->klass); } else { t = sig->params [i - sig->hasthis]; } @@ -1854,10 +1854,10 @@ mono_dwarf_writer_emit_method (MonoDwarfWriter *w, MonoCompile *cfg, MonoMethod need_loclist = TRUE; if (i == 0 && sig->hasthis) { - if (method->klass->valuetype) - t = &method->klass->this_arg; + if (m_class_is_valuetype (method->klass)) + t = m_class_get_this_arg (method->klass); else - t = &method->klass->byval_arg; + t = m_class_get_byval_arg (method->klass); pname = "this"; } else { t = sig->params [i - sig->hasthis]; @@ -1873,7 +1873,7 @@ mono_dwarf_writer_emit_method (MonoDwarfWriter *w, MonoCompile *cfg, MonoMethod emit_string (w, pname); /* type */ if (!arg || arg->flags & MONO_INST_IS_DEAD) - emit_var_type (w, &mono_defaults.int32_class->byval_arg); + emit_var_type (w, m_class_get_byval_arg (mono_defaults.int32_class)); else emit_var_type (w, t); @@ -1930,7 +1930,7 @@ mono_dwarf_writer_emit_method (MonoDwarfWriter *w, MonoCompile *cfg, MonoMethod } /* type */ if (!ins || ins->flags & MONO_INST_IS_DEAD) - emit_var_type (w, &mono_defaults.int32_class->byval_arg); + emit_var_type (w, m_class_get_byval_arg (mono_defaults.int32_class)); else emit_var_type (w, header->locals [i]); diff --git a/mono/mini/exceptions-amd64.c b/mono/mini/exceptions-amd64.c index ba33ce5f236..66a0bcd0512 100644 --- a/mono/mini/exceptions-amd64.c +++ b/mono/mini/exceptions-amd64.c @@ -411,7 +411,7 @@ mono_amd64_throw_corlib_exception (guint64 dummy1, guint64 dummy2, guint64 dummy 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); mctx->gregs [AMD64_RIP] -= pc_offset; diff --git a/mono/mini/jit-icalls.c b/mono/mini/jit-icalls.c index 895cb879e47..0c1cb8a2580 100644 --- a/mono/mini/jit-icalls.c +++ b/mono/mini/jit-icalls.c @@ -114,7 +114,7 @@ mono_helper_stelem_ref_check (MonoArray *array, MonoObject *val) mono_set_pending_exception (mono_get_exception_null_reference ()); return; } - if (val && !mono_object_isinst_checked (val, array->obj.vtable->klass->element_class, error)) { + if (val && !mono_object_isinst_checked (val, m_class_get_element_class (mono_object_class (array)), error)) { if (mono_error_set_pending_exception (error)) return; mono_set_pending_exception (mono_get_exception_array_type_mismatch ()); @@ -685,7 +685,7 @@ mono_array_new_va (MonoMethod *cm, ...) int i, d; pcount = mono_method_signature (cm)->param_count; - rank = cm->klass->rank; + rank = m_class_get_rank (cm->klass); va_start (ap, cm); @@ -695,7 +695,7 @@ mono_array_new_va (MonoMethod *cm, ...) if (rank == pcount) { /* Only lengths provided. */ - if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) { + if (m_class_get_byval_arg (cm->klass)->type == MONO_TYPE_ARRAY) { lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank); memset (lower_bounds, 0, sizeof (intptr_t) * rank); } else { @@ -732,13 +732,13 @@ mono_array_new_1 (MonoMethod *cm, guint32 length) int rank; pcount = mono_method_signature (cm)->param_count; - rank = cm->klass->rank; + rank = m_class_get_rank (cm->klass); lengths [0] = length; g_assert (rank == pcount); - if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) { + if (m_class_get_byval_arg (cm->klass)->type == MONO_TYPE_ARRAY) { lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank); memset (lower_bounds, 0, sizeof (intptr_t) * rank); } else { @@ -767,14 +767,14 @@ mono_array_new_2 (MonoMethod *cm, guint32 length1, guint32 length2) int rank; pcount = mono_method_signature (cm)->param_count; - rank = cm->klass->rank; + rank = m_class_get_rank (cm->klass); lengths [0] = length1; lengths [1] = length2; g_assert (rank == pcount); - if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) { + if (m_class_get_byval_arg (cm->klass)->type == MONO_TYPE_ARRAY) { lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank); memset (lower_bounds, 0, sizeof (intptr_t) * rank); } else { @@ -803,7 +803,7 @@ mono_array_new_3 (MonoMethod *cm, guint32 length1, guint32 length2, guint32 leng int rank; pcount = mono_method_signature (cm)->param_count; - rank = cm->klass->rank; + rank = m_class_get_rank (cm->klass); lengths [0] = length1; lengths [1] = length2; @@ -811,7 +811,7 @@ mono_array_new_3 (MonoMethod *cm, guint32 length1, guint32 length2, guint32 leng g_assert (rank == pcount); - if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) { + if (m_class_get_byval_arg (cm->klass)->type == MONO_TYPE_ARRAY) { lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank); memset (lower_bounds, 0, sizeof (intptr_t) * rank); } else { @@ -840,7 +840,7 @@ mono_array_new_4 (MonoMethod *cm, guint32 length1, guint32 length2, guint32 leng int rank; pcount = mono_method_signature (cm)->param_count; - rank = cm->klass->rank; + rank = m_class_get_rank (cm->klass); lengths [0] = length1; lengths [1] = length2; @@ -849,7 +849,7 @@ mono_array_new_4 (MonoMethod *cm, guint32 length1, guint32 length2, guint32 leng g_assert (rank == pcount); - if (cm->klass->byval_arg.type == MONO_TYPE_ARRAY) { + if (m_class_get_byval_arg (cm->klass)->type == MONO_TYPE_ARRAY) { lower_bounds = (intptr_t *)alloca (sizeof (intptr_t) * rank); memset (lower_bounds, 0, sizeof (intptr_t) * rank); } else { @@ -1118,7 +1118,7 @@ mono_helper_compile_generic_method (MonoObject *obj, MonoMethod *method, gpointe addr = mini_add_method_trampoline (vmethod, addr, mono_method_needs_static_rgctx_invoke (vmethod, FALSE), FALSE); /* Since this is a virtual call, have to unbox vtypes */ - if (obj->vtable->klass->valuetype) + if (m_class_is_valuetype (obj->vtable->klass)) *this_arg = mono_object_unbox (obj); else *this_arg = obj; @@ -1222,7 +1222,7 @@ mono_object_castclass_unbox (MonoObject *obj, MonoClass *klass) return NULL; oklass = obj->vtable->klass; - if ((klass->enumtype && oklass == klass->element_class) || (oklass->enumtype && klass == oklass->element_class)) + if ((m_class_is_enumtype (klass) && oklass == m_class_get_element_class (klass)) || (m_class_is_enumtype (oklass) && klass == m_class_get_element_class (oklass))) return obj; if (mono_object_isinst_checked (obj, klass, error)) return obj; @@ -1352,26 +1352,26 @@ constrained_gsharedvt_call_setup (gpointer mp, MonoMethod *cmethod, MonoClass *k } else { /* Lookup the virtual method */ mono_class_setup_vtable (klass); - g_assert (klass->vtable); + g_assert (m_class_get_vtable (klass)); vt_slot = mono_method_get_vtable_slot (cmethod); if (mono_class_is_interface (cmethod->klass)) { iface_offset = mono_class_interface_offset (klass, cmethod->klass); g_assert (iface_offset != -1); vt_slot += iface_offset; } - m = klass->vtable [vt_slot]; + m = m_class_get_vtable (klass) [vt_slot]; if (cmethod->is_inflated) { m = mono_class_inflate_generic_method_full_checked (m, NULL, mono_method_get_context (cmethod), error); return_val_if_nok (error, NULL); } } - if (klass->valuetype && (m->klass == mono_defaults.object_class || m->klass == mono_defaults.enum_class->parent || m->klass == mono_defaults.enum_class)) { + if (m_class_is_valuetype (klass) && (m->klass == mono_defaults.object_class || m->klass == m_class_get_parent (mono_defaults.enum_class) || m->klass == mono_defaults.enum_class)) { /* * Calling a non-vtype method with a vtype receiver, has to box. */ *this_arg = mono_value_box_checked (mono_domain_get (), klass, mp, error); - } else if (klass->valuetype) { + } else if (m_class_is_valuetype (klass)) { if (is_iface) { /* * The original type is an interface, so the receiver is a ref, @@ -1442,7 +1442,7 @@ mono_gsharedvt_constrained_call (gpointer mp, MonoMethod *cmethod, MonoClass *kl void mono_gsharedvt_value_copy (gpointer dest, gpointer src, MonoClass *klass) { - if (klass->valuetype) + if (m_class_is_valuetype (klass)) mono_value_copy (dest, src, klass); else mono_gc_wbarrier_generic_store (dest, *(MonoObject**)src); @@ -1544,10 +1544,10 @@ resolve_iface_call (MonoObject *this_obj, int imt_slot, MonoMethod *imt_method, generic_virtual = imt_method; if (generic_virtual || variant_iface) { - if (vt->klass->valuetype) /*FIXME is this required variant iface?*/ + if (m_class_is_valuetype (vt->klass)) /*FIXME is this required variant iface?*/ need_unbox_tramp = TRUE; } else { - if (impl_method->klass->valuetype) + if (m_class_is_valuetype (impl_method->klass)) need_unbox_tramp = TRUE; } @@ -1614,7 +1614,7 @@ resolve_vcall (MonoVTable *vt, int slot, MonoMethod *imt_method, gpointer *out_a /* Avoid loading metadata or creating a generic vtable if possible */ addr = mono_aot_get_method_from_vt_slot (mono_domain_get (), vt, slot, error); return_val_if_nok (error, NULL); - if (addr && !vt->klass->valuetype) + if (addr && !m_class_is_valuetype (vt->klass)) return mono_create_ftnptr (mono_domain_get (), addr); m = mono_class_get_vtable_entry (vt->klass, slot); @@ -1643,10 +1643,10 @@ resolve_vcall (MonoVTable *vt, int slot, MonoMethod *imt_method, gpointer *out_a } if (generic_virtual) { - if (vt->klass->valuetype) + if (m_class_is_valuetype (vt->klass)) need_unbox_tramp = TRUE; } else { - if (m->klass->valuetype) + if (m_class_is_valuetype (m->klass)) need_unbox_tramp = TRUE; } @@ -1723,7 +1723,7 @@ mono_resolve_generic_virtual_call (MonoVTable *vt, int slot, MonoMethod *generic m = mono_class_inflate_generic_method_checked (declaring, &context, error); g_assert (mono_error_ok (error)); - if (vt->klass->valuetype) + if (m_class_is_valuetype (vt->klass)) need_unbox_tramp = TRUE; // FIXME: This can throw exceptions @@ -1771,7 +1771,7 @@ mono_resolve_generic_virtual_iface_call (MonoVTable *vt, int imt_slot, MonoMetho mono_llvm_throw_exception ((MonoObject*)ex); } - if (vt->klass->valuetype) + if (m_class_is_valuetype (vt->klass)) need_unbox_tramp = TRUE; if (m->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) @@ -1850,7 +1850,7 @@ mono_llvmonly_init_delegate (MonoDelegate *del) if (mono_error_set_pending_exception (error)) return; - if (m->klass->valuetype && mono_method_signature (m)->hasthis) + if (m_class_is_valuetype (m->klass) && mono_method_signature (m)->hasthis) addr = mono_aot_get_unbox_trampoline (m); gpointer arg = mini_get_delegate_arg (del->method, addr); @@ -1879,7 +1879,7 @@ mono_llvmonly_init_delegate_virtual (MonoDelegate *del, MonoObject *target, Mono del->method_ptr = mono_compile_method_checked (method, error); if (mono_error_set_pending_exception (error)) return; - if (method->klass->valuetype) + if (m_class_is_valuetype (method->klass)) del->method_ptr = mono_aot_get_unbox_trampoline (method); del->extra_arg = mini_get_delegate_arg (del->method, del->method_ptr); } diff --git a/mono/mini/memory-access.c b/mono/mini/memory-access.c index 6e943ffcdb0..038c79fc00e 100644 --- a/mono/mini/memory-access.c +++ b/mono/mini/memory-access.c @@ -246,13 +246,13 @@ create_write_barrier_bitmap (MonoCompile *cfg, MonoClass *klass, unsigned *wb_bi if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) continue; - foffset = klass->valuetype ? field->offset - sizeof (MonoObject): field->offset; + foffset = m_class_is_valuetype (klass) ? field->offset - sizeof (MonoObject): field->offset; if (mini_type_is_reference (mono_field_get_type (field))) { g_assert ((foffset % SIZEOF_VOID_P) == 0); *wb_bitmap |= 1 << ((offset + foffset) / SIZEOF_VOID_P); } else { MonoClass *field_class = mono_class_from_mono_type (field->type); - if (field_class->has_references) + if (m_class_has_references (field_class)) create_write_barrier_bitmap (cfg, field_class, wb_bitmap, offset + foffset); } } @@ -353,7 +353,7 @@ mini_emit_memory_copy_internal (MonoCompile *cfg, MonoInst *dest, MonoInst *src, */ if (cfg->gshared) - klass = mono_class_from_mono_type (mini_get_underlying_type (&klass->byval_arg)); + klass = mono_class_from_mono_type (mini_get_underlying_type (m_class_get_byval_arg (klass))); /* * This check breaks with spilled vars... need to handle it during verification anyway. @@ -376,7 +376,7 @@ mini_emit_memory_copy_internal (MonoCompile *cfg, MonoInst *dest, MonoInst *src, if (explicit_align) align = explicit_align; - if (mini_type_is_reference (&klass->byval_arg)) { // Refs *MUST* be naturally aligned + if (mini_type_is_reference (m_class_get_byval_arg (klass))) { // Refs *MUST* be naturally aligned MonoInst *store, *load; int dreg = alloc_ireg_ref (cfg); @@ -389,7 +389,7 @@ mini_emit_memory_copy_internal (MonoCompile *cfg, MonoInst *dest, MonoInst *src, mini_emit_write_barrier (cfg, dest, src); return; - } else if (cfg->gen_write_barriers && (klass->has_references || size_ins) && !native) { /* if native is true there should be no references in the struct */ + } else if (cfg->gen_write_barriers && (m_class_has_references (klass) || size_ins) && !native) { /* if native is true there should be no references in the struct */ /* Avoid barriers when storing to the stack */ if (!((dest->opcode == OP_ADD_IMM && dest->sreg1 == cfg->frame_reg) || (dest->opcode == OP_LDADDR))) { diff --git a/mono/mini/mini-amd64.c b/mono/mini/mini-amd64.c index 6634e492c90..49f4f25699e 100644 --- a/mono/mini/mini-amd64.c +++ b/mono/mini/mini-amd64.c @@ -642,7 +642,7 @@ add_valuetype (MonoMethodSignature *sig, ArgInfo *ainfo, MonoType *type, int struct_size; 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 (!sig->pinvoke && ((is_return && (size == 8)) || (!is_return && (size <= 16)))) { /* We pass and return vtypes of size 8 in a register */ @@ -664,7 +664,7 @@ add_valuetype (MonoMethodSignature *sig, ArgInfo *ainfo, MonoType *type, * handle nested structures. */ fields_array = g_array_new (FALSE, TRUE, sizeof (StructFieldInfo)); - collect_field_info_nested (klass, fields_array, 0, sig->pinvoke, klass->unicode); + collect_field_info_nested (klass, fields_array, 0, sig->pinvoke, m_class_is_unicode (klass)); fields = (StructFieldInfo*)fields_array->data; nfields = fields_array->len; @@ -1853,7 +1853,7 @@ mono_arch_create_vars (MonoCompile *cfg) sig_ret = mini_get_underlying_type (sig->ret); if (cinfo->ret.storage == ArgValuetypeAddrInIReg || cinfo->ret.storage == ArgGsharedvtVariableInReg) { - 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); @@ -1864,15 +1864,15 @@ mono_arch_create_vars (MonoCompile *cfg) MonoInst *ins; 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; } - 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; } @@ -1958,7 +1958,7 @@ emit_sig_cookie (MonoCompile *cfg, MonoCallInst *call, CallInfo *cinfo) * passed on the stack after the signature. So compensate by * passing a different signature. */ - tmp_sig = mono_metadata_signature_dup_full (cfg->method->klass->image, call->signature); + tmp_sig = mono_metadata_signature_dup_full (m_class_get_image (cfg->method->klass), call->signature); tmp_sig->param_count -= call->signature->sentinelpos; tmp_sig->sentinelpos = 0; memcpy (tmp_sig->params, call->signature->params + call->signature->sentinelpos, tmp_sig->param_count * sizeof (MonoType*)); @@ -2052,7 +2052,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); t = mini_type_get_underlying_type (t); linfo->args [i].storage = LLVMArgNone; @@ -2133,7 +2133,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) in = call->args [i]; if (sig->hasthis && i == 0) - t = &mono_defaults.object_class->byval_arg; + t = m_class_get_byval_arg (mono_defaults.object_class); else t = sig->params [i - sig->hasthis]; @@ -2179,7 +2179,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) in = call->args [i]; if (sig->hasthis && i == 0) - t = &mono_defaults.object_class->byval_arg; + t = m_class_get_byval_arg (mono_defaults.object_class); else t = sig->params [i - sig->hasthis]; t = mini_get_underlying_type (t); @@ -2280,7 +2280,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) * access it. */ 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; } @@ -2362,7 +2362,7 @@ mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src) g_assert (ainfo->storage == ArgValuetypeAddrInIReg || (ainfo->storage == ArgValuetypeAddrOnStack && ainfo->pair_storage [0] == ArgNone)); - 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); vtaddr->backend.is_pinvoke = call->signature->pinvoke; MONO_INST_NEW (cfg, load, OP_LDADDR); @@ -2409,7 +2409,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)); } } } @@ -2878,7 +2878,7 @@ emit_call_body (MonoCompile *cfg, guint8 *code, MonoJumpInfoType patch_type, gco near_call = TRUE; if ((patch_type == MONO_PATCH_INFO_METHOD) || (patch_type == MONO_PATCH_INFO_METHOD_JUMP)) { - if (((MonoMethod*)data)->klass->image->aot_module) + if (m_class_get_image (((MonoMethod*)data)->klass)->aot_module) /* The callee might be an AOT method */ near_call = FALSE; if (((MonoMethod*)data)->dynamic) @@ -3724,7 +3724,7 @@ amd64_handle_varargs_call (MonoCompile *cfg, guint8 *code, MonoCallInst *call, g guint32 nregs = 0; if (call->signature->call_convention == MONO_CALL_VARARG && call->signature->pinvoke) { // deliberatly nothing -- but nreg = 0 and do not return - } else if (cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE && cfg->method->klass->image != mono_defaults.corlib) { + } else if (cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE && m_class_get_image (cfg->method->klass) != mono_defaults.corlib) { /* * Since the unmanaged calling convention doesn't contain a * 'vararg' entry, we have to treat every pinvoke call as a @@ -7402,7 +7402,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg) exc_classes [nthrows] = exc_class; exc_throw_start [nthrows] = code; } - amd64_mov_reg_imm (code, AMD64_ARG_REG1, exc_class->type_token - MONO_TOKEN_TYPE_DEF); + amd64_mov_reg_imm (code, AMD64_ARG_REG1, m_class_get_type_token (exc_class) - MONO_TOKEN_TYPE_DEF); patch_info->type = MONO_PATCH_INFO_NONE; diff --git a/mono/mini/mini-codegen.c b/mono/mini/mini-codegen.c index 8067e55be1a..3209b72d5f0 100644 --- a/mono/mini/mini-codegen.c +++ b/mono/mini/mini-codegen.c @@ -502,7 +502,7 @@ mono_print_ins_index_strbuf (int i, MonoInst *ins) break; case OP_ISINST: case OP_CASTCLASS: - g_string_append_printf (sbuf, " %s", ins->klass->name); + g_string_append_printf (sbuf, " %s", m_class_get_name (ins->klass)); break; default: break; @@ -2729,9 +2729,9 @@ mini_type_is_hfa (MonoType *t, int *out_nfields, int *out_esize) if (!mini_type_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; diff --git a/mono/mini/mini-exceptions.c b/mono/mini/mini-exceptions.c index f945aea82d8..03193a176fd 100644 --- a/mono/mini/mini-exceptions.c +++ b/mono/mini/mini-exceptions.c @@ -780,7 +780,7 @@ get_generic_info_from_stack_frame (MonoJitInfo *ji, MonoContext *ctx) if (mono_method_get_context (method)->method_inst) { /* A MonoMethodRuntimeGenericContext* */ return info; - } else if ((method->flags & METHOD_ATTRIBUTE_STATIC) || method->klass->valuetype) { + } else if ((method->flags & METHOD_ATTRIBUTE_STATIC) || m_class_is_valuetype (method->klass)) { /* A MonoVTable* */ return info; } else { @@ -825,7 +825,7 @@ get_generic_context_from_stack_frame (MonoJitInfo *ji, gpointer generic_info) /* class might refer to a subclass of method's class */ while (!(klass == method->klass || (mono_class_is_ginst (klass) && mono_class_get_generic_class (klass)->container_class == method_container_class))) { - klass = klass->parent; + klass = m_class_get_parent (klass); g_assert (klass); } @@ -1390,7 +1390,7 @@ get_exception_catch_class (MonoJitExceptionInfo *ei, MonoJitInfo *ji, MonoContex when the exception is actually thrown, so as not to waste space for exception clauses which might never be encountered. */ - inflated_type = mono_class_inflate_generic_type_checked (&catch_class->byval_arg, &context, error); + inflated_type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (catch_class), &context, error); mono_error_assert_ok (error); /* FIXME don't swallow the error */ catch_class = mono_class_from_mono_type (inflated_type); @@ -1470,7 +1470,7 @@ static gboolean wrap_non_exception_throws (MonoMethod *m) { ERROR_DECL (error); - MonoAssembly *ass = m->klass->image->assembly; + MonoAssembly *ass = m_class_get_image (m->klass)->assembly; MonoCustomAttrInfo* attrs; MonoClass *klass; int i; @@ -1921,7 +1921,7 @@ mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resu } if (mono_ex && jit_tls->class_cast_from) { - if (!strcmp (mono_ex->object.vtable->klass->name, "InvalidCastException")) { + if (!strcmp (m_class_get_name (mono_ex->object.vtable->klass), "InvalidCastException")) { char *from_name = mono_type_get_full_name (jit_tls->class_cast_from); char *to_name = mono_type_get_full_name (jit_tls->class_cast_to); char *msg = g_strdup_printf ("Unable to cast object of type '%s' to type '%s'.", from_name, to_name); @@ -1934,7 +1934,7 @@ mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resu } g_free (msg); } - if (!strcmp (mono_ex->object.vtable->klass->name, "ArrayTypeMismatchException")) { + if (!strcmp (m_class_get_name (mono_ex->object.vtable->klass), "ArrayTypeMismatchException")) { char *from_name = mono_type_get_full_name (jit_tls->class_cast_from); char *to_name = mono_type_get_full_name (jit_tls->class_cast_to); char *msg = g_strdup_printf ("Source array of type '%s' cannot be cast to destination array type '%s'.", from_name, to_name); @@ -1993,7 +1993,7 @@ mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resu msg = g_strdup ("(System.Exception.Message property not available)"); } } - g_print ("[%p:] EXCEPTION handling: %s.%s: %s\n", (void*)mono_native_thread_id_get (), mono_object_class (obj)->name_space, mono_object_class (obj)->name, msg); + g_print ("[%p:] EXCEPTION handling: %s.%s: %s\n", (void*)mono_native_thread_id_get (), m_class_get_name_space (mono_object_class (obj)), m_class_get_name (mono_object_class (obj)), msg); g_free (msg); if (mono_ex && mono_trace_eval_exception (mono_object_class (mono_ex))) mono_print_thread_dump_from_ctx (ctx); @@ -3271,7 +3271,7 @@ mono_llvm_throw_corlib_exception (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); mono_llvm_throw_exception ((MonoObject*)ex); } @@ -3387,13 +3387,13 @@ mono_llvm_match_exception (MonoJitInfo *jinfo, guint32 region_start, guint32 reg continue; catch_class = ei->data.catch_class; - if (mono_class_is_open_constructed_type (&catch_class->byval_arg)) { + if (mono_class_is_open_constructed_type (m_class_get_byval_arg (catch_class))) { MonoGenericContext context; MonoType *inflated_type; g_assert (rgctx || this_obj); context = get_generic_context_from_stack_frame (jinfo, rgctx ? rgctx : this_obj->vtable); - inflated_type = mono_class_inflate_generic_type_checked (&catch_class->byval_arg, &context, error); + inflated_type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (catch_class), &context, error); mono_error_assert_ok (error); /* FIXME don't swallow the error */ catch_class = mono_class_from_mono_type (inflated_type); diff --git a/mono/mini/mini-generic-sharing.c b/mono/mini/mini-generic-sharing.c index 81ca3204223..eb161ce4f98 100644 --- a/mono/mini/mini-generic-sharing.c +++ b/mono/mini/mini-generic-sharing.c @@ -150,8 +150,8 @@ mono_class_check_context_used (MonoClass *klass) { int context_used = 0; - context_used |= type_check_context_used (&klass->this_arg, FALSE); - context_used |= type_check_context_used (&klass->byval_arg, FALSE); + context_used |= type_check_context_used (m_class_get_this_arg (klass), FALSE); + context_used |= type_check_context_used (m_class_get_byval_arg (klass), FALSE); if (mono_class_is_ginst (klass)) context_used |= mono_generic_context_check_used (&mono_class_get_generic_class (klass)->context); @@ -256,10 +256,10 @@ static GHashTable *generic_subclass_hash; static void class_set_rgctx_template (MonoClass *klass, MonoRuntimeGenericContextTemplate *rgctx_template) { - if (!klass->image->rgctx_template_hash) - klass->image->rgctx_template_hash = g_hash_table_new (mono_aligned_addr_hash, NULL); + if (!m_class_get_image (klass)->rgctx_template_hash) + m_class_get_image (klass)->rgctx_template_hash = g_hash_table_new (mono_aligned_addr_hash, NULL); - g_hash_table_insert (klass->image->rgctx_template_hash, klass, rgctx_template); + g_hash_table_insert (m_class_get_image (klass)->rgctx_template_hash, klass, rgctx_template); } /* @@ -270,10 +270,10 @@ class_lookup_rgctx_template (MonoClass *klass) { MonoRuntimeGenericContextTemplate *template_; - if (!klass->image->rgctx_template_hash) + if (!m_class_get_image (klass)->rgctx_template_hash) return NULL; - template_ = (MonoRuntimeGenericContextTemplate *)g_hash_table_lookup (klass->image->rgctx_template_hash, klass); + template_ = (MonoRuntimeGenericContextTemplate *)g_hash_table_lookup (m_class_get_image (klass)->rgctx_template_hash, klass); return template_; } @@ -284,7 +284,7 @@ class_lookup_rgctx_template (MonoClass *klass) static void register_generic_subclass (MonoClass *klass) { - MonoClass *parent = klass->parent; + MonoClass *parent = m_class_get_parent (klass); MonoClass *subclass; MonoRuntimeGenericContextTemplate *rgctx_template = class_lookup_rgctx_template (klass); @@ -306,14 +306,14 @@ move_subclasses_not_in_image_foreach_func (MonoClass *klass, MonoClass *subclass { MonoClass *new_list; - if (klass->image == image) { + if (m_class_get_image (klass) == image) { /* The parent class itself is in the image, so all the subclasses must be in the image, too. If not, we're removing an image containing a class which still has a subclass in another image. */ while (subclass) { - g_assert (subclass->image == image); + g_assert (m_class_get_image (subclass) == image); subclass = class_lookup_rgctx_template (subclass)->next_subclass; } @@ -325,7 +325,7 @@ move_subclasses_not_in_image_foreach_func (MonoClass *klass, MonoClass *subclass MonoRuntimeGenericContextTemplate *subclass_template = class_lookup_rgctx_template (subclass); MonoClass *next = subclass_template->next_subclass; - if (subclass->image != image) { + if (m_class_get_image (subclass) != image) { subclass_template->next_subclass = new_list; new_list = subclass; } @@ -374,7 +374,7 @@ alloc_template (MonoClass *klass) mono_atomic_inc_i32 (&rgctx_template_num_allocated); mono_atomic_fetch_add_i32 (&rgctx_template_bytes_allocated, size); - return (MonoRuntimeGenericContextTemplate *)mono_image_alloc0 (klass->image, size); + return (MonoRuntimeGenericContextTemplate *)mono_image_alloc0 (m_class_get_image (klass), size); } /* LOCKING: Takes the loader lock */ @@ -389,7 +389,7 @@ alloc_oti (MonoImage *image) return (MonoRuntimeGenericContextInfoTemplate *)mono_image_alloc0 (image, size); } -#define MONO_RGCTX_SLOT_USED_MARKER ((gpointer)&mono_defaults.object_class->byval_arg) +#define MONO_RGCTX_SLOT_USED_MARKER ((gpointer)m_class_get_byval_arg (mono_defaults.object_class)) /* * Return true if this info type has the notion of identify. @@ -505,8 +505,9 @@ mono_class_get_method_generic (MonoClass *klass, MonoMethod *method, MonoError * if (mono_class_has_failure (klass)) return NULL; int mcount = mono_class_get_method_count (klass); + MonoMethod **klass_methods = m_class_get_methods (klass); for (i = 0; i < mcount; ++i) { - m = klass->methods [i]; + m = klass_methods [i]; if (m == declaring) break; if (m->is_inflated && mono_method_get_declaring_generic_method (m) == declaring) @@ -559,7 +560,7 @@ inflate_info (MonoRuntimeGenericContextInfoTemplate *oti, MonoGenericContext *co case MONO_RGCTX_INFO_LOCAL_OFFSET: case MONO_RGCTX_INFO_NULLABLE_CLASS_BOX: case MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX: { - gpointer result = mono_class_inflate_generic_type_with_mempool (temporary ? NULL : klass->image, + gpointer result = mono_class_inflate_generic_type_with_mempool (temporary ? NULL : m_class_get_image (klass), (MonoType *)data, context, error); mono_error_assert_msg_ok (error, "Could not inflate generic type"); /* FIXME proper error handling */ return result; @@ -574,7 +575,7 @@ inflate_info (MonoRuntimeGenericContextInfoTemplate *oti, MonoGenericContext *co case MONO_RGCTX_INFO_METHOD_DELEGATE_CODE: { MonoMethod *method = (MonoMethod *)data; MonoMethod *inflated_method; - MonoType *inflated_type = mono_class_inflate_generic_type_checked (&method->klass->byval_arg, context, error); + MonoType *inflated_type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (method->klass), context, error); mono_error_assert_ok (error); /* FIXME don't swallow the error */ MonoClass *inflated_class = mono_class_from_mono_type (inflated_type); @@ -585,8 +586,8 @@ inflate_info (MonoRuntimeGenericContextInfoTemplate *oti, MonoGenericContext *co g_assert (!method->wrapper_type); - if (inflated_class->byval_arg.type == MONO_TYPE_ARRAY || - inflated_class->byval_arg.type == MONO_TYPE_SZARRAY) { + if (m_class_get_byval_arg (inflated_class)->type == MONO_TYPE_ARRAY || + m_class_get_byval_arg (inflated_class)->type == MONO_TYPE_SZARRAY) { inflated_method = mono_method_search_in_array_class (inflated_class, method->name, method->signature); } else { @@ -627,7 +628,7 @@ inflate_info (MonoRuntimeGenericContextInfoTemplate *oti, MonoGenericContext *co MonoJumpInfoGSharedVtCall *info = (MonoJumpInfoGSharedVtCall *)data; MonoMethod *method = info->method; MonoMethod *inflated_method; - MonoType *inflated_type = mono_class_inflate_generic_type_checked (&method->klass->byval_arg, context, error); + MonoType *inflated_type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (method->klass), context, error); mono_error_assert_ok (error); /* FIXME don't swallow the error */ WrapperInfo *winfo = NULL; @@ -651,8 +652,8 @@ inflate_info (MonoRuntimeGenericContextInfoTemplate *oti, MonoGenericContext *co method = winfo->d.synchronized_inner.method; } - if (inflated_class->byval_arg.type == MONO_TYPE_ARRAY || - inflated_class->byval_arg.type == MONO_TYPE_SZARRAY) { + if (m_class_get_byval_arg (inflated_class)->type == MONO_TYPE_ARRAY || + m_class_get_byval_arg (inflated_class)->type == MONO_TYPE_SZARRAY) { inflated_method = mono_method_search_in_array_class (inflated_class, method->name, method->signature); } else { @@ -677,19 +678,19 @@ inflate_info (MonoRuntimeGenericContextInfoTemplate *oti, MonoGenericContext *co case MONO_RGCTX_INFO_FIELD_OFFSET: { ERROR_DECL (error); MonoClassField *field = (MonoClassField *)data; - MonoType *inflated_type = mono_class_inflate_generic_type_checked (&field->parent->byval_arg, context, error); + MonoType *inflated_type = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (field->parent), context, error); mono_error_assert_ok (error); /* FIXME don't swallow the error */ MonoClass *inflated_class = mono_class_from_mono_type (inflated_type); - int i = field - field->parent->fields; + int i = field - m_class_get_fields (field->parent); gpointer dummy = NULL; mono_metadata_free_type (inflated_type); mono_class_get_fields (inflated_class, &dummy); - g_assert (inflated_class->fields); + g_assert (m_class_get_fields (inflated_class)); - return &inflated_class->fields [i]; + return &m_class_get_fields (inflated_class) [i]; } case MONO_RGCTX_INFO_SIG_GSHAREDVT_IN_TRAMPOLINE_CALLI: case MONO_RGCTX_INFO_SIG_GSHAREDVT_OUT_TRAMPOLINE_CALLI: { @@ -711,7 +712,7 @@ inflate_info (MonoRuntimeGenericContextInfoTemplate *oti, MonoGenericContext *co // FIXME: Temporary res = (MonoJumpInfoVirtMethod *)mono_domain_alloc0 (domain, sizeof (MonoJumpInfoVirtMethod)); - t = mono_class_inflate_generic_type_checked (&info->klass->byval_arg, context, error); + t = mono_class_inflate_generic_type_checked (m_class_get_byval_arg (info->klass), context, error); mono_error_assert_ok (error); /* FIXME don't swallow the error */ res->klass = mono_class_from_mono_type (t); @@ -800,11 +801,11 @@ mono_class_get_runtime_generic_context_template (MonoClass *klass) mono_loader_lock (); - if (klass->parent) { + if (m_class_get_parent (klass)) { guint32 num_entries; int max_argc, type_argc; - parent_template = mono_class_get_runtime_generic_context_template (klass->parent); + parent_template = mono_class_get_runtime_generic_context_template (m_class_get_parent (klass)); max_argc = template_get_max_argc (parent_template); for (type_argc = 0; type_argc <= max_argc; ++type_argc) { @@ -814,9 +815,9 @@ mono_class_get_runtime_generic_context_template (MonoClass *klass) for (i = 0; i < num_entries; ++i) { MonoRuntimeGenericContextInfoTemplate oti; - oti = class_get_rgctx_template_oti (klass->parent, type_argc, i, FALSE, FALSE, NULL); + oti = class_get_rgctx_template_oti (m_class_get_parent (klass), type_argc, i, FALSE, FALSE, NULL); if (oti.data && oti.data != MONO_RGCTX_SLOT_USED_MARKER) { - rgctx_template_set_slot (klass->image, template_, type_argc, i, + rgctx_template_set_slot (m_class_get_image (klass), template_, type_argc, i, oti.data, oti.info_type); } } @@ -829,7 +830,7 @@ mono_class_get_runtime_generic_context_template (MonoClass *klass) } else { class_set_rgctx_template (klass, template_); - if (klass->parent) + if (m_class_get_parent (klass)) register_generic_subclass (klass); } @@ -902,7 +903,7 @@ class_type_info (MonoDomain *domain, MonoClass *klass, MonoRgctxInfoType info_ty case MONO_RGCTX_INFO_KLASS: return klass; case MONO_RGCTX_INFO_ELEMENT_KLASS: - return klass->element_class; + return m_class_get_element_class (klass); case MONO_RGCTX_INFO_VTABLE: { MonoVTable *vtable = mono_class_vtable_checked (domain, klass, error); return_val_if_nok (error, NULL); @@ -917,12 +918,12 @@ class_type_info (MonoDomain *domain, MonoClass *klass, MonoRgctxInfoType info_ty case MONO_RGCTX_INFO_ARRAY_ELEMENT_SIZE: return GUINT_TO_POINTER (mono_class_array_element_size (klass)); case MONO_RGCTX_INFO_VALUE_SIZE: - if (MONO_TYPE_IS_REFERENCE (&klass->byval_arg)) + if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (klass))) return GUINT_TO_POINTER (sizeof (gpointer)); else return GUINT_TO_POINTER (mono_class_value_size (klass, NULL)); case MONO_RGCTX_INFO_CLASS_BOX_TYPE: - if (MONO_TYPE_IS_REFERENCE (&klass->byval_arg)) + if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (klass))) return GUINT_TO_POINTER (MONO_GSHAREDVT_BOX_TYPE_REF); else if (mono_class_is_nullable (klass)) return GUINT_TO_POINTER (MONO_GSHAREDVT_BOX_TYPE_NULLABLE); @@ -931,7 +932,7 @@ class_type_info (MonoDomain *domain, MonoClass *klass, MonoRgctxInfoType info_ty case MONO_RGCTX_INFO_CLASS_IS_REF_OR_CONTAINS_REFS: mono_class_init (klass); /* Can't return 0 */ - if (MONO_TYPE_IS_REFERENCE (&klass->byval_arg) || klass->has_references) + if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (klass)) || m_class_has_references (klass)) return GUINT_TO_POINTER (2); else return GUINT_TO_POINTER (1); @@ -945,7 +946,7 @@ class_type_info (MonoDomain *domain, MonoClass *klass, MonoRgctxInfoType info_ty domain_info = domain_jit_info (domain); - if (MONO_TYPE_IS_REFERENCE (&klass->byval_arg)) { + if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (klass))) { size = sizeof (gpointer); align = sizeof (gpointer); } else { @@ -1105,23 +1106,23 @@ static MonoType* get_wrapper_shared_type (MonoType *t) { if (t->byref) - return &mono_defaults.int_class->this_arg; + return m_class_get_this_arg (mono_defaults.int_class); t = mini_get_underlying_type (t); switch (t->type) { case MONO_TYPE_I1: /* This removes any attributes etc. */ - return &mono_defaults.sbyte_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.sbyte_class); case MONO_TYPE_U1: - return &mono_defaults.byte_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.byte_class); case MONO_TYPE_I2: - return &mono_defaults.int16_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.int16_class); case MONO_TYPE_U2: - return &mono_defaults.uint16_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.uint16_class); case MONO_TYPE_I4: - return &mono_defaults.int32_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.int32_class); case MONO_TYPE_U4: - return &mono_defaults.uint32_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.uint32_class); case MONO_TYPE_OBJECT: case MONO_TYPE_CLASS: case MONO_TYPE_SZARRAY: @@ -1130,7 +1131,7 @@ get_wrapper_shared_type (MonoType *t) // FIXME: refs and intptr cannot be shared because // they are treated differently when a method has a vret arg, // see get_call_info (). - return &mono_defaults.object_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.object_class); //return &mono_defaults.int_class->byval_arg; case MONO_TYPE_GENERICINST: { ERROR_DECL (error); @@ -1142,7 +1143,7 @@ get_wrapper_shared_type (MonoType *t) int i; if (!MONO_TYPE_ISSTRUCT (t)) - return get_wrapper_shared_type (&mono_defaults.object_class->byval_arg); + return get_wrapper_shared_type (m_class_get_byval_arg (mono_defaults.object_class)); klass = mono_class_from_mono_type (t); orig_ctx = &mono_class_get_generic_class (klass)->context; @@ -1165,11 +1166,11 @@ get_wrapper_shared_type (MonoType *t) } klass = mono_class_inflate_generic_class_checked (mono_class_get_generic_class (klass)->container_class, &ctx, error); mono_error_assert_ok (error); /* FIXME don't swallow the error */ - return &klass->byval_arg; + return m_class_get_byval_arg (klass); } #if SIZEOF_VOID_P == 8 case MONO_TYPE_I8: - return &mono_defaults.int_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.int_class); #endif default: break; @@ -1232,7 +1233,7 @@ mini_get_gsharedvt_in_sig_wrapper (MonoMethodSignature *sig) csig = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + ((sig->param_count + 1) * sizeof (MonoType*))); memcpy (csig, sig, mono_metadata_signature_size (sig)); csig->param_count ++; - csig->params [sig->param_count] = &mono_defaults.int_class->byval_arg; + csig->params [sig->param_count] = m_class_get_byval_arg (mono_defaults.int_class); /* Create the signature for the gsharedvt callconv */ gsharedvt_sig = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + ((sig->param_count + 2) * sizeof (MonoType*))); @@ -1240,8 +1241,8 @@ mini_get_gsharedvt_in_sig_wrapper (MonoMethodSignature *sig) pindex = 0; /* The return value is returned using an explicit vret argument */ if (sig->ret->type != MONO_TYPE_VOID) { - gsharedvt_sig->params [pindex ++] = &mono_defaults.int_class->byval_arg; - gsharedvt_sig->ret = &mono_defaults.void_class->byval_arg; + gsharedvt_sig->params [pindex ++] = m_class_get_byval_arg (mono_defaults.int_class); + gsharedvt_sig->ret = m_class_get_byval_arg (mono_defaults.void_class); } for (i = 0; i < sig->param_count; i++) { gsharedvt_sig->params [pindex] = sig->params [i]; @@ -1252,7 +1253,7 @@ mini_get_gsharedvt_in_sig_wrapper (MonoMethodSignature *sig) pindex ++; } /* Rgctx arg */ - gsharedvt_sig->params [pindex ++] = &mono_defaults.int_class->byval_arg; + gsharedvt_sig->params [pindex ++] = m_class_get_byval_arg (mono_defaults.int_class); gsharedvt_sig->param_count = pindex; // FIXME: Use shared signatures @@ -1338,8 +1339,8 @@ mini_get_gsharedvt_out_sig_wrapper (MonoMethodSignature *sig) pindex = 0; /* The return value is returned using an explicit vret argument */ if (sig->ret->type != MONO_TYPE_VOID) { - csig->params [pindex ++] = &mono_defaults.int_class->byval_arg; - csig->ret = &mono_defaults.void_class->byval_arg; + csig->params [pindex ++] = m_class_get_byval_arg (mono_defaults.int_class); + csig->ret = m_class_get_byval_arg (mono_defaults.void_class); } args_start = pindex; if (sig->hasthis) @@ -1353,14 +1354,14 @@ mini_get_gsharedvt_out_sig_wrapper (MonoMethodSignature *sig) pindex ++; } /* Rgctx arg */ - csig->params [pindex ++] = &mono_defaults.int_class->byval_arg; + csig->params [pindex ++] = m_class_get_byval_arg (mono_defaults.int_class); csig->param_count = pindex; /* Create the signature for the normal callconv */ normal_sig = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + ((sig->param_count + 2) * sizeof (MonoType*))); memcpy (normal_sig, sig, mono_metadata_signature_size (sig)); normal_sig->param_count ++; - normal_sig->params [sig->param_count] = &mono_defaults.int_class->byval_arg; + normal_sig->params [sig->param_count] = m_class_get_byval_arg (mono_defaults.int_class); // FIXME: Use shared signatures mb = mono_mb_new (mono_defaults.object_class, "gsharedvt_out_sig", MONO_WRAPPER_UNKNOWN); @@ -1475,6 +1476,7 @@ mini_get_interp_in_wrapper (MonoMethodSignature *sig) csig = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + (sig->param_count * sizeof (MonoType*))); memcpy (csig, sig, mono_metadata_signature_size (sig)); + MonoType *int_type = m_class_get_byval_arg (mono_defaults.int_class); /* Create the signature for the callee callconv */ if (generic) { /* @@ -1482,12 +1484,12 @@ mini_get_interp_in_wrapper (MonoMethodSignature *sig) * interp_entry_general (gpointer this_arg, gpointer res, gpointer *args, gpointer rmethod) */ entry_sig = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + (4 * sizeof (MonoType*))); - entry_sig->ret = &mono_defaults.void_class->byval_arg; + entry_sig->ret = m_class_get_byval_arg (mono_defaults.void_class); entry_sig->param_count = 4; - entry_sig->params [0] = &mono_defaults.int_class->byval_arg; - entry_sig->params [1] = &mono_defaults.int_class->byval_arg; - entry_sig->params [2] = &mono_defaults.int_class->byval_arg; - entry_sig->params [3] = &mono_defaults.int_class->byval_arg; + entry_sig->params [0] = int_type; + entry_sig->params [1] = int_type; + entry_sig->params [2] = int_type; + entry_sig->params [3] = int_type; name = "interp_in_generic"; generic = TRUE; } else { @@ -1500,8 +1502,8 @@ mini_get_interp_in_wrapper (MonoMethodSignature *sig) pindex = 0; /* The return value is returned using an explicit vret argument */ if (sig->ret->type != MONO_TYPE_VOID) { - entry_sig->params [pindex ++] = &mono_defaults.int_class->byval_arg; - entry_sig->ret = &mono_defaults.void_class->byval_arg; + entry_sig->params [pindex ++] = int_type; + entry_sig->ret = m_class_get_byval_arg (mono_defaults.void_class); } for (i = 0; i < sig->param_count; i++) { entry_sig->params [pindex] = sig->params [i]; @@ -1512,7 +1514,7 @@ mini_get_interp_in_wrapper (MonoMethodSignature *sig) pindex ++; } /* Extra arg */ - entry_sig->params [pindex ++] = &mono_defaults.int_class->byval_arg; + entry_sig->params [pindex ++] = int_type; entry_sig->param_count = pindex; name = sig->hasthis ? "interp_in" : "interp_in_static"; } @@ -1529,7 +1531,7 @@ mini_get_interp_in_wrapper (MonoMethodSignature *sig) #ifndef DISABLE_JIT if (return_native_struct) { - retval_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg); + retval_var = mono_mb_add_local (mb, int_type); mono_mb_emit_icon (mb, mono_class_native_size (sig->ret->data.klass, NULL)); mono_mb_emit_byte (mb, CEE_PREFIX1); mono_mb_emit_byte (mb, CEE_LOCALLOC); @@ -1541,7 +1543,7 @@ mini_get_interp_in_wrapper (MonoMethodSignature *sig) /* Make the call */ if (generic) { /* Collect arguments */ - int args_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg); + int args_var = mono_mb_add_local (mb, int_type); mono_mb_emit_icon (mb, sizeof (gpointer) * sig->param_count); mono_mb_emit_byte (mb, CEE_PREFIX1); @@ -1630,21 +1632,22 @@ mini_get_gsharedvt_out_sig_wrapper_signature (gboolean has_this, gboolean has_re { MonoMethodSignature *sig = g_malloc0 (sizeof (MonoMethodSignature) + (32 * sizeof (MonoType*))); int i, pindex; + MonoType *int_type = m_class_get_byval_arg (mono_defaults.int_class); - sig->ret = &mono_defaults.void_class->byval_arg; + sig->ret = m_class_get_byval_arg (mono_defaults.void_class); sig->sentinelpos = -1; pindex = 0; if (has_this) /* this */ - sig->params [pindex ++] = &mono_defaults.int_class->byval_arg; + sig->params [pindex ++] = int_type; if (has_ret) /* vret */ - sig->params [pindex ++] = &mono_defaults.int_class->byval_arg; + sig->params [pindex ++] = int_type; for (i = 0; i < param_count; ++i) /* byref arguments */ - sig->params [pindex ++] = &mono_defaults.int_class->byval_arg; + sig->params [pindex ++] = int_type; /* extra arg */ - sig->params [pindex ++] = &mono_defaults.int_class->byval_arg; + sig->params [pindex ++] = int_type; sig->param_count = pindex; return sig; @@ -1875,8 +1878,8 @@ instantiate_info (MonoDomain *domain, MonoRuntimeGenericContextInfoTemplate *oti } slot = mono_method_get_vtable_slot (info->method); g_assert (slot != -1); - g_assert (info->klass->vtable); - method = info->klass->vtable [ioffset + slot]; + g_assert (m_class_get_vtable (info->klass)); + method = m_class_get_vtable (info->klass) [ioffset + slot]; method = mono_class_inflate_generic_method_checked (method, context, error); return_val_if_nok (error, NULL); @@ -1910,11 +1913,11 @@ instantiate_info (MonoDomain *domain, MonoRuntimeGenericContextInfoTemplate *oti } slot = mono_method_get_vtable_slot (info->method); g_assert (slot != -1); - g_assert (info->klass->vtable); - method = info->klass->vtable [ioffset + slot]; + g_assert (m_class_get_vtable (info->klass)); + method = m_class_get_vtable (info->klass) [ioffset + slot]; impl_class = method->klass; - if (MONO_TYPE_IS_REFERENCE (&impl_class->byval_arg)) + if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (impl_class))) return GUINT_TO_POINTER (MONO_GSHAREDVT_BOX_TYPE_REF); else if (mono_class_is_nullable (impl_class)) return GUINT_TO_POINTER (MONO_GSHAREDVT_BOX_TYPE_NULLABLE); @@ -1936,7 +1939,7 @@ instantiate_info (MonoDomain *domain, MonoRuntimeGenericContextInfoTemplate *oti MonoClassField *field = (MonoClassField *)data; /* The value is offset by 1 */ - if (field->parent->valuetype && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) + if (m_class_is_valuetype (field->parent) && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) return GUINT_TO_POINTER (field->offset - sizeof (MonoObject) + 1); else return GUINT_TO_POINTER (field->offset + 1); @@ -2007,7 +2010,7 @@ instantiate_info (MonoDomain *domain, MonoRuntimeGenericContextInfoTemplate *oti if (virtual_) { /* Same as in mono_emit_method_call_full () */ - if ((method->klass->parent == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) { + if ((m_class_get_parent (method->klass) == mono_defaults.multicastdelegate_class) && (!strcmp (method->name, "Invoke"))) { /* See mono_emit_method_call_full () */ /* The gsharedvt trampoline will recognize this constant */ vcall_offset = MONO_GSHAREDVT_DEL_INVOKE_VT_OFFSET; @@ -2185,7 +2188,7 @@ fill_in_rgctx_template_slot (MonoClass *klass, int type_argc, int index, gpointe MonoRuntimeGenericContextTemplate *template_ = mono_class_get_runtime_generic_context_template (klass); MonoClass *subclass; - rgctx_template_set_slot (klass->image, template_, type_argc, index, data, info_type); + rgctx_template_set_slot (m_class_get_image (klass), template_, type_argc, index, data, info_type); /* Recurse for all subclasses */ if (generic_subclass_hash) @@ -2199,7 +2202,7 @@ fill_in_rgctx_template_slot (MonoClass *klass, int type_argc, int index, gpointe g_assert (subclass_template); - subclass_oti = class_get_rgctx_template_oti (subclass->parent, type_argc, index, FALSE, FALSE, NULL); + subclass_oti = class_get_rgctx_template_oti (m_class_get_parent (subclass), type_argc, index, FALSE, FALSE, NULL); g_assert (subclass_oti.data); fill_in_rgctx_template_slot (subclass, type_argc, index, subclass_oti.data, info_type); @@ -2279,7 +2282,7 @@ register_info (MonoClass *klass, int type_argc, gpointer data, MonoRgctxInfoType /* Mark the slot as used in all parent classes (until we find a parent class which already has it marked used). */ - parent = klass->parent; + parent = m_class_get_parent (klass); while (parent != NULL) { MonoRuntimeGenericContextTemplate *parent_template; MonoRuntimeGenericContextInfoTemplate *oti; @@ -2293,10 +2296,10 @@ register_info (MonoClass *klass, int type_argc, gpointer data, MonoRgctxInfoType if (oti && oti->data) break; - rgctx_template_set_slot (parent->image, parent_template, type_argc, i, + rgctx_template_set_slot (m_class_get_image (parent), parent_template, type_argc, i, MONO_RGCTX_SLOT_USED_MARKER, (MonoRgctxInfoType)0); - parent = parent->parent; + parent = m_class_get_parent (parent); } /* Fill in the slot in this class and in all subclasses @@ -2749,7 +2752,7 @@ type_is_sharable (MonoType *type, gboolean allow_type_vars, gboolean allow_parti return TRUE; /* Allow non ref arguments if they are primitive types or enums (partial sharing). */ - if (allow_partial && !type->byref && (((type->type >= MONO_TYPE_BOOLEAN) && (type->type <= MONO_TYPE_R8)) || (type->type == MONO_TYPE_I) || (type->type == MONO_TYPE_U) || (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype))) + if (allow_partial && !type->byref && (((type->type >= MONO_TYPE_BOOLEAN) && (type->type <= MONO_TYPE_R8)) || (type->type == MONO_TYPE_I) || (type->type == MONO_TYPE_U) || (type->type == MONO_TYPE_VALUETYPE && m_class_is_enumtype (type->data.klass)))) return TRUE; if (allow_partial && !type->byref && type->type == MONO_TYPE_GENERICINST && MONO_TYPE_ISSTRUCT (type)) { @@ -2898,7 +2901,7 @@ is_async_state_machine_class (MonoClass *klass) iclass = mono_class_try_get_iasync_state_machine_class (); - if (iclass && klass->valuetype && mono_class_is_assignable_from (iclass, klass)) + if (iclass && m_class_is_valuetype (klass) && mono_class_is_assignable_from (iclass, klass)) return TRUE; return FALSE; } @@ -2919,8 +2922,8 @@ is_async_method (MonoMethod *method) /* Do less expensive checks first */ sig = mono_method_signature (method); if (attr_class && sig && ((sig->ret->type == MONO_TYPE_VOID) || - (sig->ret->type == MONO_TYPE_CLASS && !strcmp (sig->ret->data.generic_class->container_class->name, "Task")) || - (sig->ret->type == MONO_TYPE_GENERICINST && !strcmp (sig->ret->data.generic_class->container_class->name, "Task`1")))) { + (sig->ret->type == MONO_TYPE_CLASS && !strcmp (m_class_get_name (sig->ret->data.generic_class->container_class), "Task")) || + (sig->ret->type == MONO_TYPE_GENERICINST && !strcmp (m_class_get_name (sig->ret->data.generic_class->container_class), "Task`1")))) { //printf ("X: %s\n", mono_method_full_name (method, TRUE)); cattr = mono_custom_attrs_from_method_checked (method, error); if (!is_ok (error)) { @@ -2966,7 +2969,7 @@ mono_method_is_generic_sharable_full (MonoMethod *method, gboolean allow_type_va // FIXME: allow_partial = FALSE; - if (method->klass->image->dynamic) + if (m_class_get_image (method->klass)->dynamic) /* * Enabling this causes corlib test failures because the JIT encounters generic instances whose * instance_size is 0. @@ -3053,7 +3056,7 @@ mono_method_needs_static_rgctx_invoke (MonoMethod *method, gboolean allow_type_v return TRUE; return ((method->flags & METHOD_ATTRIBUTE_STATIC) || - method->klass->valuetype || + m_class_is_valuetype (method->klass) || mini_method_is_default_method (method)) && (mono_class_is_ginst (method->klass) || mono_class_is_gtd (method->klass)); } @@ -3066,8 +3069,9 @@ get_object_generic_inst (int type_argc) type_argv = (MonoType **)alloca (sizeof (MonoType*) * type_argc); + MonoType *object_type = m_class_get_byval_arg (mono_defaults.object_class); for (i = 0; i < type_argc; ++i) - type_argv [i] = &mono_defaults.object_class->byval_arg; + type_argv [i] = object_type; return mono_metadata_get_generic_inst (type_argc, type_argv); } @@ -3163,7 +3167,7 @@ mono_method_check_context_used (MonoMethod *method) if (!method_context) { /* It might be a method of an array of an open generic type */ - if (method->klass->rank) + if (m_class_get_rank (method->klass)) context_used = mono_class_check_context_used (method->klass); } else { context_used = mono_generic_context_check_used (method_context); @@ -3259,13 +3263,13 @@ mini_get_basic_type_from_generic (MonoType *type) MonoType *constraint = type->data.generic_param->gshared_constraint; /* The gparam constraint encodes the type this gparam can represent */ if (!constraint) { - return &mono_defaults.object_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.object_class); } else { MonoClass *klass; - g_assert (constraint != &mono_defaults.int_class->parent->byval_arg); + g_assert (constraint != m_class_get_byval_arg (m_class_get_parent (mono_defaults.int_class))); klass = mono_class_from_mono_type (constraint); - return &klass->byval_arg; + return m_class_get_byval_arg (klass); } } else { return mini_native_type_replace_type (mono_type_get_basic_type_from_generic (type)); @@ -3284,20 +3288,20 @@ mini_type_get_underlying_type (MonoType *type) type = mini_native_type_replace_type (type); if (type->byref) - return &mono_defaults.int_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.int_class); if (!type->byref && (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR) && mini_is_gsharedvt_type (type)) return type; type = mini_get_basic_type_from_generic (mono_type_get_underlying_type (type)); switch (type->type) { case MONO_TYPE_BOOLEAN: - return &mono_defaults.byte_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.byte_class); case MONO_TYPE_CHAR: - return &mono_defaults.uint16_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.uint16_class); case MONO_TYPE_STRING: case MONO_TYPE_CLASS: case MONO_TYPE_ARRAY: case MONO_TYPE_SZARRAY: - return &mono_defaults.object_class->byval_arg; + return m_class_get_byval_arg (mono_defaults.object_class); default: return type; } @@ -3460,7 +3464,7 @@ mini_class_is_generic_sharable (MonoClass *klass) gboolean mini_is_gsharedvt_variable_klass (MonoClass *klass) { - return mini_is_gsharedvt_variable_type (&klass->byval_arg); + return mini_is_gsharedvt_variable_type (m_class_get_byval_arg (klass)); } gboolean @@ -3606,7 +3610,7 @@ get_shared_type (MonoType *t, MonoType *type) k = mono_class_inflate_generic_class_checked (gclass->container_class, &context, error); mono_error_assert_ok (error); /* FIXME don't swallow the error */ - return mini_get_shared_gparam (t, &k->byval_arg); + return mini_get_shared_gparam (t, m_class_get_byval_arg (k)); } else if (MONO_TYPE_ISSTRUCT (type)) { return type; } @@ -3631,7 +3635,7 @@ get_shared_type (MonoType *t, MonoType *type) t2.type = ttype; klass = mono_class_from_mono_type (&t2); - return mini_get_shared_gparam (t, &klass->byval_arg); + return mini_get_shared_gparam (t, m_class_get_byval_arg (klass)); } } @@ -3639,7 +3643,7 @@ static MonoType* get_gsharedvt_type (MonoType *t) { /* Use TypeHandle as the constraint type since its a valuetype */ - return mini_get_shared_gparam (t, &mono_defaults.typehandle_class->byval_arg); + return mini_get_shared_gparam (t, m_class_get_byval_arg (mono_defaults.typehandle_class)); } static MonoGenericInst* @@ -3762,7 +3766,7 @@ mini_get_rgctx_entry_slot (MonoJumpInfoRgctxEntry *entry) switch (entry->data->type) { case MONO_PATCH_INFO_CLASS: - slot = mono_method_lookup_or_register_info (entry->method, entry->in_mrgctx, &entry->data->data.klass->byval_arg, entry->info_type, mono_method_get_context (entry->method)); + slot = mono_method_lookup_or_register_info (entry->method, entry->in_mrgctx, m_class_get_byval_arg (entry->data->data.klass), entry->info_type, mono_method_get_context (entry->method)); break; case MONO_PATCH_INFO_METHOD: case MONO_PATCH_INFO_METHODCONST: @@ -3870,7 +3874,7 @@ mini_is_gsharedvt_type (MonoType *t) gboolean mini_is_gsharedvt_klass (MonoClass *klass) { - return mini_is_gsharedvt_type (&klass->byval_arg); + return mini_is_gsharedvt_type (m_class_get_byval_arg (klass)); } gboolean @@ -3903,7 +3907,7 @@ mini_is_gsharedvt_variable_type (MonoType *t) MonoGenericInst *inst; int i; - if (t->data.generic_class->container_class->byval_arg.type != MONO_TYPE_VALUETYPE || t->data.generic_class->container_class->enumtype) + if (m_class_get_byval_arg (t->data.generic_class->container_class)->type != MONO_TYPE_VALUETYPE || m_class_is_enumtype (t->data.generic_class->container_class)) return FALSE; inst = context->class_inst; @@ -3941,7 +3945,7 @@ is_variable_size (MonoType *t) return is_variable_size (param->gshared_constraint); return TRUE; } - if (t->type == MONO_TYPE_GENERICINST && t->data.generic_class->container_class->byval_arg.type == MONO_TYPE_VALUETYPE) { + if (t->type == MONO_TYPE_GENERICINST && m_class_get_byval_arg (t->data.generic_class->container_class)->type == MONO_TYPE_VALUETYPE) { MonoGenericClass *gclass = t->data.generic_class; MonoGenericContext *context = &gclass->context; MonoGenericInst *inst; diff --git a/mono/mini/mini-native-types.c b/mono/mini/mini-native-types.c index 3f0540ff5fe..e8053a363cc 100644 --- a/mono/mini/mini-native-types.c +++ b/mono/mini/mini-native-types.c @@ -325,7 +325,7 @@ MonoInst* mono_emit_native_types_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args) { if (mono_class_is_magic_int (cmethod->klass)) { - const char *class_name = cmethod->klass->name; + const char *class_name = m_class_get_name (cmethod->klass); if (!strcmp ("nint", class_name)) return emit_intrinsics (cfg, cmethod, fsig, args, &type_info [0]); else @@ -341,18 +341,19 @@ mono_emit_native_types_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMe static inline gboolean mono_class_is_magic_assembly (MonoClass *klass) { - if (!klass->image->assembly_name) + const char *aname = m_class_get_image (klass)->assembly_name; + if (!aname) return FALSE; - if (!strcmp ("Xamarin.iOS", klass->image->assembly_name)) + if (!strcmp ("Xamarin.iOS", aname)) return TRUE; - if (!strcmp ("Xamarin.Mac", klass->image->assembly_name)) + if (!strcmp ("Xamarin.Mac", aname)) return TRUE; - if (!strcmp ("Xamarin.WatchOS", klass->image->assembly_name)) + if (!strcmp ("Xamarin.WatchOS", aname)) return TRUE; /* regression test suite */ - if (!strcmp ("builtin-types", klass->image->assembly_name)) + if (!strcmp ("builtin-types", aname)) return TRUE; - if (!strcmp ("mini_tests", klass->image->assembly_name)) + if (!strcmp ("mini_tests", aname)) return TRUE; return FALSE; } @@ -375,15 +376,15 @@ mono_class_is_magic_int (MonoClass *klass) if (!mono_class_is_magic_assembly (klass)) return FALSE; - if (strcmp ("System", klass->name_space) != 0) + if (strcmp ("System", m_class_get_name_space (klass)) != 0) return FALSE; - if (strcmp ("nint", klass->name) == 0) { + if (strcmp ("nint", m_class_get_name (klass)) == 0) { magic_nint_class = klass; return TRUE; } - if (strcmp ("nuint", klass->name) == 0){ + if (strcmp ("nuint", m_class_get_name (klass)) == 0){ magic_nuint_class = klass; return TRUE; } @@ -404,19 +405,19 @@ mono_class_is_magic_float (MonoClass *klass) if (!mono_class_is_magic_assembly (klass)) return FALSE; - if (strcmp ("System", klass->name_space) != 0) + if (strcmp ("System", m_class_get_name_space (klass)) != 0) return FALSE; - if (strcmp ("nfloat", klass->name) == 0) { + if (strcmp ("nfloat", m_class_get_name (klass)) == 0) { magic_nfloat_class = klass; /* Assert that we are using the matching assembly */ MonoClassField *value_field = mono_class_get_field_from_name (klass, "v"); g_assert (value_field); MonoType *t = mono_field_get_type (value_field); - MonoType *native = mini_native_type_replace_type (&klass->byval_arg); + MonoType *native = mini_native_type_replace_type (m_class_get_byval_arg (klass)); if (t->type != native->type) - g_error ("Assembly used for native types '%s' doesn't match this runtime, %s is mapped to %s, expecting %s.\n", klass->image->name, klass->name, mono_type_full_name (t), mono_type_full_name (native)); + g_error ("Assembly used for native types '%s' doesn't match this runtime, %s is mapped to %s, expecting %s.\n", m_class_get_image (klass)->name, m_class_get_name (klass), mono_type_full_name (t), mono_type_full_name (native)); return TRUE; } return FALSE; @@ -448,12 +449,12 @@ mini_native_type_replace_type (MonoType *type) klass = type->data.klass; if (mono_class_is_magic_int (klass)) - return type->byref ? &mono_defaults.int_class->this_arg : &mono_defaults.int_class->byval_arg; + return type->byref ? m_class_get_this_arg (mono_defaults.int_class) : m_class_get_byval_arg (mono_defaults.int_class); if (mono_class_is_magic_float (klass)) #if SIZEOF_VOID_P == 8 - return type->byref ? &mono_defaults.double_class->this_arg : &mono_defaults.double_class->byval_arg; + return type->byref ? m_class_get_this_arg (mono_defaults.double_class) : m_class_get_byval_arg (mono_defaults.double_class); #else - return type->byref ? &mono_defaults.single_class->this_arg : &mono_defaults.single_class->byval_arg; + return type->byref ? m_class_get_this_arg (mono_defaults.single_class) : m_class_get_byval_arg (mono_defaults.single_class); #endif return type; } diff --git a/mono/mini/mini-profiler.c b/mono/mini/mini-profiler.c index c05660e7512..8d274c740f3 100644 --- a/mono/mini/mini-profiler.c +++ b/mono/mini/mini-profiler.c @@ -204,7 +204,7 @@ mini_profiler_context_get_this (MonoProfilerCallContext *ctx) return NULL; if (ctx->interp_frame) - return memdup_with_type (mini_get_interp_callbacks ()->frame_get_this (ctx->interp_frame), &ctx->method->klass->this_arg); + return memdup_with_type (mini_get_interp_callbacks ()->frame_get_this (ctx->interp_frame), m_class_get_this_arg (ctx->method->klass)); MonoDebugMethodJitInfo *info = mono_debug_find_method (ctx->method, mono_domain_get ()); diff --git a/mono/mini/mini-runtime.c b/mono/mini/mini-runtime.c index 7f950cefba0..22dab7313d6 100644 --- a/mono/mini/mini-runtime.c +++ b/mono/mini/mini-runtime.c @@ -1429,11 +1429,11 @@ mono_resolve_patch_target (MonoMethod *method, MonoDomain *domain, guint8 *code, break; case MONO_PATCH_INFO_IID: mono_class_init (patch_info->data.klass); - target = GUINT_TO_POINTER (patch_info->data.klass->interface_id); + target = GUINT_TO_POINTER (m_class_get_interface_id (patch_info->data.klass)); break; case MONO_PATCH_INFO_ADJUSTED_IID: mono_class_init (patch_info->data.klass); - target = GUINT_TO_POINTER ((guint32)(-((patch_info->data.klass->interface_id + 1) * SIZEOF_VOID_P))); + target = GUINT_TO_POINTER ((guint32)(-((m_class_get_interface_id (patch_info->data.klass) + 1) * SIZEOF_VOID_P))); break; case MONO_PATCH_INFO_VTABLE: target = mono_class_vtable_checked (domain, patch_info->data.klass, error); @@ -1826,7 +1826,7 @@ mini_get_class (MonoMethod *method, guint32 token, MonoGenericContext *context) mono_error_cleanup (error); /* FIXME don't swallow the error */ } } else { - klass = mono_class_get_and_inflate_typespec_checked (method->klass->image, token, context, error); + klass = mono_class_get_and_inflate_typespec_checked (m_class_get_image (method->klass), token, context, error); mono_error_cleanup (error); /* FIXME don't swallow the error */ } if (klass) @@ -2178,7 +2178,7 @@ lookup_start: * This is not a problem, since it will be initialized when the method is first * called by init_method (). */ - if (!mono_llvm_only && !mono_class_is_open_constructed_type (&method->klass->byval_arg)) { + if (!mono_llvm_only && !mono_class_is_open_constructed_type (m_class_get_byval_arg (method->klass))) { vtable = mono_class_vtable_checked (domain, method->klass, error); mono_error_assert_ok (error); if (!mono_runtime_class_init_full (vtable, error)) @@ -2206,7 +2206,7 @@ lookup_start: } if (!code) { - if (mono_class_is_open_constructed_type (&method->klass->byval_arg)) { + if (mono_class_is_open_constructed_type (m_class_get_byval_arg (method->klass))) { mono_error_set_invalid_operation (error, "Could not execute the method because the containing type is not fully instantiated."); return NULL; } @@ -2355,7 +2355,7 @@ mono_jit_free_method (MonoDomain *domain, MonoMethod *method) * Instead of freeing the code, change it to call an error routine * so people can fix their code. */ - char *type = mono_type_full_name (&method->klass->byval_arg); + char *type = mono_type_full_name (m_class_get_byval_arg (method->klass)); char *type_and_method = g_strdup_printf ("%s.%s", type, method->name); g_free (type); @@ -2750,7 +2750,7 @@ mono_jit_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObjec gpointer compiled_method; callee = method; - if (method->klass->rank && (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && + if (m_class_get_rank (method->klass) && (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && (method->iflags & METHOD_IMPL_ATTRIBUTE_NATIVE)) { /* * Array Get/Set/Address methods. The JIT implements them using inline code diff --git a/mono/mini/mini-trampolines.c b/mono/mini/mini-trampolines.c index ff997a144e4..6762c436dbd 100644 --- a/mono/mini/mini-trampolines.c +++ b/mono/mini/mini-trampolines.c @@ -183,7 +183,7 @@ mini_resolve_imt_method (MonoVTable *vt, gpointer *vtable_slot, MonoMethod *imt_ /* This has to be variance aware since imt_method can be from an interface that vt->klass doesn't directly implement */ interface_offset = mono_class_interface_offset_with_variance (vt->klass, imt_method->klass, &variance_used); if (interface_offset < 0) - g_error ("%s doesn't implement interface %s\n", mono_type_get_name_full (&vt->klass->byval_arg, MONO_TYPE_NAME_FORMAT_IL), mono_type_get_name_full (&imt_method->klass->byval_arg, MONO_TYPE_NAME_FORMAT_IL)); + g_error ("%s doesn't implement interface %s\n", mono_type_get_name_full (m_class_get_byval_arg (vt->klass), MONO_TYPE_NAME_FORMAT_IL), mono_type_get_name_full (m_class_get_byval_arg (imt_method->klass), MONO_TYPE_NAME_FORMAT_IL)); *variant_iface = NULL; if (imt_method->is_inflated && ((MonoMethodInflated*)imt_method)->context.method_inst) { @@ -219,7 +219,7 @@ mini_resolve_imt_method (MonoVTable *vt, gpointer *vtable_slot, MonoMethod *imt_ } else { /* Avoid loading metadata or creating a generic vtable if possible */ - if (lookup_aot && !vt->klass->valuetype) { + if (lookup_aot && !m_class_is_valuetype (vt->klass)) { aot_addr = (guint8 *)mono_aot_get_method_from_vt_slot (mono_domain_get (), vt, interface_offset + mono_method_get_vtable_slot (imt_method), error); return_val_if_nok (error, NULL); } else { @@ -600,7 +600,7 @@ common_call_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, MonoVTable * } /* We must handle magic interfaces on rank 1 arrays of ref types as if they were variant */ - if (!variant_iface && vt->klass->rank == 1 && !vt->klass->element_class->valuetype && imt_method->klass->is_array_special_interface) + if (!variant_iface && m_class_get_rank (vt->klass) == 1 && !m_class_is_valuetype (m_class_get_element_class (vt->klass)) && m_class_is_array_special_interface (imt_method->klass)) variant_iface = imt_method; /* This is the vcall slot which gets called through the IMT trampoline */ @@ -664,7 +664,7 @@ common_call_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, MonoVTable * klass = mrgctx->class_vtable->klass; method_inst = mrgctx->method_inst; - } else if ((m->flags & METHOD_ATTRIBUTE_STATIC) || m->klass->valuetype) { + } else if ((m->flags & METHOD_ATTRIBUTE_STATIC) || m_class_is_valuetype (m->klass)) { MonoVTable *vtable = mono_arch_find_static_call_vtable (regs, code); klass = vtable->klass; @@ -674,11 +674,11 @@ common_call_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, MonoVTable * vt = this_argument->vtable; vtable_slot = orig_vtable_slot; - g_assert (this_argument->vtable->klass->inited); + g_assert (m_class_is_inited (this_argument->vtable->klass)); if (!vtable_slot) { mono_class_setup_supertypes (this_argument->vtable->klass); - klass = this_argument->vtable->klass->supertypes [m->klass->idepth - 1]; + klass = m_class_get_supertypes (this_argument->vtable->klass) [m_class_get_idepth (m->klass) - 1]; } } @@ -691,7 +691,7 @@ common_call_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, MonoVTable * g_assert (displacement > 0); - actual_method = vt->klass->vtable [displacement]; + actual_method = m_class_get_vtable (vt->klass) [displacement]; } if (method_inst || m->wrapper_type) { @@ -737,10 +737,10 @@ common_call_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, MonoVTable * return NULL; if (generic_virtual || variant_iface) { - if (vt->klass->valuetype) /*FIXME is this required variant iface?*/ + if (m_class_is_valuetype (vt->klass)) /*FIXME is this required variant iface?*/ need_unbox_tramp = TRUE; } else if (orig_vtable_slot) { - if (m->klass->valuetype) + if (m_class_is_valuetype (m->klass)) need_unbox_tramp = TRUE; } @@ -916,7 +916,7 @@ mono_vcall_trampoline (mgreg_t *regs, guint8 *code, int slot, guint8 *tramp) /* Avoid loading metadata or creating a generic vtable if possible */ addr = mono_aot_get_method_from_vt_slot (mono_domain_get (), vt, slot, error); goto_if_nok (error, leave); - if (addr && !vt->klass->valuetype) { + if (addr && !m_class_is_valuetype (vt->klass)) { if (mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot)) *vtable_slot = addr; @@ -1179,7 +1179,7 @@ mono_delegate_trampoline (mgreg_t *regs, guint8 *code, gpointer *arg, guint8* tr } } - if (sig->hasthis && method->klass->valuetype) { + if (sig->hasthis && m_class_is_valuetype (method->klass)) { gboolean need_unbox = TRUE; if (tramp_info->invoke_sig->param_count > sig->param_count && tramp_info->invoke_sig->params [0]->byref) diff --git a/mono/mini/mini.c b/mono/mini/mini.c index d608fc0dd9f..d539021d7c8 100644 --- a/mono/mini/mini.c +++ b/mono/mini/mini.c @@ -358,7 +358,7 @@ handle_enum: case MONO_TYPE_R8: return OP_STORER8_MEMBASE_REG; case MONO_TYPE_VALUETYPE: - if (type->data.klass->enumtype) { + if (m_class_is_enumtype (type->data.klass)) { type = mono_class_enum_basetype (type->data.klass); goto handle_enum; } @@ -370,7 +370,7 @@ handle_enum: case MONO_TYPE_GENERICINST: if (MONO_CLASS_IS_SIMD (cfg, mono_class_from_mono_type (type))) return OP_STOREX_MEMBASE; - type = &type->data.generic_class->container_class->byval_arg; + type = m_class_get_byval_arg (type->data.generic_class->container_class); goto handle_enum; case MONO_TYPE_VAR: case MONO_TYPE_MVAR: @@ -669,7 +669,7 @@ mono_compile_create_var_for_vreg (MonoCompile *cfg, MonoType *type, int opcode, if (type->byref) { mono_mark_vreg_as_mp (cfg, vreg); } else { - if ((MONO_TYPE_ISSTRUCT (type) && inst->klass->has_references) || mini_type_is_reference (type)) { + if ((MONO_TYPE_ISSTRUCT (type) && m_class_has_references (inst->klass)) || mini_type_is_reference (type)) { inst->flags |= MONO_INST_GC_TRACK; mono_mark_vreg_as_ref (cfg, vreg); } @@ -724,7 +724,7 @@ mono_compile_create_var_for_vreg (MonoCompile *cfg, MonoType *type, int opcode, tree->flags = MONO_INST_VOLATILE; tree->inst_c0 = num; tree->type = STACK_I4; - tree->inst_vtype = &mono_defaults.int32_class->byval_arg; + tree->inst_vtype = m_class_get_byval_arg (mono_defaults.int32_class); tree->klass = mono_class_from_mono_type (tree->inst_vtype); set_vreg_to_inst (cfg, MONO_LVREG_LS (inst->dreg), tree); @@ -736,7 +736,7 @@ mono_compile_create_var_for_vreg (MonoCompile *cfg, MonoType *type, int opcode, tree->flags = MONO_INST_VOLATILE; tree->inst_c0 = num; tree->type = STACK_I4; - tree->inst_vtype = &mono_defaults.int32_class->byval_arg; + tree->inst_vtype = m_class_get_byval_arg (mono_defaults.int32_class); tree->klass = mono_class_from_mono_type (tree->inst_vtype); set_vreg_to_inst (cfg, MONO_LVREG_MS (inst->dreg), tree); @@ -815,28 +815,28 @@ static MonoType* type_from_stack_type (MonoInst *ins) { switch (ins->type) { - case STACK_I4: return &mono_defaults.int32_class->byval_arg; - case STACK_I8: return &mono_defaults.int64_class->byval_arg; - case STACK_PTR: return &mono_defaults.int_class->byval_arg; - case STACK_R8: return &mono_defaults.double_class->byval_arg; + case STACK_I4: return m_class_get_byval_arg (mono_defaults.int32_class); + case STACK_I8: return m_class_get_byval_arg (mono_defaults.int64_class); + case STACK_PTR: return m_class_get_byval_arg (mono_defaults.int_class); + case STACK_R8: return m_class_get_byval_arg (mono_defaults.double_class); case STACK_MP: /* * this if used to be commented without any specific reason, but * it breaks #80235 when commented */ if (ins->klass) - return &ins->klass->this_arg; + return m_class_get_this_arg (ins->klass); else - return &mono_defaults.object_class->this_arg; + return m_class_get_this_arg (mono_defaults.object_class); case STACK_OBJ: /* ins->klass may not be set for ldnull. * Also, if we have a boxed valuetype, we want an object lass, * not the valuetype class */ - if (ins->klass && !ins->klass->valuetype) - return &ins->klass->byval_arg; - return &mono_defaults.object_class->byval_arg; - case STACK_VTYPE: return &ins->klass->byval_arg; + if (ins->klass && !m_class_is_valuetype (ins->klass)) + return m_class_get_byval_arg (ins->klass); + return m_class_get_byval_arg (mono_defaults.object_class); + case STACK_VTYPE: return m_class_get_byval_arg (ins->klass); default: g_error ("stack type %d to montype not handled\n", ins->type); } @@ -959,11 +959,12 @@ mono_get_array_new_va_signature (int arity) res->call_convention = MONO_CALL_C; #endif - res->params [0] = &mono_defaults.int_class->byval_arg; + MonoType *int_type = m_class_get_byval_arg (mono_defaults.int_class); + res->params [0] = int_type; for (i = 0; i < arity; i++) - res->params [i + 1] = &mono_defaults.int_class->byval_arg; + res->params [i + 1] = int_type; - res->ret = &mono_defaults.object_class->byval_arg; + res->ret = m_class_get_byval_arg (mono_defaults.object_class); g_hash_table_insert (sighash, GINT_TO_POINTER (arity), res); mono_jit_unlock (); @@ -997,7 +998,7 @@ mono_get_array_new_va_icall (int rank) gboolean mini_assembly_can_skip_verification (MonoDomain *domain, MonoMethod *method) { - MonoAssembly *assembly = method->klass->image->assembly; + MonoAssembly *assembly = m_class_get_image (method->klass)->assembly; if (method->wrapper_type != MONO_WRAPPER_NONE && method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD) return FALSE; if (assembly->in_gac || assembly->image == mono_defaults.corlib) @@ -1077,7 +1078,7 @@ gboolean mono_compile_is_broken (MonoCompile *cfg, MonoMethod *method, gboolean fail_compile) { MonoMethod *method_definition = method; - gboolean dont_verify = method->klass->image->assembly->corlib_internal; + gboolean dont_verify = m_class_get_image (method->klass)->assembly->corlib_internal; while (method_definition->is_inflated) { MonoMethodInflated *imethod = (MonoMethodInflated *) method_definition; @@ -2038,7 +2039,7 @@ mono_compile_create_vars (MonoCompile *cfg) cfg->args = (MonoInst **)mono_mempool_alloc0 (cfg->mempool, (sig->param_count + sig->hasthis) * sizeof (MonoInst*)); if (sig->hasthis) { - cfg->args [0] = mono_compile_create_var (cfg, &cfg->method->klass->this_arg, OP_ARG); + cfg->args [0] = mono_compile_create_var (cfg, m_class_get_this_arg (cfg->method->klass), OP_ARG); cfg->this_arg = cfg->args [0]; } @@ -2088,7 +2089,7 @@ mono_compile_create_vars (MonoCompile *cfg) #endif if (cfg->method->save_lmf && cfg->create_lmf_var) { - MonoInst *lmf_var = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL); + MonoInst *lmf_var = mono_compile_create_var (cfg, m_class_get_byval_arg (mono_defaults.int_class), OP_LOCAL); lmf_var->flags |= MONO_INST_VOLATILE; lmf_var->flags |= MONO_INST_LMF; cfg->lmf_var = lmf_var; @@ -2529,7 +2530,7 @@ create_jit_info (MonoCompile *cfg, MonoMethod *method_to_compile) if ((method_to_compile->flags & METHOD_ATTRIBUTE_STATIC) || mini_method_get_context (method_to_compile)->method_inst || - method_to_compile->klass->valuetype) { + m_class_is_valuetype (method_to_compile->klass)) { g_assert (cfg->rgctx_var); } @@ -2537,7 +2538,7 @@ create_jit_info (MonoCompile *cfg, MonoMethod *method_to_compile) if ((method_to_compile->flags & METHOD_ATTRIBUTE_STATIC) || mini_method_get_context (method_to_compile)->method_inst || - method_to_compile->klass->valuetype) { + m_class_is_valuetype (method_to_compile->klass)) { inst = cfg->rgctx_var; if (!COMPILE_LLVM (cfg)) g_assert (inst->opcode == OP_REGOFFSET); @@ -3892,14 +3893,14 @@ mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, JitFl if ((gboolean)mono_atomic_load_i32 ((gint32*)&mono_jit_stats.enabled)) { if (code_size_ratio > mono_atomic_load_i32 (&mono_jit_stats.biggest_method_size)) { mono_atomic_store_i32 (&mono_jit_stats.biggest_method_size, code_size_ratio); - char *biggest_method = g_strdup_printf ("%s::%s)", method->klass->name, method->name); + char *biggest_method = g_strdup_printf ("%s::%s)", m_class_get_name (method->klass), method->name); biggest_method = mono_atomic_xchg_ptr ((gpointer*)&mono_jit_stats.biggest_method, biggest_method); g_free (biggest_method); } code_size_ratio = (code_size_ratio * 100) / header->code_size; if (code_size_ratio > mono_atomic_load_i32 (&mono_jit_stats.max_code_size_ratio)) { mono_atomic_store_i32 (&mono_jit_stats.max_code_size_ratio, code_size_ratio); - char *max_ratio_method = g_strdup_printf ("%s::%s)", method->klass->name, method->name); + char *max_ratio_method = g_strdup_printf ("%s::%s)", m_class_get_name (method->klass), method->name); max_ratio_method = mono_atomic_xchg_ptr ((gpointer*)&mono_jit_stats.max_ratio_method, max_ratio_method); g_free (max_ratio_method); } @@ -4060,9 +4061,9 @@ mono_jit_compile_method_inner (MonoMethod *method, MonoDomain *target_domain, in piinfo->addr = mono_lookup_internal_call (method); else if (method->iflags & METHOD_IMPL_ATTRIBUTE_NATIVE) #ifdef HOST_WIN32 - g_warning ("Method '%s' in assembly '%s' contains native code that cannot be executed by Mono in modules loaded from byte arrays. The assembly was probably created using C++/CLI.\n", mono_method_full_name (method, TRUE), method->klass->image->name); + g_warning ("Method '%s' in assembly '%s' contains native code that cannot be executed by Mono in modules loaded from byte arrays. The assembly was probably created using C++/CLI.\n", mono_method_full_name (method, TRUE), m_class_get_image (method->klass)->name); #else - g_warning ("Method '%s' in assembly '%s' contains native code that cannot be executed by Mono on this platform. The assembly was probably created using C++/CLI.\n", mono_method_full_name (method, TRUE), method->klass->image->name); + g_warning ("Method '%s' in assembly '%s' contains native code that cannot be executed by Mono on this platform. The assembly was probably created using C++/CLI.\n", mono_method_full_name (method, TRUE), m_class_get_image (method->klass)->name); #endif else mono_lookup_pinvoke_call (method, NULL, NULL); @@ -4082,7 +4083,7 @@ mono_jit_compile_method_inner (MonoMethod *method, MonoDomain *target_domain, in char *full_name, *msg; MonoMethod *nm; - if (method->klass->parent == mono_defaults.multicastdelegate_class) { + if (m_class_get_parent (method->klass) == mono_defaults.multicastdelegate_class) { if (*name == '.' && (strcmp (name, ".ctor") == 0)) { MonoJitICallInfo *mi = mono_find_jit_icall_by_name ("ves_icall_mono_delegate_ctor"); g_assert (mi); @@ -4402,7 +4403,7 @@ mono_add_patch_info (MonoCompile *cfg, int ip, MonoJumpInfoType type, gconstpoin gboolean mini_class_is_system_array (MonoClass *klass) { - if (klass->parent == mono_defaults.array_class) + if (m_class_get_parent (klass) == mono_defaults.array_class) return TRUE; else return FALSE; diff --git a/mono/mini/mini.h b/mono/mini/mini.h index dcea07975ac..6810f97ddfe 100644 --- a/mono/mini/mini.h +++ b/mono/mini/mini.h @@ -291,7 +291,7 @@ enum { #define MONO_IS_REAL_MOVE(ins) (((ins)->opcode == OP_MOVE) || ((ins)->opcode == OP_FMOVE) || ((ins)->opcode == OP_XMOVE) || ((ins)->opcode == OP_RMOVE)) #define MONO_IS_ZERO(ins) (((ins)->opcode == OP_VZERO) || ((ins)->opcode == OP_XZERO)) -#define MONO_CLASS_IS_SIMD(cfg, klass) (((cfg)->opt & MONO_OPT_SIMD) && (klass)->simd_type) +#define MONO_CLASS_IS_SIMD(cfg, klass) (((cfg)->opt & MONO_OPT_SIMD) && m_class_is_simd_type (klass)) #else diff --git a/mono/mini/simd-intrinsics.c b/mono/mini/simd-intrinsics.c index 01530aa55a3..dfaf3f9cbf9 100644 --- a/mono/mini/simd-intrinsics.c +++ b/mono/mini/simd-intrinsics.c @@ -671,7 +671,7 @@ mono_simd_simplify_indirection (MonoCompile *cfg) for (i = 0; i < cfg->num_varinfo; i++) { MonoInst *var = cfg->varinfo [i]; - if (var->klass->simd_type) { + if (m_class_is_simd_type (var->klass)) { var->flags &= ~MONO_INST_INDIRECT; max_vreg = MAX (var->dreg, max_vreg); } @@ -683,7 +683,7 @@ mono_simd_simplify_indirection (MonoCompile *cfg) for (ins = bb->code; ins; ins = ins->next) { if (ins->opcode == OP_LDADDR) { MonoInst *var = (MonoInst*)ins->inst_p0; - if (var->klass->simd_type) { + if (m_class_is_simd_type (var->klass)) { var->flags |= MONO_INST_INDIRECT; } } @@ -696,7 +696,7 @@ mono_simd_simplify_indirection (MonoCompile *cfg) for (i = 0; i < cfg->num_varinfo; i++) { MonoInst *var = cfg->varinfo [i]; - if (var->klass->simd_type && !(var->flags & (MONO_INST_INDIRECT|MONO_INST_VOLATILE))) { + if (m_class_is_simd_type (var->klass) && !(var->flags & (MONO_INST_INDIRECT|MONO_INST_VOLATILE))) { vreg_flags [var->dreg] = VREG_USED; DEBUG (printf ("[simd-simplify] processing var %d with vreg %d\n", i, var->dreg)); } @@ -728,7 +728,7 @@ mono_simd_simplify_indirection (MonoCompile *cfg) if (IS_DEBUG_ON (cfg)) { for (i = 0; i < cfg->num_varinfo; i++) { MonoInst *var = cfg->varinfo [i]; - if (var->klass->simd_type) { + if (m_class_is_simd_type (var->klass)) { if ((vreg_flags [var->dreg] & VREG_HAS_XZERO_BB0)) DEBUG (printf ("[simd-simplify] R%d has xzero only\n", var->dreg)); if ((vreg_flags [var->dreg] & VREG_HAS_OTHER_OP_BB0)) @@ -770,7 +770,7 @@ mono_simd_simplify_indirection (MonoCompile *cfg) for (i = 0; i < cfg->num_varinfo; i++) { MonoInst *var = cfg->varinfo [i]; - if (!var->klass->simd_type) + if (!m_class_is_simd_type (var->klass)) continue; if ((vreg_flags [var->dreg] & VREG_SINGLE_BB_USE)) DEBUG (printf ("[simd-simplify] R%d has single bb use\n", var->dreg)); @@ -884,7 +884,7 @@ static MonoInst* get_double_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; @@ -893,7 +893,7 @@ static MonoInst* get_simd_ctor_spill_area (MonoCompile *cfg, MonoClass *avector_klass) { if (!cfg->simd_ctor_var) { - cfg->simd_ctor_var = mono_compile_create_var (cfg, &avector_klass->byval_arg, OP_LOCAL); + cfg->simd_ctor_var = mono_compile_create_var (cfg, m_class_get_byval_arg (avector_klass), OP_LOCAL); cfg->simd_ctor_var->flags |= MONO_INST_VOLATILE; /*FIXME, use the don't regalloc flag*/ } return cfg->simd_ctor_var; @@ -1157,7 +1157,7 @@ get_simd_vreg_or_expanded_scalar (MonoCompile *cfg, MonoClass *klass, MonoType * MonoInst *ins; int expand_op; - if (mono_class_from_mono_type (param_type)->simd_type) + if (m_class_is_simd_type (mono_class_from_mono_type (param_type))) return get_simd_vreg (cfg, NULL, src); expand_op = mono_type_to_expand_op (param_type); @@ -1818,12 +1818,12 @@ emit_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsi { const SimdIntrinsic *result = (const SimdIntrinsic *)mono_binary_search (cmethod->name, intrinsics, size, sizeof (SimdIntrinsic), &simd_intrinsic_compare_by_name); if (!result) { - DEBUG (printf ("function doesn't have a simd intrinsic %s::%s/%d\n", cmethod->klass->name, cmethod->name, fsig->param_count)); + DEBUG (printf ("function doesn't have a simd intrinsic %s::%s/%d\n", m_class_get_name (cmethod->klass), cmethod->name, fsig->param_count)); return NULL; } if (IS_DEBUG_ON (cfg)) { int i, max; - printf ("found call to intrinsic %s::%s/%d -> %s\n", cmethod->klass->name, cmethod->name, fsig->param_count, method_name (result->name)); + printf ("found call to intrinsic %s::%s/%d -> %s\n", m_class_get_name (cmethod->klass), cmethod->name, fsig->param_count, method_name (result->name)); max = fsig->param_count + fsig->hasthis; for (i = 0; i < max; ++i) { printf ("param %d: ", i); @@ -1833,7 +1833,7 @@ emit_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsi if (result->simd_version_flags && !(result->simd_version_flags & simd_supported_versions)) { if (IS_DEBUG_ON (cfg)) { int x; - printf ("function %s::%s/%d requires one of unsuported SIMD instruction set(s): ", cmethod->klass->name, cmethod->name, fsig->param_count); + printf ("function %s::%s/%d requires one of unsuported SIMD instruction set(s): ", m_class_get_name (cmethod->klass), cmethod->name, fsig->param_count); for (x = 1; x <= SIMD_VERSION_INDEX_END; x++) if (result->simd_version_flags & (1 << x)) printf ("%s ", simd_version_name (1 << x)); @@ -1985,17 +1985,17 @@ mono_emit_simd_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign { const char *class_name; - if (is_sys_numerics_assembly (cmethod->klass->image->assembly)) + if (is_sys_numerics_assembly (m_class_get_image (cmethod->klass)->assembly)) return emit_sys_numerics_intrinsics (cfg, cmethod, fsig, args); - if (is_sys_numerics_vectors_assembly (cmethod->klass->image->assembly)) + if (is_sys_numerics_vectors_assembly (m_class_get_image (cmethod->klass)->assembly)) return emit_sys_numerics_vectors_intrinsics (cfg, cmethod, fsig, args); - if (strcmp ("Mono.Simd", cmethod->klass->image->assembly->aname.name) || - strcmp ("Mono.Simd", cmethod->klass->name_space)) + if (strcmp ("Mono.Simd", m_class_get_image (cmethod->klass)->assembly->aname.name) || + strcmp ("Mono.Simd", m_class_get_name_space (cmethod->klass))) return NULL; - class_name = cmethod->klass->name; + class_name = m_class_get_name (cmethod->klass); if (!strcmp ("SimdRuntime", class_name)) return emit_simd_runtime_intrinsics (cfg, cmethod, fsig, args); @@ -2005,8 +2005,8 @@ mono_emit_simd_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign if (!strcmp ("VectorOperations", class_name)) { if (!(cmethod->flags & METHOD_ATTRIBUTE_STATIC)) return NULL; - class_name = mono_class_from_mono_type (mono_method_signature (cmethod)->params [0])->name; - } else if (!cmethod->klass->simd_type) + class_name = m_class_get_name (mono_class_from_mono_type (mono_method_signature (cmethod)->params [0])); + } else if (!m_class_is_simd_type (cmethod->klass)) return NULL; cfg->uses_simd_intrinsics = 1; @@ -2046,7 +2046,7 @@ assert_handled (MonoCompile *cfg, MonoMethod *method) if (cattr) { gboolean has_attr = FALSE; for (int i = 0; i < cattr->num_attrs; ++i) - if (cattr->attrs [i].ctor && (!strcmp (cattr->attrs [i].ctor->klass->name, "JitIntrinsicAttribute"))) + if (cattr->attrs [i].ctor && (!strcmp (m_class_get_name (cattr->attrs [i].ctor->klass), "JitIntrinsicAttribute"))) has_attr = TRUE; if (has_attr) { printf ("SIMD intrinsic unhandled: %s\n", mono_method_get_name_full (method, TRUE, TRUE, MONO_TYPE_NAME_FORMAT_IL)); @@ -2079,9 +2079,9 @@ emit_vector_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignatu { const SimdIntrinsic *intrins; MonoMethodSignature *sig = mono_method_signature (cmethod); - MonoType *type = &cmethod->klass->byval_arg; + MonoType *type = m_class_get_byval_arg (cmethod->klass); - if (!cmethod->klass->simd_type) + if (!m_class_is_simd_type (cmethod->klass)) return NULL; /* @@ -2220,7 +2220,7 @@ emit_vector_t_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSigna return NULL; } - type = &cmethod->klass->byval_arg; + type = m_class_get_byval_arg (cmethod->klass); etype = mono_class_get_context (cmethod->klass)->class_inst->type_argv [0]; size = mono_class_value_size (mono_class_from_mono_type (etype), NULL); g_assert (size); @@ -2456,8 +2456,8 @@ emit_vector_t_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSigna static MonoInst* emit_sys_numerics_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args) { - const char *nspace = cmethod->klass->name_space; - const char *class_name = cmethod->klass->name; + const char *nspace = m_class_get_name_space (cmethod->klass); + const char *class_name = m_class_get_name (cmethod->klass); if (!strcmp ("Vector2", class_name) || !strcmp ("Vector4", class_name) || !strcmp ("Vector3", class_name)) return emit_vector_intrinsics (cfg, cmethod, fsig, args); @@ -2473,8 +2473,8 @@ emit_sys_numerics_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodS static MonoInst* emit_sys_numerics_vectors_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args) { - const char *nspace = cmethod->klass->name_space; - const char *class_name = cmethod->klass->name; + const char *nspace = m_class_get_name_space (cmethod->klass); + const char *class_name = m_class_get_name (cmethod->klass); if (!strcmp (class_name, "Vector`1")) return emit_vector_t_intrinsics (cfg, cmethod, fsig, args); @@ -2490,12 +2490,13 @@ emit_sys_numerics_vectors_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, Mon MonoInst* mono_emit_simd_field_load (MonoCompile *cfg, MonoClassField *field, MonoInst *addr) { - if (is_sys_numerics_assembly (field->parent->image->assembly)) { + if (is_sys_numerics_assembly (m_class_get_image (field->parent)->assembly)) { int index = -1; - if (!strcmp (field->parent->name, "Vector2") || - !strcmp (field->parent->name, "Vector3") || - !strcmp (field->parent->name, "Vector4")) { + const char *parent_name = m_class_get_name (field->parent); + if (!strcmp (parent_name, "Vector2") || + !strcmp (parent_name, "Vector3") || + !strcmp (parent_name, "Vector4")) { if (!strcmp (field->name, "X")) index = 0; else if (!strcmp (field->name, "Y")) diff --git a/mono/mini/ssa.c b/mono/mini/ssa.c index 187ac213f38..5a761ba54b6 100644 --- a/mono/mini/ssa.c +++ b/mono/mini/ssa.c @@ -509,7 +509,7 @@ mono_ssa_remove_gsharedvt (MonoCompile *cfg) printf ("\nREMOVE SSA %d:\n", bb->block_num); for (ins = bb->code; ins; ins = ins->next) { - if (!(MONO_IS_PHI (ins) && ins->opcode == OP_VPHI && mini_is_gsharedvt_variable_type (&ins->klass->byval_arg))) + if (!(MONO_IS_PHI (ins) && ins->opcode == OP_VPHI && mini_is_gsharedvt_variable_type (m_class_get_byval_arg (ins->klass)))) continue; g_assert (ins->inst_phi_args [0] == bb->in_count); diff --git a/mono/mini/trace.c b/mono/mini/trace.c index fb6ad1ccf58..017a643cb77 100644 --- a/mono/mini/trace.c +++ b/mono/mini/trace.c @@ -174,7 +174,7 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) if (mono_method_signature (method)->hasthis) { gpointer *this_obj = (gpointer *)(ebp + arg_info [0].offset); - if (method->klass->valuetype) { + if (m_class_is_valuetype (method->klass)) { printf ("value:%p, ", *arg_in_stack_slot(this_obj, gpointer *)); } else { o = *arg_in_stack_slot(this_obj, MonoObject *); @@ -189,7 +189,7 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) printf ("this:[STRING:%p:%s], ", o, as); g_free (as); } else { - printf ("this:%p[%s.%s %s], ", o, klass->name_space, klass->name, o->vtable->domain->friendly_name); + printf ("this:%p[%s.%s %s], ", o, m_class_get_name_space (klass), m_class_get_name (klass), o->vtable->domain->friendly_name); } } else printf ("this:NULL, "); @@ -254,7 +254,7 @@ mono_trace_enter_method (MonoMethod *method, char *ebp) } else if (klass == mono_defaults.runtimetype_class) { printf ("[TYPE:%s], ", mono_type_full_name (((MonoReflectionType*)o)->type)); } else - printf ("[%s.%s:%p], ", klass->name_space, klass->name, o); + printf ("[%s.%s:%p], ", m_class_get_name_space (klass), m_class_get_name (klass), o); } else { printf ("%p, ", *arg_in_stack_slot(cpos, gpointer)); } @@ -381,7 +381,7 @@ mono_trace_leave_method (MonoMethod *method, ...) } else if (o->vtable->klass == mono_defaults.int64_class) { printf ("[INT64:%p:%lld]", o, (long long)*((gint64 *)((char *)o + sizeof (MonoObject)))); } else - printf ("[%s.%s:%p]", o->vtable->klass->name_space, o->vtable->klass->name, o); + printf ("[%s.%s:%p]", m_class_get_name_space (mono_object_class (o)), m_class_get_name (mono_object_class (o)), o); } else printf ("[OBJECT:%p]", o); diff --git a/mono/mini/type-checking.c b/mono/mini/type-checking.c index 84982b9dcc7..2576aa64f77 100644 --- a/mono/mini/type-checking.c +++ b/mono/mini/type-checking.c @@ -10,9 +10,10 @@ #include "mini.h" #include "ir-emit.h" #include +#include -#define is_complex_isinst(klass) (mono_class_is_interface (klass) || klass->rank || mono_class_is_nullable (klass) || mono_class_is_marshalbyref (klass) || mono_class_is_sealed (klass) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR) +#define is_complex_isinst(klass) (mono_class_is_interface (klass) || m_class_get_rank (klass) || mono_class_is_nullable (klass) || mono_class_is_marshalbyref (klass) || mono_class_is_sealed (klass) || m_class_get_byval_arg (klass)->type == MONO_TYPE_VAR || m_class_get_byval_arg (klass)->type == MONO_TYPE_MVAR) static int get_castclass_cache_idx (MonoCompile *cfg) @@ -108,13 +109,13 @@ mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, mono_class_setup_supertypes (klass); - if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) { - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth)); - MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth); + if (m_class_get_idepth (klass) > MONO_DEFAULT_SUPERTABLE_SIZE) { + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, m_class_offsetof_idepth ()); + MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, m_class_get_idepth (klass)); MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBLT_UN, false_target); } - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes)); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P)); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, m_class_offsetof_supertypes ()); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((m_class_get_idepth (klass) - 1) * SIZEOF_VOID_P)); if (klass_ins) { MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, stype, klass_ins->dreg); } else if (cfg->compile_aot) { @@ -162,8 +163,8 @@ mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_r MONO_EMIT_NEW_BIALU (cfg, OP_ISHL, iid_bit_reg, iid_one_bit_reg, masked_iid_reg); MONO_EMIT_NEW_BIALU (cfg, OP_IAND, intf_bit_reg, ibitmap_byte_reg, iid_bit_reg); } else { - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, klass->interface_id >> 3); - MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (klass->interface_id & 7)); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, ibitmap_byte_reg, ibitmap_reg, m_class_get_interface_id (klass) >> 3); + MONO_EMIT_NEW_BIALU_IMM (cfg, OP_AND_IMM, intf_bit_reg, ibitmap_byte_reg, 1 << (m_class_get_interface_id (klass) & 7)); } #endif } @@ -175,7 +176,7 @@ mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_r static void mini_emit_load_intf_bit_reg_class (MonoCompile *cfg, int intf_bit_reg, int klass_reg, MonoClass *klass) { - mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, interface_bitmap), klass); + mini_emit_interface_bitmap_check (cfg, intf_bit_reg, klass_reg, m_class_offsetof_interface_bitmap (), klass); } /* @@ -202,7 +203,7 @@ mini_emit_max_iid_check (MonoCompile *cfg, int max_iid_reg, MonoClass *klass, MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, max_iid_reg, iid_reg); } else - MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, max_iid_reg, klass->interface_id); + MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, max_iid_reg, m_class_get_interface_id (klass)); if (false_target) MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBLT_UN, false_target); else @@ -227,7 +228,7 @@ mini_emit_max_iid_check_class (MonoCompile *cfg, int klass_reg, MonoClass *klass { int max_iid_reg = alloc_preg (cfg); - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU4_MEMBASE, max_iid_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, max_interface_id)); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU4_MEMBASE, max_iid_reg, klass_reg, m_class_offsetof_max_interface_id ()); mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target); } @@ -289,34 +290,34 @@ mini_emit_castclass (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *kl static void mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClass *klass, MonoInst *klass_inst, MonoBasicBlock *object_is_null) { - if (klass->rank) { + if (m_class_get_rank (klass)) { int rank_reg = alloc_preg (cfg); int eclass_reg = alloc_preg (cfg); g_assert (!klass_inst); - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, rank)); - MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, klass->rank); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, m_class_offsetof_rank ()); + MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, m_class_get_rank (klass)); MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException"); // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass)); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class)); - if (klass->cast_class == mono_defaults.object_class) { + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, m_class_offsetof_cast_class ()); + if (m_class_get_cast_class (klass) == mono_defaults.object_class) { int parent_reg = alloc_preg (cfg); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent)); - mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, object_is_null); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, m_class_offsetof_parent ()); + mini_emit_class_check_branch (cfg, parent_reg, m_class_get_parent (mono_defaults.enum_class), OP_PBNE_UN, object_is_null); mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class); - } else if (klass->cast_class == mono_defaults.enum_class->parent) { - mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, object_is_null); + } else if (m_class_get_cast_class (klass) == m_class_get_parent (mono_defaults.enum_class)) { + mini_emit_class_check_branch (cfg, eclass_reg, m_class_get_parent (mono_defaults.enum_class), OP_PBEQ, object_is_null); mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class); - } else if (klass->cast_class == mono_defaults.enum_class) { + } else if (m_class_get_cast_class (klass) == mono_defaults.enum_class) { mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class); - } else if (mono_class_is_interface (klass->cast_class)) { - mini_emit_iface_class_cast (cfg, eclass_reg, klass->cast_class, NULL, NULL); + } else if (mono_class_is_interface (m_class_get_cast_class (klass))) { + mini_emit_iface_class_cast (cfg, eclass_reg, m_class_get_cast_class (klass), NULL, NULL); } else { // Pass -1 as obj_reg to skip the check below for arrays of arrays - mini_emit_castclass (cfg, -1, eclass_reg, klass->cast_class, object_is_null); + mini_emit_castclass (cfg, -1, eclass_reg, m_class_get_cast_class (klass), object_is_null); } - if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY) && (obj_reg != -1)) { + if ((m_class_get_rank (klass) == 1) && (m_class_get_byval_arg (klass)->type == MONO_TYPE_SZARRAY) && (obj_reg != -1)) { /* Check that the object is a vector too */ int bounds_reg = alloc_preg (cfg); MONO_EMIT_NEW_LOAD_MEMBASE (cfg, bounds_reg, obj_reg, MONO_STRUCT_OFFSET (MonoArray, bounds)); @@ -330,13 +331,13 @@ mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClas mono_class_setup_supertypes (klass); - if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) { - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, idepth)); - MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth); + if (m_class_get_idepth (klass) > MONO_DEFAULT_SUPERTABLE_SIZE) { + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, m_class_offsetof_idepth ()); + MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, m_class_get_idepth (klass)); MONO_EMIT_NEW_COND_EXC (cfg, LT_UN, "InvalidCastException"); } - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, supertypes)); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P)); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, m_class_offsetof_supertypes ()); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((m_class_get_idepth (klass) - 1) * SIZEOF_VOID_P)); mini_emit_class_check_inst (cfg, stype, klass, klass_inst); } } @@ -353,7 +354,7 @@ emit_special_array_iface_check (MonoCompile *cfg, MonoInst *src, MonoClass* klas MonoBasicBlock *not_an_array; int rank_reg; - if (!klass->is_array_special_interface) + if (!m_class_is_array_special_interface (klass)) return; rank_reg = alloc_ireg (cfg); @@ -494,7 +495,7 @@ handle_castclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context MONO_EMIT_NEW_LOAD_MEMBASE (cfg, vtable_reg, obj_reg, MONO_STRUCT_OFFSET (MonoObject, vtable)); - if (!klass->rank && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && mono_class_is_sealed (klass)) { + if (!m_class_get_rank (klass) && !cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && mono_class_is_sealed (klass)) { /* the remoting code is broken, access the class for now */ if (0) { /*FIXME what exactly is broken? This change refers to r39380 from 2005 and mention some remoting fixes were due.*/ MonoVTable *vt = mono_class_vtable_checked (cfg->domain, klass, &cfg->error); @@ -563,7 +564,7 @@ handle_isinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_us mini_emit_iface_cast (cfg, vtable_reg, klass, interface_fail_bb, is_null_bb); MONO_START_BB (cfg, interface_fail_bb); - if (klass->is_array_special_interface) { + if (m_class_is_array_special_interface (klass)) { MonoBasicBlock *not_an_array; MonoInst *move; int rank_reg = alloc_ireg (cfg); @@ -648,11 +649,11 @@ handle_isinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_us } else { int klass_reg = alloc_preg (cfg); - if (klass->rank) { + if (m_class_get_rank (klass)) { int rank_reg = alloc_preg (cfg); int eclass_reg = alloc_preg (cfg); - if ((klass->rank == 1) && (klass->byval_arg.type == MONO_TYPE_SZARRAY)) { + if ((m_class_get_rank (klass) == 1) && (m_class_get_byval_arg (klass)->type == MONO_TYPE_SZARRAY)) { /* Check that the object is a vector too */ int bounds_reg = alloc_preg (cfg); MONO_EMIT_NEW_LOAD_MEMBASE (cfg, bounds_reg, obj_reg, MONO_STRUCT_OFFSET (MonoArray, bounds)); @@ -662,34 +663,34 @@ handle_isinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_us g_assert (!context_used); MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, rank)); - MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, klass->rank); + MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, m_class_get_rank (klass)); MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false_bb); MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass)); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, MONO_STRUCT_OFFSET (MonoClass, cast_class)); - if (klass->cast_class == mono_defaults.object_class) { + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, m_class_offsetof_cast_class ()); + if (m_class_get_cast_class (klass) == mono_defaults.object_class) { int parent_reg = alloc_preg (cfg); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, MONO_STRUCT_OFFSET (MonoClass, parent)); - mini_emit_class_check_branch (cfg, parent_reg, mono_defaults.enum_class->parent, OP_PBNE_UN, is_null_bb); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, m_class_offsetof_parent ()); + mini_emit_class_check_branch (cfg, parent_reg, m_class_get_parent (mono_defaults.enum_class), OP_PBNE_UN, is_null_bb); mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_PBEQ, is_null_bb); MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false_bb); - } else if (klass->cast_class == mono_defaults.enum_class->parent) { - mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class->parent, OP_PBEQ, is_null_bb); + } else if (m_class_get_cast_class (klass) == m_class_get_parent (mono_defaults.enum_class)) { + mini_emit_class_check_branch (cfg, eclass_reg, m_class_get_parent (mono_defaults.enum_class), OP_PBEQ, is_null_bb); mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_PBEQ, is_null_bb); MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false_bb); - } else if (klass->cast_class == mono_defaults.enum_class) { + } else if (m_class_get_cast_class (klass) == mono_defaults.enum_class) { mini_emit_class_check_branch (cfg, eclass_reg, mono_defaults.enum_class, OP_PBEQ, is_null_bb); MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_BR, false_bb); - } else if (mono_class_is_interface (klass->cast_class)) { - mini_emit_iface_class_cast (cfg, eclass_reg, klass->cast_class, false_bb, is_null_bb); + } else if (mono_class_is_interface (m_class_get_cast_class (klass))) { + mini_emit_iface_class_cast (cfg, eclass_reg, m_class_get_cast_class (klass), false_bb, is_null_bb); } else { /* the is_null_bb target simply copies the input register to the output */ - mini_emit_isninst_cast (cfg, eclass_reg, klass->cast_class, false_bb, is_null_bb); + mini_emit_isninst_cast (cfg, eclass_reg, m_class_get_cast_class (klass), false_bb, is_null_bb); } } else if (mono_class_is_nullable (klass)) { g_assert (!context_used); MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass)); /* the is_null_bb target simply copies the input register to the output */ - mini_emit_isninst_cast (cfg, klass_reg, klass->cast_class, false_bb, is_null_bb); + mini_emit_isninst_cast (cfg, klass_reg, m_class_get_cast_class (klass), false_bb, is_null_bb); } else { if (!cfg->compile_aot && !(cfg->opt & MONO_OPT_SHARED) && mono_class_is_sealed (klass)) { g_assert (!context_used); @@ -737,7 +738,7 @@ mono_decompose_typecheck (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins) g_assert (is_isinst || ins->opcode == OP_CASTCLASS); source = get_vreg_to_inst (cfg, ins->sreg1); if (!source || source == (MonoInst *) -1) - source = mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, ins->sreg1); + source = mono_compile_create_var_for_vreg (cfg, m_class_get_byval_arg (mono_defaults.object_class), OP_LOCAL, ins->sreg1); g_assert (source && source != (MonoInst *) -1); MonoBasicBlock *first_bb; -- 2.11.4.GIT