[runtime] Switch to mono_object_new_checked

Mark mono_object_new external only.

diff --git a/mono/metadata/appdomain.c b/mono/metadata/appdomain.c
index e35697dd95992ed9979d6e183a21456eeca3dce2..bdf1861f357f7e1da002b16834c41ff4886fe880 100644 (file)
--- a/mono/metadata/appdomain.c
+++ b/mono/metadata/appdomain.c
@@ -158,6 +158,7 @@ mono_runtime_get_no_exec (void)
 static void
 create_domain_objects (MonoDomain *domain)
 {
+       MonoError error;
        MonoDomain *old_domain = mono_domain_get ();
        MonoString *arg;
        MonoVTable *string_vt;
@@ -193,7 +194,8 @@ create_domain_objects (MonoDomain *domain)
        domain->stack_overflow_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "StackOverflowException", arg, NULL);
 
        /*The ephemeron tombstone i*/
-       domain->ephemeron_tombstone = mono_object_new (domain, mono_defaults.object_class);
+       domain->ephemeron_tombstone = mono_object_new_checked (domain, mono_defaults.object_class, &error);
+       mono_error_assert_ok (&error);
 
        if (domain != old_domain) {
                mono_thread_pop_appdomain_ref ();
@@ -403,7 +405,8 @@ mono_domain_create_appdomain (char *friendly_name, char *configuration_file)
        MonoClass *klass;
 
        klass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
-       setup = (MonoAppDomainSetup *) mono_object_new (mono_domain_get (), klass);
+       setup = (MonoAppDomainSetup *) mono_object_new_checked (mono_domain_get (), klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        setup->configuration_file = configuration_file != NULL ? mono_string_new (mono_domain_get (), configuration_file) : NULL;
 
        ad = mono_domain_create_appdomain_internal (friendly_name, setup, &error);
@@ -434,9 +437,11 @@ mono_domain_set_config (MonoDomain *domain, const char *base_dir, const char *co
 static MonoAppDomainSetup*
 copy_app_domain_setup (MonoDomain *domain, MonoAppDomainSetup *setup)
 {
+       MonoError error;
        MonoDomain *caller_domain = mono_domain_get ();
        MonoClass *ads_class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
-       MonoAppDomainSetup *copy = (MonoAppDomainSetup*)mono_object_new (domain, ads_class);
+       MonoAppDomainSetup *copy = (MonoAppDomainSetup*)mono_object_new_checked (domain, ads_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        mono_domain_set_internal (domain);
 
@@ -479,7 +484,8 @@ mono_domain_create_appdomain_internal (char *friendly_name, MonoAppDomainSetup *
        /* FIXME: pin all those objects */
        data = mono_domain_create();
 
-       ad = (MonoAppDomain *) mono_object_new (data, adclass);
+       ad = (MonoAppDomain *) mono_object_new_checked (data, adclass, error);
+       if (!mono_error_ok (error)) return NULL;
        ad->data = data;
        data->domain = ad;
        data->friendly_name = g_strdup (friendly_name);

diff --git a/mono/metadata/exception.c b/mono/metadata/exception.c
index 3c70edb3ac9045051932da332d7bae79a10c65d0..a5e3c895ea71a3f7a37868e1a4c9c5ea7ddd2968 100644 (file)
--- a/mono/metadata/exception.c
+++ b/mono/metadata/exception.c
@@ -59,14 +59,15 @@ MonoException *
 mono_exception_from_name_domain (MonoDomain *domain, MonoImage *image, 
                                 const char* name_space, const char *name)
 {
+       MonoError error;
        MonoClass *klass;
        MonoObject *o;
        MonoDomain *caller_domain = mono_domain_get ();
 
        klass = mono_class_from_name (image, name_space, name);
 
-       o = mono_object_new (domain, klass);
-       g_assert (o != NULL);
+       o = mono_object_new_checked (domain, klass, &error);
+       g_assert (o != NULL && mono_error_ok (&error)); /* FIXME don't swallow the error */
 
        if (domain != caller_domain)
                mono_domain_set_internal (domain);
@@ -97,8 +98,8 @@ mono_exception_from_token (MonoImage *image, guint32 token)
        klass = mono_class_get_checked (image, token, &error);
        g_assert (mono_error_ok (&error)); /* FIXME handle the error. */
 
-       o = mono_object_new (mono_domain_get (), klass);
-       g_assert (o != NULL);
+       o = mono_object_new_checked (mono_domain_get (), klass, &error);
+       g_assert (o != NULL && mono_error_ok (&error)); /* FIXME don't swallow the error */
        
        mono_runtime_object_init (o);
 
@@ -108,6 +109,7 @@ mono_exception_from_token (MonoImage *image, guint32 token)
 static MonoException *
 create_exception_two_strings (MonoClass *klass, MonoString *a1, MonoString *a2)
 {
+       MonoError error;
        MonoDomain *domain = mono_domain_get ();
        MonoMethod *method = NULL;
        MonoObject *o;
@@ -119,7 +121,8 @@ create_exception_two_strings (MonoClass *klass, MonoString *a1, MonoString *a2)
        if (a2 != NULL)
                count++;
        
-       o = mono_object_new (domain, klass);
+       o = mono_object_new_checked (domain, klass, &error);
+       mono_error_assert_ok (&error);
 
        iter = NULL;
        while ((m = mono_class_get_methods (klass, &iter))) {
@@ -570,6 +573,7 @@ mono_get_exception_file_not_found2 (const char *msg, MonoString *fname)
 MonoException *
 mono_get_exception_type_initialization (const gchar *type_name, MonoException *inner)
 {
+       MonoError error;
        MonoClass *klass;
        gpointer args [2];
        MonoObject *exc;
@@ -596,7 +600,8 @@ mono_get_exception_type_initialization (const gchar *type_name, MonoException *i
        args [0] = mono_string_new (mono_domain_get (), type_name);
        args [1] = inner;
 
-       exc = mono_object_new (mono_domain_get (), klass);
+       exc = mono_object_new_checked (mono_domain_get (), klass, &error);
+       mono_error_assert_ok (&error);
        mono_runtime_invoke (method, exc, args, NULL);
 
        return (MonoException *) exc;
@@ -743,6 +748,7 @@ mono_get_exception_method_access_msg (const char *msg)
 MonoException *
 mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions)
 {
+       MonoError error;
        MonoClass *klass;
        gpointer args [2];
        MonoObject *exc;
@@ -769,7 +775,8 @@ mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions
        args [0] = types;
        args [1] = exceptions;
 
-       exc = mono_object_new (mono_domain_get (), klass);
+       exc = mono_object_new_checked (mono_domain_get (), klass, &error);
+       mono_error_assert_ok (&error);
        mono_runtime_invoke (method, exc, args, NULL);
 
        return (MonoException *) exc;
@@ -778,6 +785,7 @@ mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions
 MonoException *
 mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception)
 {
+       MonoError error;
        MonoClass *klass;
        MonoObject *o;
        MonoMethod *method;
@@ -787,8 +795,8 @@ mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception)
        klass = mono_class_from_name (mono_get_corlib (), "System.Runtime.CompilerServices", "RuntimeWrappedException");
        g_assert (klass);
 
-       o = mono_object_new (domain, klass);
-       g_assert (o != NULL);
+       o = mono_object_new_checked (domain, klass, &error);
+       g_assert (o != NULL && mono_error_ok (&error)); /* FIXME don't swallow the error */
 
        method = mono_class_get_method_from_name (klass, ".ctor", 1);
        g_assert (method);

diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c
index efa7242ef72556d2a68a6d42e55e0fe534d820ee..999410efe742639dab9e2c5bfb86357359cdf1d5 100644 (file)
--- a/mono/metadata/icall.c
+++ b/mono/metadata/icall.c
@@ -1846,7 +1846,11 @@ ves_icall_MonoField_SetValueInternal (MonoReflectionField *field, MonoObject *ob
                                 * This is complicated by the fact that Nullables have
                                 * a variable structure.
                                 */
-                               nullable = mono_object_new (mono_domain_get (), nklass);
+                               nullable = mono_object_new_checked (mono_domain_get (), nklass, &error);
+                               if (!mono_error_ok (&error)) {
+                                       mono_error_set_pending_exception (&error);
+                                       return;
+                               }
 
                                mono_nullable_init ((guint8 *)mono_object_unbox (nullable), value, nklass);
 
@@ -1966,7 +1970,11 @@ ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *rfield)
                t->type = def_type;
                klass = mono_class_from_mono_type (t);
                g_free (t);
-               o = mono_object_new (domain, klass);
+               o = mono_object_new_checked (domain, klass, &error);
+               if (!mono_error_ok (&error)) {
+                       mono_error_set_pending_exception (&error);
+                       return NULL;
+               }
                v = ((gchar *) o) + sizeof (MonoObject);
                mono_get_constant_value_from_blob (domain, def_type, def_value, v);
                break;
@@ -3175,6 +3183,7 @@ write_enum_value (char *mem, int type, guint64 value)
 ICALL_EXPORT MonoObject *
 ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, guint64 value)
 {
+       MonoError error;
        MonoDomain *domain; 
        MonoClass *enumc;
        MonoObject *res;
@@ -3187,7 +3196,8 @@ ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, guint64 value)
 
        etype = mono_class_enum_basetype (enumc);
 
-       res = mono_object_new (domain, enumc);
+       res = mono_object_new_checked (domain, enumc, &error);
+       mono_error_raise_exception (&error);
        write_enum_value ((char *)res + sizeof (MonoObject), etype->type, value);
 
        return res;
@@ -3208,6 +3218,7 @@ ves_icall_System_Enum_InternalHasFlag (MonoObject *a, MonoObject *b)
 ICALL_EXPORT MonoObject *
 ves_icall_System_Enum_get_value (MonoObject *eobj)
 {
+       MonoError error;
        MonoObject *res;
        MonoClass *enumc;
        gpointer dst;
@@ -3220,7 +3231,8 @@ ves_icall_System_Enum_get_value (MonoObject *eobj)
        g_assert (eobj->vtable->klass->enumtype);
        
        enumc = mono_class_from_mono_type (mono_class_enum_basetype (eobj->vtable->klass));
-       res = mono_object_new (mono_object_domain (eobj), enumc);
+       res = mono_object_new_checked (mono_object_domain (eobj), enumc, &error);
+       mono_error_raise_exception (&error);
        dst = (char *)res + sizeof (MonoObject);
        src = (char *)eobj + sizeof (MonoObject);
        size = mono_class_value_size (enumc, NULL);
@@ -4432,6 +4444,7 @@ create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build,
 {
        static MonoClass *System_Version = NULL;
        static MonoMethod *create_version = NULL;
+       MonoError error;
        MonoObject *result;
        gpointer args [4];
        
@@ -4451,7 +4464,8 @@ create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build,
        args [1] = &minor;
        args [2] = &build;
        args [3] = &revision;
-       result = mono_object_new (domain, System_Version);
+       result = mono_object_new_checked (domain, System_Version, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        mono_runtime_invoke (create_version, result, args, NULL);
 
        return result;
@@ -4461,6 +4475,7 @@ ICALL_EXPORT MonoArray*
 ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly) 
 {
        static MonoClass *System_Reflection_AssemblyName;
+       MonoError error;
        MonoArray *result;
        MonoDomain *domain = mono_object_domain (assembly);
        int i, count = 0;
@@ -4491,8 +4506,9 @@ ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAsse
 
                mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
 
-               aname = (MonoReflectionAssemblyName *) mono_object_new (
-                       domain, System_Reflection_AssemblyName);
+               aname = (MonoReflectionAssemblyName *) mono_object_new_checked (
+                       domain, System_Reflection_AssemblyName, &error);
+               mono_error_raise_exception (&error);
 
                MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME])));
 
@@ -5890,6 +5906,7 @@ ICALL_EXPORT MonoObject *
 ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, MonoObject *target,
                                                   MonoReflectionMethod *info, MonoBoolean throwOnBindFailure)
 {
+       MonoError error;
        MonoClass *delegate_class = mono_class_from_mono_type (type->type);
        MonoObject *delegate;
        gpointer func;
@@ -5904,7 +5921,8 @@ ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, Mon
                        return NULL;
        }
 
-       delegate = mono_object_new (mono_object_domain (type), delegate_class);
+       delegate = mono_object_new_checked (mono_object_domain (type), delegate_class, &error);
+       mono_error_raise_exception (&error);
 
        if (method_is_dynamic (method)) {
                /* Creating a trampoline would leak memory */
@@ -5924,11 +5942,13 @@ ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, Mon
 ICALL_EXPORT MonoMulticastDelegate *
 ves_icall_System_Delegate_AllocDelegateLike_internal (MonoDelegate *delegate)
 {
+       MonoError error;
        MonoMulticastDelegate *ret;
 
        g_assert (mono_class_has_parent (mono_object_class (delegate), mono_defaults.multicastdelegate_class));
 
-       ret = (MonoMulticastDelegate*) mono_object_new (mono_object_domain (delegate), mono_object_class (delegate));
+       ret = (MonoMulticastDelegate*) mono_object_new_checked (mono_object_domain (delegate), mono_object_class (delegate), &error);
+       mono_error_raise_exception (&error);
        ret->delegate.invoke_impl = mono_runtime_create_delegate_trampoline (mono_object_class (delegate));
 
        return ret;
@@ -6037,6 +6057,7 @@ ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, Mo
 ICALL_EXPORT MonoObject *
 ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this_obj, MonoString *class_name)
 {
+       MonoError error;
        MonoDomain *domain = mono_object_domain (this_obj); 
        MonoObject *res;
        MonoRealProxy *rp = ((MonoRealProxy *)this_obj);
@@ -6044,7 +6065,8 @@ ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this_obj, MonoStri
        MonoType *type;
        MonoClass *klass;
 
-       res = mono_object_new (domain, mono_defaults.transparent_proxy_class);
+       res = mono_object_new_checked (domain, mono_defaults.transparent_proxy_class, &error);
+       mono_error_raise_exception (&error);
        tp = (MonoTransparentProxy*) res;
        
        MONO_OBJECT_SETREF (tp, rp, rp);
@@ -6918,6 +6940,8 @@ ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (MonoS
 ICALL_EXPORT MonoObject *
 ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type)
 {
+       MonoError error;
+       MonoObject *result;
        MonoClass *klass;
        MonoDomain *domain;
        
@@ -6929,7 +6953,9 @@ ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type)
                /* No arguments -> null */
                return NULL;
 
-       return mono_object_new (domain, klass);
+       result = mono_object_new_checked (domain, klass, &error);
+       mono_error_raise_exception (&error);
+       return result;
 }
 
 ICALL_EXPORT MonoReflectionMethod *

diff --git a/mono/metadata/locales.c b/mono/metadata/locales.c
index 1060d0f476023a92b893a5d0c51a606308f4f1bb..fa510af6f44d6bda879ec0062060d5158d7c0e0b 100644 (file)
--- a/mono/metadata/locales.c
+++ b/mono/metadata/locales.c
@@ -574,6 +574,7 @@ MonoArray*
 ves_icall_System_Globalization_CultureInfo_internal_get_cultures (MonoBoolean neutral,
                MonoBoolean specific, MonoBoolean installed)
 {
+       MonoError error;
        MonoArray *ret;
        MonoClass *klass;
        MonoCultureInfo *culture;
@@ -613,7 +614,8 @@ ves_icall_System_Globalization_CultureInfo_internal_get_cultures (MonoBoolean ne
                ci = &culture_entries [i];
                is_neutral = ci->territory == 0;
                if ((neutral && is_neutral) || (specific && !is_neutral)) {
-                       culture = (MonoCultureInfo *) mono_object_new (domain, klass);
+                       culture = (MonoCultureInfo *) mono_object_new_checked (domain, klass, &error);
+                       mono_error_raise_exception (&error);
                        mono_runtime_object_init ((MonoObject *) culture);
                        construct_culture (culture, ci);
                        culture->use_user_override = TRUE;

diff --git a/mono/metadata/marshal.c b/mono/metadata/marshal.c
index 3c6768041b2089b6eba1d60a518d8464943ad3e5..f1d27758c9c25cba05665d3c5340735accf0fe79 100644 (file)
--- a/mono/metadata/marshal.c
+++ b/mono/metadata/marshal.c
@@ -424,6 +424,7 @@ parse_unmanaged_function_pointer_attr (MonoClass *klass, MonoMethodPInvoke *piin
 MonoDelegate*
 mono_ftnptr_to_delegate (MonoClass *klass, gpointer ftn)
 {
+       MonoError error;
        guint32 gchandle;
        MonoDelegate *d;
 
@@ -478,7 +479,8 @@ mono_ftnptr_to_delegate (MonoClass *klass, gpointer ftn)
                        g_free (sig);
                }
 
-               d = (MonoDelegate*)mono_object_new (mono_domain_get (), klass);
+               d = (MonoDelegate*)mono_object_new_checked (mono_domain_get (), klass, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
                mono_delegate_ctor_with_method ((MonoObject*)d, this_obj, mono_compile_method (wrapper), wrapper);
        }
 
@@ -704,6 +706,7 @@ mono_array_to_byte_byvalarray (gpointer native_arr, MonoArray *arr, guint32 elnu
 static MonoStringBuilder *
 mono_string_builder_new (int starting_string_length)
 {
+       MonoError error;
        static MonoClass *string_builder_class;
        static MonoMethod *sb_ctor;
        static void *args [1];
@@ -730,9 +733,9 @@ mono_string_builder_new (int starting_string_length)
        // array will always be garbage collected.
        args [0] = &initial_len;
 
-       MonoStringBuilder *sb = (MonoStringBuilder*)mono_object_new (mono_domain_get (), string_builder_class);
+       MonoStringBuilder *sb = (MonoStringBuilder*)mono_object_new_checked (mono_domain_get (), string_builder_class, &error);
        MonoObject *exc;
-       g_assert (sb);
+       g_assert (sb && mono_error_ok (&error)); /* FIXME don't swallow the error */
 
        mono_runtime_invoke (sb_ctor, sb, args, &exc);
        g_assert (!exc);
@@ -2778,6 +2781,7 @@ mono_marshal_get_delegate_begin_invoke (MonoMethod *method)
 static MonoObject *
 mono_delegate_end_invoke (MonoDelegate *delegate, gpointer *params)
 {
+       MonoError error;
        MonoDomain *domain = mono_domain_get ();
        MonoAsyncResult *ares;
        MonoMethod *method = NULL;
@@ -2821,7 +2825,8 @@ mono_delegate_end_invoke (MonoDelegate *delegate, gpointer *params)
 #ifndef DISABLE_REMOTING
        if (delegate->target && mono_object_is_transparent_proxy (delegate->target)) {
                MonoTransparentProxy* tp = (MonoTransparentProxy *)delegate->target;
-               msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
+               msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
                mono_message_init (domain, msg, delegate->method_info, NULL);
                msg->call_type = CallType_EndInvoke;
                MONO_OBJECT_SETREF (msg, async_result, ares);
@@ -10377,6 +10382,7 @@ ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (gpointer src, M
 MonoObject *
 ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer src, MonoReflectionType *type)
 {
+       MonoError error;
        MonoClass *klass;
        MonoDomain *domain = mono_domain_get (); 
        MonoObject *res;
@@ -10391,7 +10397,8 @@ ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer s
                return NULL;
        }
 
-       res = mono_object_new (domain, klass);
+       res = mono_object_new_checked (domain, klass, &error);
+       mono_error_raise_exception (&error);
 
        ptr_to_structure (src, res);
 

diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h
index 03592a9d3209d21022bb5579ef2925e631d6756c..179e3856a398656bcf27e72eaa8a42b41fd63807 100644 (file)
--- a/mono/metadata/object-internals.h
+++ b/mono/metadata/object-internals.h
@@ -1623,6 +1623,9 @@ mono_object_new_pinned (MonoDomain *domain, MonoClass *klass, MonoError *error);
 MonoObject *
 mono_object_new_specific_checked (MonoVTable *vtable, MonoError *error);
 
+MonoObject *
+ves_icall_object_new (MonoDomain *domain, MonoClass *klass);
+       
 MonoObject *
 ves_icall_object_new_specific (MonoVTable *vtable);
 

diff --git a/mono/metadata/object.c b/mono/metadata/object.c
index f97a9462365f11f75589d3d531bdbcb49e67f115..711bd794ecaff6b502e090c487d97a0b84d166ac 100644 (file)
--- a/mono/metadata/object.c
+++ b/mono/metadata/object.c
@@ -3335,7 +3335,8 @@ mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObje
        if (mono_class_is_nullable (klass))
                return mono_nullable_box (mono_field_get_addr (obj, vtable, field), klass);
 
-       o = mono_object_new (domain, klass);
+       o = mono_object_new_checked (domain, klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        v = ((gchar *) o) + sizeof (MonoObject);
 
        if (is_literal) {
@@ -3555,6 +3556,8 @@ mono_nullable_box (guint8 *buf, MonoClass *klass)
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
+       
        MonoClass *param_class = klass->cast_class;
 
        mono_class_setup_fields_locking (klass);
@@ -3564,7 +3567,8 @@ mono_nullable_box (guint8 *buf, MonoClass *klass)
        g_assert (mono_class_from_mono_type (klass->fields [1].type) == mono_defaults.boolean_class);
 
        if (*(guint8*)(buf + klass->fields [1].offset - sizeof (MonoObject))) {
-               MonoObject *o = mono_object_new (mono_domain_get (), param_class);
+               MonoObject *o = mono_object_new_checked (mono_domain_get (), param_class, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
                if (param_class->has_references)
                        mono_gc_wbarrier_value_copy (mono_object_unbox (o), buf + klass->fields [0].offset - sizeof (MonoObject), 1, param_class);
                else
@@ -3922,7 +3926,8 @@ make_transparent_proxy (MonoObject *obj, gboolean *failure, MonoObject **exc)
 
        g_assert (mono_class_is_marshalbyref (obj->vtable->klass));
 
-       real_proxy = (MonoRealProxy*) mono_object_new (domain, mono_defaults.real_proxy_class);
+       real_proxy = (MonoRealProxy*) mono_object_new_checked (domain, mono_defaults.real_proxy_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        reflection_type = mono_type_get_object_checked (domain, &obj->vtable->klass->byval_arg, &error);
        mono_error_raise_exception (&error); /* FIXME don't raise here */
 
@@ -3990,6 +3995,7 @@ create_unhandled_exception_eventargs (MonoObject *exc)
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        MonoClass *klass;
        gpointer args [2];
        MonoMethod *method = NULL;
@@ -4008,7 +4014,8 @@ create_unhandled_exception_eventargs (MonoObject *exc)
        args [0] = exc;
        args [1] = &is_terminating;
 
-       obj = mono_object_new (mono_domain_get (), klass);
+       obj = mono_object_new_checked (mono_domain_get (), klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        mono_runtime_invoke (method, obj, args, NULL);
 
        return obj;
@@ -4335,8 +4342,11 @@ mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
                                                has_byref_nullables = TRUE;
                                } else {
                                        /* MS seems to create the objects if a null is passed in */
-                                       if (!mono_array_get (params, MonoObject*, i))
-                                               mono_array_setref (params, i, mono_object_new (mono_domain_get (), mono_class_from_mono_type (sig->params [i]))); 
+                                       if (!mono_array_get (params, MonoObject*, i)) {
+                                               MonoObject *o = mono_object_new_checked (mono_domain_get (), mono_class_from_mono_type (sig->params [i]), &error);
+                                               mono_error_raise_exception (&error); /* FIXME don't raise here */
+                                               mono_array_setref (params, i, o); 
+                                       }
 
                                        if (t->byref) {
                                                /*
@@ -4404,8 +4414,8 @@ mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
                }
 
                if (!obj) {
-                       obj = mono_object_new (mono_domain_get (), method->klass);
-                       g_assert (obj); /*maybe we should raise a TLE instead?*/
+                       obj = mono_object_new_checked (mono_domain_get (), method->klass, &error);
+                       g_assert (obj && mono_error_ok (&error)); /*maybe we should raise a TLE instead?*/ /* FIXME don't swallow error */
 #ifndef DISABLE_REMOTING
                        if (mono_object_class(obj) == mono_defaults.transparent_proxy_class) {
                                method = mono_marshal_get_remoting_invoke (method->slot == -1 ? method : method->klass->vtable [method->slot]);
@@ -4426,7 +4436,8 @@ mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
                        MonoObject *nullable;
 
                        /* Convert the unboxed vtype into a Nullable structure */
-                       nullable = mono_object_new (mono_domain_get (), method->klass);
+                       nullable = mono_object_new_checked (mono_domain_get (), method->klass, &error);
+                       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
                        mono_nullable_init ((guint8 *)mono_object_unbox (nullable), mono_value_box (mono_domain_get (), method->klass->cast_class, obj), method->klass);
                        obj = mono_object_unbox (nullable);
@@ -4500,6 +4511,19 @@ mono_object_new (MonoDomain *domain, MonoClass *klass)
        return result;
 }
 
+MonoObject *
+ves_icall_object_new (MonoDomain *domain, MonoClass *klass)
+{
+       MONO_REQ_GC_UNSAFE_MODE;
+
+       MonoError error;
+
+       MonoObject * result = mono_object_new_checked (domain, klass, &error);
+
+       mono_error_raise_exception (&error);
+       return result;
+}
+
 /**
  * mono_object_new_checked:
  * @klass: the class of the object that we want to create
@@ -4760,12 +4784,17 @@ mono_object_new_from_token  (MonoDomain *domain, MonoImage *image, guint32 token
        MONO_REQ_GC_UNSAFE_MODE;
 
        MonoError error;
+       MonoObject *result;
        MonoClass *klass;
 
        klass = mono_class_get_checked (image, token, &error);
        g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
+       
+       result = mono_object_new_checked (domain, klass, &error);
 
-       return mono_object_new (domain, klass);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
+       return result;
+       
 }
 
 
@@ -6213,11 +6242,13 @@ mono_wait_handle_new (MonoDomain *domain, HANDLE handle)
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        MonoWaitHandle *res;
        gpointer params [1];
        static MonoMethod *handle_set;
 
-       res = (MonoWaitHandle *)mono_object_new (domain, mono_defaults.manualresetevent_class);
+       res = (MonoWaitHandle *)mono_object_new_checked (domain, mono_defaults.manualresetevent_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        /* Even though this method is virtual, it's safe to invoke directly, since the object type matches.  */
        if (!handle_set)
@@ -6291,7 +6322,9 @@ mono_async_result_new (MonoDomain *domain, HANDLE handle, MonoObject *state, gpo
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
-       MonoAsyncResult *res = (MonoAsyncResult *)mono_object_new (domain, mono_defaults.asyncresult_class);
+       MonoError error;
+       MonoAsyncResult *res = (MonoAsyncResult *)mono_object_new_checked (domain, mono_defaults.asyncresult_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        MonoObject *context = mono_runtime_capture_context (domain);
        /* we must capture the execution context from the original thread */
        if (context) {
@@ -6731,13 +6764,15 @@ mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        MonoDomain *domain = mono_domain_get ();
        MonoMethodSignature *sig = mono_method_signature (method);
        MonoMethodMessage *msg;
        int i, count;
 
-       msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class); 
-       
+       msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, &error); 
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
        if (invoke) {
                mono_message_init (domain, msg, mono_method_get_object (domain, invoke, NULL), NULL);
                count =  sig->param_count - 2;
@@ -6849,6 +6884,7 @@ mono_load_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        static MonoMethod *getter = NULL;
        MonoDomain *domain = mono_domain_get ();
        MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
@@ -6874,7 +6910,8 @@ mono_load_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *
        
        field_class = mono_class_from_mono_type (field->type);
 
-       msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
+       msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        out_args = mono_array_new (domain, mono_defaults.object_class, 1);
        mono_message_init (domain, msg, mono_method_get_object (domain, getter, NULL), out_args);
 
@@ -6911,6 +6948,7 @@ mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassFie
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        static MonoMethod *getter = NULL;
        MonoDomain *domain = mono_domain_get ();
        MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
@@ -6927,7 +6965,8 @@ mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassFie
        if (mono_class_is_contextbound (tp->remote_class->proxy_class) && tp->rp->context == (MonoObject *) mono_context_get ()) {
                gpointer val;
                if (field_class->valuetype) {
-                       res = mono_object_new (domain, field_class);
+                       res = mono_object_new_checked (domain, field_class, &error);
+                       mono_error_raise_exception (&error); /* FIXME don't raise here */
                        val = ((gchar *) res) + sizeof (MonoObject);
                } else {
                        val = &res;
@@ -6942,7 +6981,8 @@ mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassFie
                        mono_raise_exception (mono_get_exception_not_supported ("Linked away."));
        }
        
-       msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
+       msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        out_args = mono_array_new (domain, mono_defaults.object_class, 1);
 
        mono_message_init (domain, msg, mono_method_get_object (domain, getter, NULL), out_args);
@@ -6980,6 +7020,7 @@ mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        static MonoMethod *setter = NULL;
        MonoDomain *domain = mono_domain_get ();
        MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
@@ -7012,7 +7053,8 @@ mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField
                arg = *((MonoObject **)val);
                
 
-       msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
+       msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        mono_message_init (domain, msg, mono_method_get_object (domain, setter, NULL), NULL);
 
        full_name = mono_type_get_full_name (klass);
@@ -7040,6 +7082,7 @@ mono_store_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassFi
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        static MonoMethod *setter = NULL;
        MonoDomain *domain = mono_domain_get ();
        MonoTransparentProxy *tp = (MonoTransparentProxy *) this_obj;
@@ -7065,7 +7108,8 @@ mono_store_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassFi
                        mono_raise_exception (mono_get_exception_not_supported ("Linked away."));
        }
 
-       msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
+       msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, &error);
+       mono_error_raise_exception (&error);
        mono_message_init (domain, msg, mono_method_get_object (domain, setter, NULL), NULL);
 
        full_name = mono_type_get_full_name (klass);

diff --git a/mono/metadata/object.h b/mono/metadata/object.h
index 7aef3ad2e6095f3fb203843a5ece7843f2b09339..0790764fe28c46cbc41428793bef1634196403bd 100644 (file)
--- a/mono/metadata/object.h
+++ b/mono/metadata/object.h
@@ -69,7 +69,7 @@ typedef void      (*MonoMainThreadFunc)    (void* user_data);
 MONO_API mono_unichar2 *mono_string_chars  (MonoString *s);
 MONO_API int            mono_string_length (MonoString *s);
 
-MONO_API MonoObject *
+MONO_RT_EXTERNAL_ONLY MONO_API MonoObject *
 mono_object_new                    (MonoDomain *domain, MonoClass *klass);
 
 MONO_API MonoObject *

diff --git a/mono/metadata/process.c b/mono/metadata/process.c
index 24d33ee89c86a283f21b4270967fd9083ec50af7..7de73a58b8562c22fa3da2b25ef737a023dcf071 100644 (file)
--- a/mono/metadata/process.c
+++ b/mono/metadata/process.c
@@ -377,6 +377,7 @@ static void process_get_assembly_fileversion (MonoObject *filever, MonoAssembly
 
 static MonoObject* get_process_module (MonoAssembly *assembly, MonoClass *proc_class)
 {
+       MonoError error;
        static MonoClass *filever_class = NULL;
        MonoObject *item, *filever;
        MonoDomain *domain = mono_domain_get ();
@@ -387,14 +388,16 @@ static MonoObject* get_process_module (MonoAssembly *assembly, MonoClass *proc_c
 
        /* Build a System.Diagnostics.ProcessModule with the data.
         */
-       item = mono_object_new (domain, proc_class);
+       item = mono_object_new_checked (domain, proc_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        if (!filever_class)
                filever_class = mono_class_from_name (system_assembly,
                                            "System.Diagnostics",
                                            "FileVersionInfo");
 
-       filever = mono_object_new (domain, filever_class);
+       filever = mono_object_new_checked (domain, filever_class, &error);
+       if (!mono_error_ok (&error)) goto leave;
 
        process_get_assembly_fileversion (filever, assembly);
        process_set_field_string_char (filever, "filename", filename);
@@ -405,13 +408,16 @@ static MonoObject* get_process_module (MonoAssembly *assembly, MonoClass *proc_c
        process_set_field_string_char (item, "filename", filename);
        process_set_field_string_char (item, "modulename", modulename);
 
+leave:
        g_free (filename);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        return item;
 }
 
 static MonoObject* process_add_module (HANDLE process, HMODULE mod, gunichar2 *filename, gunichar2 *modulename, MonoClass *proc_class)
 {
+       MonoError error;
        static MonoClass *filever_class = NULL;
        MonoObject *item, *filever;
        MonoDomain *domain=mono_domain_get ();
@@ -420,14 +426,16 @@ static MonoObject* process_add_module (HANDLE process, HMODULE mod, gunichar2 *f
        
        /* Build a System.Diagnostics.ProcessModule with the data.
         */
-       item=mono_object_new (domain, proc_class);
+       item=mono_object_new_checked (domain, proc_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        if (!filever_class)
                filever_class=mono_class_from_name (system_assembly,
                                            "System.Diagnostics",
                                            "FileVersionInfo");
 
-       filever=mono_object_new (domain, filever_class);
+       filever=mono_object_new_checked (domain, filever_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        process_get_fileversion (filever, filename);
 

diff --git a/mono/metadata/reflection.c b/mono/metadata/reflection.c
index c564c51678820ddab7d5b25ba18a53bd747b7ed4..eb28963c6f054db678a0a8f7f0442be1c352aea0 100644 (file)
--- a/mono/metadata/reflection.c
+++ b/mono/metadata/reflection.c
@@ -6500,6 +6500,7 @@ mono_image_set_wrappers_type (MonoReflectionModuleBuilder *moduleb, MonoReflecti
 MonoReflectionAssembly*
 mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
 {
+       MonoError error;
        static MonoClass *assembly_type;
        MonoReflectionAssembly *res;
        
@@ -6511,7 +6512,8 @@ mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
                g_assert (klass);
                assembly_type = klass;
        }
-       res = (MonoReflectionAssembly *)mono_object_new (domain, assembly_type);
+       res = (MonoReflectionAssembly *)mono_object_new_checked (domain, assembly_type, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        res->assembly = assembly;
 
        CACHE_OBJECT (MonoReflectionAssembly *, assembly, res, NULL);
@@ -6522,6 +6524,7 @@ mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
 MonoReflectionModule*   
 mono_module_get_object   (MonoDomain *domain, MonoImage *image)
 {
+       MonoError error;
        static MonoClass *module_type;
        MonoReflectionModule *res;
        char* basename;
@@ -6534,7 +6537,8 @@ mono_module_get_object   (MonoDomain *domain, MonoImage *image)
                g_assert (klass);
                module_type = klass;
        }
-       res = (MonoReflectionModule *)mono_object_new (domain, module_type);
+       res = (MonoReflectionModule *)mono_object_new_checked (domain, module_type, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        res->image = image;
        MONO_OBJECT_SETREF (res, assembly, (MonoReflectionAssembly *) mono_assembly_get_object(domain, image->assembly));
@@ -6566,6 +6570,7 @@ mono_module_get_object   (MonoDomain *domain, MonoImage *image)
 MonoReflectionModule*   
 mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index)
 {
+       MonoError error;
        static MonoClass *module_type;
        MonoReflectionModule *res;
        MonoTableInfo *table;
@@ -6581,7 +6586,8 @@ mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_ind
                g_assert (klass);
                module_type = klass;
        }
-       res = (MonoReflectionModule *)mono_object_new (domain, module_type);
+       res = (MonoReflectionModule *)mono_object_new_checked (domain, module_type, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        table = &image->tables [MONO_TABLE_FILE];
        g_assert (table_index < table->rows);
@@ -6856,7 +6862,8 @@ mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refcl
                                System_Reflection_MonoGenericMethod = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoGenericMethod");
                        klass = System_Reflection_MonoGenericMethod;
                }
-               gret = (MonoReflectionGenericMethod*)mono_object_new (domain, klass);
+               gret = (MonoReflectionGenericMethod*)mono_object_new_checked (domain, klass, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
                gret->method.method = method;
 
                MONO_OBJECT_SETREF (gret, method.name, mono_string_new (domain, method->name));
@@ -6883,7 +6890,8 @@ mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refcl
                        System_Reflection_MonoMethod = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoMethod");
                klass = System_Reflection_MonoMethod;
        }
-       ret = (MonoReflectionMethod*)mono_object_new (domain, klass);
+       ret = (MonoReflectionMethod*)mono_object_new_checked (domain, klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        ret->method = method;
 
        rt = mono_type_get_object_checked (domain, &refclass->byval_arg, &error);
@@ -6939,7 +6947,8 @@ mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *fie
        CHECK_OBJECT (MonoReflectionField *, field, klass);
        if (!monofield_klass)
                monofield_klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoField");
-       res = (MonoReflectionField *)mono_object_new (domain, monofield_klass);
+       res = (MonoReflectionField *)mono_object_new_checked (domain, monofield_klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        res->klass = klass;
        res->field = field;
        MONO_OBJECT_SETREF (res, name, mono_string_new (domain, mono_field_get_name (field)));
@@ -6975,13 +6984,15 @@ mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *fie
 MonoReflectionProperty*
 mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property)
 {
+       MonoError error;
        MonoReflectionProperty *res;
        static MonoClass *monoproperty_klass;
 
        CHECK_OBJECT (MonoReflectionProperty *, property, klass);
        if (!monoproperty_klass)
                monoproperty_klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoProperty");
-       res = (MonoReflectionProperty *)mono_object_new (domain, monoproperty_klass);
+       res = (MonoReflectionProperty *)mono_object_new_checked (domain, monoproperty_klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        res->klass = klass;
        res->property = property;
        CACHE_OBJECT (MonoReflectionProperty *, property, res, klass);
@@ -6999,6 +7010,7 @@ mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *pr
 MonoReflectionEvent*
 mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event)
 {
+       MonoError error;
        MonoReflectionEvent *res;
        MonoReflectionMonoEvent *mono_event;
        static MonoClass *monoevent_klass;
@@ -7006,7 +7018,8 @@ mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event)
        CHECK_OBJECT (MonoReflectionEvent *, event, klass);
        if (!monoevent_klass)
                monoevent_klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoEvent");
-       mono_event = (MonoReflectionMonoEvent *)mono_object_new (domain, monoevent_klass);
+       mono_event = (MonoReflectionMonoEvent *)mono_object_new_checked (domain, monoevent_klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        mono_event->klass = klass;
        mono_event->event = event;
        res = (MonoReflectionEvent*)mono_event;
@@ -7276,7 +7289,8 @@ mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
        } else
                local_var_sig_token = 0; //FIXME
 
-       ret = (MonoReflectionMethodBody*)mono_object_new (domain, System_Reflection_MethodBody);
+       ret = (MonoReflectionMethodBody*)mono_object_new_checked (domain, System_Reflection_MethodBody, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        ret->init_locals = header->init_locals;
        ret->max_stack = header->max_stack;
@@ -7287,7 +7301,8 @@ mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
        /* Locals */
        MONO_OBJECT_SETREF (ret, locals, mono_array_new_cached (domain, System_Reflection_LocalVariableInfo, header->num_locals));
        for (i = 0; i < header->num_locals; ++i) {
-               MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new (domain, System_Reflection_LocalVariableInfo);
+               MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new_checked (domain, System_Reflection_LocalVariableInfo, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
 
                rt = mono_type_get_object_checked (domain, header->locals [i], &error);
                mono_error_raise_exception (&error); /* FIXME don't raise here */
@@ -7302,7 +7317,8 @@ mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
        /* Exceptions */
        MONO_OBJECT_SETREF (ret, clauses, mono_array_new_cached (domain, System_Reflection_ExceptionHandlingClause, header->num_clauses));
        for (i = 0; i < header->num_clauses; ++i) {
-               MonoReflectionExceptionHandlingClause *info = (MonoReflectionExceptionHandlingClause*)mono_object_new (domain, System_Reflection_ExceptionHandlingClause);
+               MonoReflectionExceptionHandlingClause *info = (MonoReflectionExceptionHandlingClause*)mono_object_new_checked (domain, System_Reflection_ExceptionHandlingClause, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
                MonoExceptionClause *clause = &header->clauses [i];
 
                info->flags = clause->flags;
@@ -7423,6 +7439,7 @@ get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types)
 MonoObject *
 mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob)
 {
+       MonoError error;
        void *retval;
        MonoClass *klass;
        MonoObject *object;
@@ -7433,7 +7450,8 @@ mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob)
        
        klass = mono_class_from_mono_type (type);
        if (klass->valuetype) {
-               object = mono_object_new (domain, klass);
+               object = mono_object_new_checked (domain, klass, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
                retval = ((gchar *) object + sizeof (MonoObject));
                if (klass->enumtype)
                        basetype = mono_class_enum_basetype (klass);
@@ -8445,9 +8463,10 @@ handle_type:
                val = load_cattr_value (image, &subc->byval_arg, p, end, error);
                obj = NULL;
                if (mono_error_ok (error)) {
-                       obj = mono_object_new (mono_domain_get (), subc);
+                       obj = mono_object_new_checked (mono_domain_get (), subc, error);
                        g_assert (!subc->has_references);
-                       mono_gc_memmove_atomic ((char*)obj + sizeof (MonoObject), val, mono_class_value_size (subc, NULL));
+                       if (mono_error_ok (error))
+                               mono_gc_memmove_atomic ((char*)obj + sizeof (MonoObject), val, mono_class_value_size (subc, NULL));
                }
 
                g_free (val);
@@ -8551,7 +8570,8 @@ create_cattr_typed_arg (MonoType *t, MonoObject *val)
        mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        params [1] = val;
-       retval = mono_object_new (mono_domain_get (), klass);
+       retval = mono_object_new_checked (mono_domain_get (), klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        unboxed = mono_object_unbox (retval);
        mono_runtime_invoke (ctor, unboxed, params, NULL);
 
@@ -8563,6 +8583,7 @@ create_cattr_named_arg (void *minfo, MonoObject *typedarg)
 {
        static MonoClass *klass;
        static MonoMethod *ctor;
+       MonoError error;
        MonoObject *retval;
        void *unboxed, *params [2];
 
@@ -8573,7 +8594,8 @@ create_cattr_named_arg (void *minfo, MonoObject *typedarg)
 
        params [0] = minfo;
        params [1] = typedarg;
-       retval = mono_object_new (mono_domain_get (), klass);
+       retval = mono_object_new_checked (mono_domain_get (), klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        unboxed = mono_object_unbox (retval);
        mono_runtime_invoke (ctor, unboxed, params, NULL);
 
@@ -8678,7 +8700,8 @@ create_custom_attr (MonoImage *image, MonoMethod *method, const guchar *data, gu
        }
 
        if (len == 0) {
-               attr = mono_object_new (mono_domain_get (), method->klass);
+               attr = mono_object_new_checked (mono_domain_get (), method->klass, error);
+               if (!mono_error_ok (error)) return NULL;
                mono_runtime_invoke (method, attr, NULL, NULL);
                return attr;
        }
@@ -8706,7 +8729,8 @@ create_custom_attr (MonoImage *image, MonoMethod *method, const guchar *data, gu
        }
 
        named = p;
-       attr = mono_object_new (mono_domain_get (), method->klass);
+       attr = mono_object_new_checked (mono_domain_get (), method->klass, error);
+       if (!mono_error_ok (error)) goto fail;
 
        mono_runtime_invoke (method, attr, params, &exc);
        if (exc)
@@ -9043,6 +9067,7 @@ static MonoObject*
 create_custom_attr_data (MonoImage *image, MonoCustomAttrEntry *cattr)
 {
        static MonoMethod *ctor;
+       MonoError error;
        MonoDomain *domain;
        MonoObject *attr;
        void *params [4];
@@ -9053,7 +9078,8 @@ create_custom_attr_data (MonoImage *image, MonoCustomAttrEntry *cattr)
                ctor = mono_class_get_method_from_name (mono_defaults.customattribute_data_class, ".ctor", 4);
 
        domain = mono_domain_get ();
-       attr = mono_object_new (domain, mono_defaults.customattribute_data_class);
+       attr = mono_object_new_checked (domain, mono_defaults.customattribute_data_class, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        params [0] = mono_method_get_object (domain, cattr->ctor, NULL);
        params [1] = mono_assembly_get_object (domain, image->assembly);
        params [2] = (gpointer)&cattr->data;
@@ -10673,7 +10699,8 @@ mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, Mono
                g_assert (System_Reflection_Emit_MarshalAsAttribute);
        }
 
-       minfo = (MonoReflectionMarshalAsAttribute*)mono_object_new (domain, System_Reflection_Emit_MarshalAsAttribute);
+       minfo = (MonoReflectionMarshalAsAttribute*)mono_object_new_checked (domain, System_Reflection_Emit_MarshalAsAttribute, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        minfo->utype = spec->native;
 
        switch (minfo->utype) {

diff --git a/mono/metadata/socket-io.c b/mono/metadata/socket-io.c
index 94d8cb2e98dc13c3795508f4435054a6be026a22..7ddf9d3e4686faa5023da5d0e7bdd947e45d8180 100644 (file)
--- a/mono/metadata/socket-io.c
+++ b/mono/metadata/socket-io.c
@@ -824,6 +824,7 @@ is_ipv4_mapped_any (const struct in6_addr *addr)
 static MonoObject*
 create_object_from_sockaddr(struct sockaddr *saddr, int sa_size, gint32 *error)
 {
+       MonoError merror;
        MonoDomain *domain = mono_domain_get ();
        MonoObject *sockaddr_obj;
        MonoArray *data;
@@ -834,7 +835,8 @@ create_object_from_sockaddr(struct sockaddr *saddr, int sa_size, gint32 *error)
                domain->sockaddr_class=mono_class_from_name (get_socket_assembly (), "System.Net", "SocketAddress");
                g_assert (domain->sockaddr_class);
        }
-       sockaddr_obj=mono_object_new(domain, domain->sockaddr_class);
+       sockaddr_obj=mono_object_new_checked(domain, domain->sockaddr_class, &merror);
+       mono_error_raise_exception (&merror); /* FIXME don't raise here */
        
        /* Locate the SocketAddress data buffer in the object */
        if (!domain->sockaddr_data_field) {
@@ -1910,6 +1912,7 @@ ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (SOCKET sock, g
 #  endif
        socklen_t credsize = sizeof(cred);
 #endif
+       MonoError merror;
        MonoDomain *domain=mono_domain_get();
        MonoObject *obj;
        MonoClass *obj_class;
@@ -1978,8 +1981,9 @@ ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (SOCKET sock, g
                obj_class=mono_class_from_name(get_socket_assembly (),
                                               "System.Net.Sockets",
                                               "LingerOption");
-               obj=mono_object_new(domain, obj_class);
-               
+               obj=mono_object_new_checked(domain, obj_class, &merror);
+               mono_error_raise_exception (&merror); /* FIXME don't raise here */
+
                /* Locate and set the fields "bool enabled" and "int
                 * lingerTime"
                 */
@@ -2026,7 +2030,8 @@ ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (SOCKET sock, g
                obj_class = mono_class_from_name(mono_posix_image,
                                                 "Mono.Posix",
                                                 "PeerCredData");
-               obj = mono_object_new(domain, obj_class);
+               obj = mono_object_new_checked(domain, obj_class, &merror);
+               mono_error_raise_exception (&merror); /* FIXME don't raise here */
                cred_data = (MonoPeerCredData *)obj;
                cred_data->pid = cred.pid;
                cred_data->uid = cred.uid;

diff --git a/mono/metadata/threadpool-ms.c b/mono/metadata/threadpool-ms.c
index 17936001106381195303b13ea8c3ed9b0dc88863..2d68656fe0fb96b84aebb051f56f4aed3226f369 100644 (file)
--- a/mono/metadata/threadpool-ms.c
+++ b/mono/metadata/threadpool-ms.c
@@ -1320,6 +1320,7 @@ MonoAsyncResult *
 mono_threadpool_ms_begin_invoke (MonoDomain *domain, MonoObject *target, MonoMethod *method, gpointer *params)
 {
        static MonoClass *async_call_klass = NULL;
+       MonoError error;
        MonoMethodMessage *message;
        MonoAsyncResult *async_result;
        MonoAsyncCall *async_call;
@@ -1334,7 +1335,9 @@ mono_threadpool_ms_begin_invoke (MonoDomain *domain, MonoObject *target, MonoMet
 
        message = mono_method_call_message_new (method, params, mono_get_delegate_invoke (method->klass), (params != NULL) ? (&async_callback) : NULL, (params != NULL) ? (&state) : NULL);
 
-       async_call = (MonoAsyncCall*) mono_object_new (domain, async_call_klass);
+       async_call = (MonoAsyncCall*) mono_object_new_checked (domain, async_call_klass, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
        MONO_OBJECT_SETREF (async_call, msg, message);
        MONO_OBJECT_SETREF (async_call, state, state);
 

diff --git a/mono/metadata/threads.c b/mono/metadata/threads.c
index 7578499a854a6a8bbcf092343a756fc34bcb5fe7..7ae43c5cd631434e05ae96e9766134715559cfdb 100644 (file)
--- a/mono/metadata/threads.c
+++ b/mono/metadata/threads.c
@@ -3492,12 +3492,15 @@ mono_threads_perform_thread_dump (void)
 static void
 mono_threads_get_thread_dump (MonoArray **out_threads, MonoArray **out_stack_frames)
 {
+       MonoError error;
        ThreadDumpUserData ud;
        MonoInternalThread *thread_array [128];
        MonoDomain *domain = mono_domain_get ();
        MonoDebugSourceLocation *location;
        int tindex, nthreads;
 
+       mono_error_init (&error);
+       
        *out_threads = NULL;
        *out_stack_frames = NULL;
 
@@ -3534,7 +3537,9 @@ mono_threads_get_thread_dump (MonoArray **out_threads, MonoArray **out_stack_fra
                for (i = 0; i < ud.nframes; ++i) {
                        MonoStackFrameInfo *frame = &ud.frames [i];
                        MonoMethod *method = NULL;
-                       MonoStackFrame *sf = (MonoStackFrame *)mono_object_new (domain, mono_defaults.stack_frame_class);
+                       MonoStackFrame *sf = (MonoStackFrame *)mono_object_new_checked (domain, mono_defaults.stack_frame_class, &error);
+                       if (!mono_error_ok (&error))
+                               goto leave;
 
                        sf->native_offset = frame->native_offset;
 
@@ -3564,7 +3569,9 @@ mono_threads_get_thread_dump (MonoArray **out_threads, MonoArray **out_stack_fra
                }
        }
 
+leave:
        g_free (ud.frames);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 }
 
 /**

diff --git a/mono/mini/debugger-agent.c b/mono/mini/debugger-agent.c
index f0b4d4f0201c4985c0232ad5539d67ec0e8655d5..7d0626cbc7f7a1584a394375b62c647089ea21a8 100644 (file)
--- a/mono/mini/debugger-agent.c
+++ b/mono/mini/debugger-agent.c
@@ -6559,8 +6559,11 @@ do_invoke_method (DebuggerTlsData *tls, Buffer *buf, InvokeData *invoke, guint8
                if (!strcmp (m->name, ".ctor")) {
                        if (m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT)
                                return ERR_INVALID_ARGUMENT;
-                       else
-                               this_arg = mono_object_new (domain, m->klass);
+                       else {
+                               MonoError error;
+                               this_arg = mono_object_new_checked (domain, m->klass, &error);
+                               mono_error_assert_ok (&error);
+                       }
                } else {
                        return ERR_INVALID_ARGUMENT;
                }
@@ -7572,6 +7575,7 @@ domain_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
                break;
        }
        case CMD_APPDOMAIN_CREATE_BOXED_VALUE: {
+               MonoError error;
                MonoClass *klass;
                MonoDomain *domain2;
                MonoObject *o;
@@ -7586,7 +7590,8 @@ domain_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
                // FIXME:
                g_assert (domain == domain2);
 
-               o = mono_object_new (domain, klass);
+               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);
                if (err != ERR_NONE)
@@ -8291,9 +8296,11 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint
                break;
        }
        case CMD_TYPE_CREATE_INSTANCE: {
+               MonoError error;
                MonoObject *obj;
 
-               obj = mono_object_new (domain, klass);
+               obj = mono_object_new_checked (domain, klass, &error);
+               mono_error_assert_ok (&error);
                buffer_add_objid (buf, obj);
                break;
        }

diff --git a/mono/mini/jit-icalls.c b/mono/mini/jit-icalls.c
index f049daca1ca497dc995144cef7b6622e7f1aa0ad..f54855a6917ef97e2eb13f8bea6489af8098865b 100644 (file)
--- a/mono/mini/jit-icalls.c
+++ b/mono/mini/jit-icalls.c
@@ -1127,7 +1127,10 @@ mono_helper_newobj_mscorlib (guint32 idx)
                return NULL;
        }
 
-       return mono_object_new (mono_domain_get (), klass);
+       MonoObject *obj = mono_object_new_checked (mono_domain_get (), klass, &error);
+       if (!mono_error_ok (&error))
+               mono_error_set_pending_exception (&error);
+       return obj;
 }
 
 /*

diff --git a/mono/mini/method-to-ir.c b/mono/mini/method-to-ir.c
index 130c62165ba119d480e8dfa29ca411920571123c..b79a812aa9c831014747edbe66b8d537200f9402 100644 (file)
--- a/mono/mini/method-to-ir.c
+++ b/mono/mini/method-to-ir.c
@@ -4195,7 +4195,7 @@ handle_alloc (MonoCompile *cfg, MonoClass *klass, gboolean for_box, int context_
                if (cfg->opt & MONO_OPT_SHARED) {
                        EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
                        iargs [1] = data;
-                       alloc_ftn = mono_object_new;
+                       alloc_ftn = ves_icall_object_new;
                } else {
                        iargs [0] = data;
                        alloc_ftn = ves_icall_object_new_specific;
@@ -4219,7 +4219,7 @@ handle_alloc (MonoCompile *cfg, MonoClass *klass, gboolean for_box, int context_
                EMIT_NEW_DOMAINCONST (cfg, iargs [0]);
                EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
 
-               alloc_ftn = mono_object_new;
+               alloc_ftn = ves_icall_object_new;
        } else if (cfg->compile_aot && cfg->cbb->out_of_line && klass->type_token && klass->image == mono_defaults.corlib && !klass->generic_class) {
                /* This happens often in argument checking code, eg. throw new FooException... */
                /* Avoid relocations and save some space by calling a helper function specialized to mscorlib */
@@ -12586,7 +12586,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
                                MONO_ADD_INS (cfg->cbb, iargs [0]);
                                NEW_CLASSCONST (cfg, iargs [1], klass);
                                MONO_ADD_INS (cfg->cbb, iargs [1]);
-                               *sp++ = mono_emit_jit_icall (cfg, mono_object_new, iargs);
+                               *sp++ = mono_emit_jit_icall (cfg, ves_icall_object_new, iargs);
                                ip += 6;
                                inline_costs += 10 * num_calls++;
                                break;

diff --git a/mono/mini/mini-exceptions.c b/mono/mini/mini-exceptions.c
index 95d110649edeff85b2db8a2d6e7e43c18d4b42eb..34881a2182645d71ab10b939169aeaea8906f606 100644 (file)
--- a/mono/mini/mini-exceptions.c
+++ b/mono/mini/mini-exceptions.c
@@ -657,6 +657,7 @@ mono_exception_walk_trace (MonoException *ex, MonoExceptionFrameWalk func, gpoin
 MonoArray *
 ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info)
 {
+       MonoError error;
        MonoDomain *domain = mono_domain_get ();
        MonoArray *res;
        MonoArray *ta = exc->trace_ips;
@@ -674,7 +675,8 @@ ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info
 
        for (i = skip; i < len; i++) {
                MonoJitInfo *ji;
-               MonoStackFrame *sf = (MonoStackFrame *)mono_object_new (domain, mono_defaults.stack_frame_class);
+               MonoStackFrame *sf = (MonoStackFrame *)mono_object_new_checked (domain, mono_defaults.stack_frame_class, &error);
+               mono_error_raise_exception (&error);
                gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
                gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
                MonoMethod *method;

diff --git a/mono/mini/mini-runtime.c b/mono/mini/mini-runtime.c
index 4640672dd5428c48a861892c3e4888b87b4d4fe4..a72021c481aab13447ccc0eee6d4ed262ace7df1 100644 (file)
--- a/mono/mini/mini-runtime.c
+++ b/mono/mini/mini-runtime.c
@@ -3871,7 +3871,7 @@ register_icalls (void)
        register_icall (mono_get_special_static_data, "mono_get_special_static_data", "ptr int", FALSE);
        register_icall (mono_ldstr, "mono_ldstr", "object ptr ptr int32", FALSE);
        register_icall (mono_helper_stelem_ref_check, "mono_helper_stelem_ref_check", "void object object", FALSE);
-       register_icall (mono_object_new, "mono_object_new", "object ptr ptr", FALSE);
+       register_icall (ves_icall_object_new, "ves_icall_object_new", "object ptr ptr", FALSE);
        register_icall (ves_icall_object_new_specific, "ves_icall_object_new_specific", "object ptr", FALSE);
        register_icall (mono_array_new, "mono_array_new", "object ptr ptr int32", FALSE);
        register_icall (ves_icall_array_new_specific, "ves_icall_array_new_specific", "object ptr int32", FALSE);