-/*
- * marshal.c: Routines for marshaling complex types in P/Invoke methods.
+/**
+ * \file
+ * Routines for marshaling complex types in P/Invoke methods.
*
* Author:
* Paolo Molaro (lupus@ximian.com)
#include "mono/metadata/threads-types.h"
#include "mono/metadata/string-icalls.h"
#include "mono/metadata/attrdefs.h"
-#include "mono/metadata/gc-internals.h"
#include "mono/metadata/cominterop.h"
#include "mono/metadata/remoting.h"
#include "mono/metadata/reflection-internals.h"
static void init_safe_handle (void);
static void*
-ves_icall_marshal_alloc (gulong size);
+ves_icall_marshal_alloc (gsize size);
void
mono_string_utf8_to_builder (MonoStringBuilder *sb, char *text);
mono_icall_end (MonoThreadInfo *info, HandleStackMark *stackmark, MonoError *error);
/* Lazy class loading functions */
-static GENERATE_GET_CLASS_WITH_CACHE (string_builder, System.Text, StringBuilder);
-static GENERATE_GET_CLASS_WITH_CACHE (date_time, System, DateTime);
-static GENERATE_GET_CLASS_WITH_CACHE (fixed_buffer_attribute, System.Runtime.CompilerServices, FixedBufferAttribute);
-static GENERATE_TRY_GET_CLASS_WITH_CACHE (unmanaged_function_pointer_attribute, System.Runtime.InteropServices, UnmanagedFunctionPointerAttribute);
-static GENERATE_TRY_GET_CLASS_WITH_CACHE (icustom_marshaler, System.Runtime.InteropServices, ICustomMarshaler);
+static GENERATE_GET_CLASS_WITH_CACHE (string_builder, "System.Text", "StringBuilder");
+static GENERATE_GET_CLASS_WITH_CACHE (date_time, "System", "DateTime");
+static GENERATE_GET_CLASS_WITH_CACHE (fixed_buffer_attribute, "System.Runtime.CompilerServices", "FixedBufferAttribute");
+static GENERATE_TRY_GET_CLASS_WITH_CACHE (unmanaged_function_pointer_attribute, "System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute");
+static GENERATE_TRY_GET_CLASS_WITH_CACHE (icustom_marshaler, "System.Runtime.InteropServices", "ICustomMarshaler");
/* MonoMethod pointers to SafeHandle::DangerousAddRef and ::DangerousRelease */
static MonoMethod *sh_dangerous_add_ref;
mono_register_jit_icall (func, name, sig, no_wrapper);
}
+static void
+register_icall_no_wrapper (gpointer func, const char *name, const char *sigstr)
+{
+ MonoMethodSignature *sig = mono_create_icall_signature (sigstr);
+
+ mono_register_jit_icall (func, name, sig, TRUE);
+}
+
MonoMethodSignature*
mono_signature_no_pinvoke (MonoMethod *method)
{
register_icall (mono_ftnptr_to_delegate, "mono_ftnptr_to_delegate", "object ptr ptr", FALSE);
register_icall (mono_marshal_asany, "mono_marshal_asany", "ptr object int32 int32", FALSE);
register_icall (mono_marshal_free_asany, "mono_marshal_free_asany", "void object ptr int32 int32", FALSE);
- register_icall (ves_icall_marshal_alloc, "ves_icall_marshal_alloc", "ptr int32", FALSE);
+ register_icall (ves_icall_marshal_alloc, "ves_icall_marshal_alloc", "ptr ptr", FALSE);
register_icall (mono_marshal_free, "mono_marshal_free", "void ptr", FALSE);
register_icall (mono_marshal_set_last_error, "mono_marshal_set_last_error", "void", FALSE);
register_icall (mono_marshal_set_last_error_windows, "mono_marshal_set_last_error_windows", "void int32", FALSE);
register_icall (mono_string_to_byvalstr, "mono_string_to_byvalstr", "void ptr ptr int32", FALSE);
register_icall (mono_string_to_byvalwstr, "mono_string_to_byvalwstr", "void ptr ptr int32", FALSE);
register_icall (g_free, "g_free", "void ptr", FALSE);
- register_icall (mono_object_isinst_icall, "mono_object_isinst_icall", "object object ptr", FALSE);
+ register_icall_no_wrapper (mono_object_isinst_icall, "mono_object_isinst_icall", "object object ptr");
register_icall (mono_struct_delete_old, "mono_struct_delete_old", "void ptr ptr", FALSE);
register_icall (mono_delegate_begin_invoke, "mono_delegate_begin_invoke", "object object ptr", FALSE);
register_icall (mono_delegate_end_invoke, "mono_delegate_end_invoke", "object object ptr", FALSE);
- register_icall (mono_context_get, "mono_context_get", "object", FALSE);
- register_icall (mono_context_set, "mono_context_set", "void object", FALSE);
register_icall (mono_gc_wbarrier_generic_nostore, "wb_generic", "void ptr", FALSE);
register_icall (mono_gchandle_get_target, "mono_gchandle_get_target", "object int32", TRUE);
register_icall (mono_gchandle_new, "mono_gchandle_new", "uint32 object bool", TRUE);
register_icall (mono_threads_detach_coop, "mono_threads_detach_coop", "void ptr ptr", TRUE);
register_icall (mono_icall_start, "mono_icall_start", "ptr ptr ptr", TRUE);
register_icall (mono_icall_end, "mono_icall_end", "void ptr ptr ptr", TRUE);
- register_icall (mono_handle_new, "mono_handle_new", "ptr ptr", TRUE);
+ register_icall (mono_handle_new_full, "mono_handle_new_full", "ptr ptr bool", TRUE);
mono_cominterop_init ();
mono_remoting_init ();
target_handle = mono_gchandle_new_weakref (delegate->target, FALSE);
}
- wrapper = mono_marshal_get_managed_wrapper (method, klass, target_handle);
+ wrapper = mono_marshal_get_managed_wrapper (method, klass, target_handle, &error);
+ if (!is_ok (&error))
+ goto fail;
delegate->delegate_trampoline = mono_compile_method_checked (wrapper, &error);
if (!is_ok (&error))
/**
* mono_string_builder_to_utf8:
- * @sb: the string builder
+ * \param sb the string builder
*
- * Converts to utf8 the contents of the MonoStringBuilder.
+ * Converts to utf8 the contents of the \c MonoStringBuilder .
*
- * Returns: a utf8 string with the contents of the StringBuilder.
+ * \returns a utf8 string with the contents of the \c StringBuilder .
*
* The return value must be released with mono_marshal_free.
*
/**
* mono_string_builder_to_utf16:
- * @sb: the string builder
+ * \param sb the string builder
*
- * Converts to utf16 the contents of the MonoStringBuilder.
+ * Converts to utf16 the contents of the \c MonoStringBuilder .
*
- * Returns: a utf16 string with the contents of the StringBuilder.
+ * Returns: a utf16 string with the contents of the \c StringBuilder .
*
* The return value must be released with mono_marshal_free.
*
/**
* mono_string_to_byvalstr:
- * @dst: Where to store the null-terminated utf8 decoded string.
- * @src: the MonoString to copy.
- * @size: the maximum number of bytes to copy.
+ * \param dst Where to store the null-terminated utf8 decoded string.
+ * \param src the \c MonoString to copy.
+ * \param size the maximum number of bytes to copy.
*
- * Copies the MonoString pointed to by @src as a utf8 string
- * into @dst, it copies at most @size bytes into the destination.
+ * Copies the \c MonoString pointed to by \p src as a utf8 string
+ * into \p dst, it copies at most \p size bytes into the destination.
*/
void
mono_string_to_byvalstr (gpointer dst, MonoString *src, int size)
/**
* mono_string_to_byvalwstr:
- * @dst: Where to store the null-terminated utf16 decoded string.
- * @src: the MonoString to copy.
- * @size: the maximum number of wide characters to copy (each consumes 2 bytes)
+ * \param dst Where to store the null-terminated utf16 decoded string.
+ * \param src the \c MonoString to copy.
+ * \param size the maximum number of wide characters to copy (each consumes 2 bytes)
*
- * Copies the MonoString pointed to by @src as a utf16 string into
- * @dst, it copies at most @size bytes into the destination (including
+ * Copies the \c MonoString pointed to by \p src as a utf16 string into
+ * \p dst, it copies at most \p size bytes into the destination (including
* a terminating 16-bit zero terminator).
*/
void
}
#ifndef DISABLE_REMOTING
- if (delegate->target && mono_object_class (delegate->target) == mono_defaults.transparent_proxy_class) {
+ if (delegate->target && mono_object_is_transparent_proxy (delegate->target)) {
MonoTransparentProxy* tp = (MonoTransparentProxy *)delegate->target;
if (!mono_class_is_contextbound (tp->remote_class->proxy_class) || tp->rp->context != (MonoObject *) mono_context_get ()) {
/* If the target is a proxy, make a direct call. Is proxy's work
case MONO_NATIVE_VBBYREFSTR:
return MONO_MARSHAL_CONV_LPSTR_STR;
case MONO_NATIVE_LPTSTR:
+#ifdef TARGET_WIN32
+ *need_free = FALSE;
+#endif
return MONO_MARSHAL_CONV_LPTSTR_STR;
case MONO_NATIVE_BSTR:
return MONO_MARSHAL_CONV_BSTR_STR;
return mono_mb_create_and_cache_full (cache, key, mb, sig, max_stack, NULL, NULL);
}
+/**
+ * mono_marshal_method_from_wrapper:
+ */
MonoMethod *
mono_marshal_method_from_wrapper (MonoMethod *wrapper)
{
return res;
}
+/**
+ * mono_marshal_get_delegate_begin_invoke:
+ */
MonoMethod *
mono_marshal_get_delegate_begin_invoke (MonoMethod *method)
{
#endif /* DISABLE_JIT */
+/**
+ * mono_marshal_get_delegate_end_invoke:
+ */
MonoMethod *
mono_marshal_get_delegate_end_invoke (MonoMethod *method)
{
return res;
}
-/*
- * the returned method invokes all methods in a multicast delegate.
+/**
+ * mono_marshal_get_delegate_invoke:
+ * The returned method invokes all methods in a multicast delegate.
*/
MonoMethod *
mono_marshal_get_delegate_invoke (MonoMethod *method, MonoDelegate *del)
}
#endif
-/*
- * generates IL code for the runtime invoke function
- * MonoObject *runtime_invoke (MonoObject *this_obj, void **params, MonoObject **exc, void* method)
+/**
+ * mono_marshal_get_runtime_invoke:
+ * Generates IL code for the runtime invoke function:
*
- * we also catch exceptions if exc != null
- * If VIRTUAL is TRUE, then METHOD is invoked virtually on THIS. This is useful since
- * it means that the compiled code for METHOD does not have to be looked up
+ * <code>MonoObject *runtime_invoke (MonoObject *this_obj, void **params, MonoObject **exc, void* method)</code>
+ *
+ * We also catch exceptions if \p exc is not NULL.
+ * If \p virtual is TRUE, then \p method is invoked virtually on \p this. This is useful since
+ * it means that the compiled code for \p method does not have to be looked up
* before calling the runtime invoke wrapper. In this case, the wrapper ignores
- * its METHOD argument.
+ * its \p method argument.
*/
MonoMethod *
mono_marshal_get_runtime_invoke (MonoMethod *method, gboolean virtual_)
MonoMethodSignature *csig;
MonoExceptionClause *clause;
MonoMethodBuilder *mb;
- int pos, posna;
+ int pos;
char *name;
WrapperInfo *info;
mono_mb_emit_byte (mb, CEE_LDNULL);
mono_mb_emit_stloc (mb, 0);
- /* Check for the abort exception */
- mono_mb_emit_ldloc (mb, 1);
- mono_mb_emit_op (mb, CEE_ISINST, mono_defaults.threadabortexception_class);
- posna = mono_mb_emit_short_branch (mb, CEE_BRFALSE_S);
-
- /* Delay the abort exception */
- mono_mb_emit_icall (mb, ves_icall_System_Threading_Thread_ResetAbort);
-
- mono_mb_patch_short_branch (mb, posna);
mono_mb_emit_branch (mb, CEE_LEAVE);
clause->handler_len = mono_mb_get_pos (mb) - clause->handler_offset;
}
#endif
-/*
- * generates IL code for the icall wrapper (the generated method
- * calls the unmanaged code in func)
+/**
+ * mono_marshal_get_icall_wrapper:
+ * Generates IL code for the icall wrapper. The generated method
+ * calls the unmanaged code in \p func.
*/
MonoMethod *
mono_marshal_get_icall_wrapper (MonoMethodSignature *sig, const char *name, gconstpointer func, gboolean check_exceptions)
mono_mb_emit_byte (mb, CEE_POP);
mono_mb_emit_exception_full (mb, "System", "ApplicationException", exception_msg);
- g_free (exception_msg);
break;
case MARSHAL_ACTION_PUSH:
}
}
+/* How the arguments of an icall should be wrapped */
+typedef enum {
+ /* Don't wrap at all, pass the argument as is */
+ ICALL_HANDLES_WRAP_NONE,
+ /* Wrap the argument in an object handle, pass the handle to the icall */
+ ICALL_HANDLES_WRAP_OBJ,
+ /* Wrap the argument in an object handle, pass the handle to the icall,
+ write the value out from the handle when the icall returns */
+ ICALL_HANDLES_WRAP_OBJ_INOUT,
+ /* Wrap the argument (a valuetype reference) in a handle to pin its enclosing object,
+ but pass the raw reference to the icall */
+ ICALL_HANDLES_WRAP_VALUETYPE_REF,
+} IcallHandlesWrap;
+
+typedef struct {
+ IcallHandlesWrap wrap;
+ /* if wrap is NONE or OBJ or VALUETYPE_REF, this is not meaningful.
+ if wrap is OBJ_INOUT it's the local var that holds the MonoObjectHandle.
+ */
+ int handle;
+} IcallHandlesLocal;
+
+/*
+ * Describes how to wrap the given parameter.
+ *
+ */
+static IcallHandlesWrap
+signature_param_uses_handles (MonoMethodSignature *sig, int param)
+{
+ if (MONO_TYPE_IS_REFERENCE (sig->params [param])) {
+ return mono_signature_param_is_out (sig, param) ? ICALL_HANDLES_WRAP_OBJ_INOUT : ICALL_HANDLES_WRAP_OBJ;
+ } else if (mono_type_is_byref (sig->params [param]))
+ return ICALL_HANDLES_WRAP_VALUETYPE_REF;
+ else
+ return ICALL_HANDLES_WRAP_NONE;
+}
+
+
#ifndef DISABLE_JIT
/**
* mono_marshal_emit_native_wrapper:
- * @image: the image to use for looking up custom marshallers
- * @sig: The signature of the native function
- * @piinfo: Marshalling information
- * @mspecs: Marshalling information
- * @aot: whenever the created method will be compiled by the AOT compiler
- * @method: if non-NULL, the pinvoke method to call
- * @check_exceptions: Whenever to check for pending exceptions after the native call
- * @func_param: the function to call is passed as a boxed IntPtr as the first parameter
+ * \param image the image to use for looking up custom marshallers
+ * \param sig The signature of the native function
+ * \param piinfo Marshalling information
+ * \param mspecs Marshalling information
+ * \param aot whenever the created method will be compiled by the AOT compiler
+ * \param method if non-NULL, the pinvoke method to call
+ * \param check_exceptions Whenever to check for pending exceptions after the native call
+ * \param func_param the function to call is passed as a boxed IntPtr as the first parameter
*
- * generates IL code for the pinvoke wrapper, the generated code calls @func.
+ * generates IL code for the pinvoke wrapper, the generated code calls \p func .
*/
void
mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func, gboolean aot, gboolean check_exceptions, gboolean func_param)
/**
* mono_marshal_get_native_wrapper:
- * @method: The MonoMethod to wrap.
- * @check_exceptions: Whenever to check for pending exceptions
+ * \param method The \c MonoMethod to wrap.
+ * \param check_exceptions Whenever to check for pending exceptions
*
- * generates IL code for the pinvoke wrapper (the generated method
- * calls the unmanaged code in piinfo->addr)
+ * Generates IL code for the pinvoke wrapper. The generated method
+ * calls the unmanaged code in \c piinfo->addr.
*/
MonoMethod *
mono_marshal_get_native_wrapper (MonoMethod *method, gboolean check_exceptions, gboolean aot)
int thread_info_var = -1, stack_mark_var = -1, error_var = -1;
MonoMethodSignature *call_sig = csig;
gboolean uses_handles = FALSE;
- gboolean has_outarg_handles = FALSE;
- int *outarg_handle = NULL;
+ gboolean save_handles_to_locals = FALSE;
+ IcallHandlesLocal *handles_locals = NULL;
(void) mono_lookup_internal_call_full (method, &uses_handles);
if (uses_handles) {
MonoMethodSignature *ret;
- /* Add a MonoError argument */
+ /* Add a MonoError argument and figure out which args need to be wrapped in handles */
// FIXME: The stuff from mono_metadata_signature_dup_internal_with_padding ()
ret = mono_metadata_signature_alloc (method->klass->image, csig->param_count + 1);
ret->param_count = csig->param_count + 1;
ret->ret = csig->ret;
+
+ handles_locals = g_new0 (IcallHandlesLocal, csig->param_count);
for (int i = 0; i < csig->param_count; ++i) {
- if (MONO_TYPE_IS_REFERENCE (csig->params[i])) {
+ IcallHandlesWrap w = signature_param_uses_handles (csig, i);
+ handles_locals [i].wrap = w;
+ switch (w) {
+ case ICALL_HANDLES_WRAP_OBJ:
+ case ICALL_HANDLES_WRAP_OBJ_INOUT:
ret->params [i] = mono_class_get_byref_type (mono_class_from_mono_type(csig->params[i]));
- if (mono_signature_param_is_out (csig, i)) {
- has_outarg_handles = TRUE;
- }
- } else
+ if (w == ICALL_HANDLES_WRAP_OBJ_INOUT)
+ save_handles_to_locals = TRUE;
+ break;
+ case ICALL_HANDLES_WRAP_NONE:
+ case ICALL_HANDLES_WRAP_VALUETYPE_REF:
ret->params [i] = csig->params [i];
+ break;
+ default:
+ g_assert_not_reached ();
+ }
}
+ /* Add MonoError* param */
ret->params [csig->param_count] = &mono_get_intptr_class ()->byval_arg;
+ ret->pinvoke = csig->pinvoke;
+
call_sig = ret;
}
stack_mark_var = mono_mb_add_local (mb, &handle_stack_mark_class->byval_arg);
error_var = mono_mb_add_local (mb, &error_class->byval_arg);
- if (has_outarg_handles) {
- outarg_handle = g_new0 (int, sig->param_count);
-
+ if (save_handles_to_locals) {
/* add a local var to hold the handles for each out arg */
for (int i = 0; i < sig->param_count; ++i) {
- if (mono_signature_param_is_out (sig, i) && MONO_TYPE_IS_REFERENCE (sig->params[i])) {
- outarg_handle[i] = mono_mb_add_local (mb, sig->params[i]);
- } else if (outarg_handle != NULL)
- outarg_handle[i] = -1;
+ int j = i + sig->hasthis;
+ switch (handles_locals[j].wrap) {
+ case ICALL_HANDLES_WRAP_NONE:
+ case ICALL_HANDLES_WRAP_OBJ:
+ case ICALL_HANDLES_WRAP_VALUETYPE_REF:
+ handles_locals [j].handle = -1;
+ break;
+ case ICALL_HANDLES_WRAP_OBJ_INOUT:
+ handles_locals [j].handle = mono_mb_add_local (mb, sig->params [i]);
+ break;
+ default:
+ g_assert_not_reached ();
+ }
}
}
}
if (sig->hasthis) {
mono_mb_emit_byte (mb, CEE_LDARG_0);
- mono_mb_emit_icall (mb, mono_handle_new);
+ /* TODO support adding wrappers to non-static struct methods */
+ g_assert (!mono_class_is_valuetype(mono_method_get_class (method)));
+ mono_mb_emit_byte (mb, CEE_LDC_I4_0);
+ mono_mb_emit_icall (mb, mono_handle_new_full);
}
for (i = 0; i < sig->param_count; i++) {
- /* load each argument. object reference arguments get wrapped in handles */
-
- if (!MONO_TYPE_IS_REFERENCE (sig->params [i])) {
- mono_mb_emit_ldarg (mb, i + sig->hasthis);
- } else {
- if (outarg_handle && outarg_handle[i] != -1) {
- /* handleI = argI = mono_handle_new (NULL) */
- mono_mb_emit_byte (mb, CEE_LDNULL);
- mono_mb_emit_icall (mb, mono_handle_new);
- /* tmp = argI */
- mono_mb_emit_byte (mb, CEE_DUP);
- /* handleI = tmp */
- mono_mb_emit_stloc (mb, outarg_handle[i]);
- } else {
- /* argI = mono_handle_new (argI_raw) */
- mono_mb_emit_ldarg (mb, i + sig->hasthis);
- mono_mb_emit_icall (mb, mono_handle_new);
- }
+ /* load each argument. references into the managed heap get wrapped in handles */
+ int j = i + sig->hasthis;
+ switch (handles_locals[j].wrap) {
+ case ICALL_HANDLES_WRAP_NONE:
+ mono_mb_emit_ldarg (mb, j);
+ break;
+ case ICALL_HANDLES_WRAP_OBJ:
+ /* argI = mono_handle_new_full (argI_raw, FALSE) */
+ mono_mb_emit_ldarg (mb, j);
+ mono_mb_emit_byte (mb, CEE_LDC_I4_0);
+ mono_mb_emit_icall (mb, mono_handle_new_full);
+ break;
+ case ICALL_HANDLES_WRAP_OBJ_INOUT:
+ /* handleI = argI = mono_handle_new_full (NULL, FALSE) */
+ mono_mb_emit_byte (mb, CEE_LDNULL);
+ mono_mb_emit_byte (mb, CEE_LDC_I4_0);
+ mono_mb_emit_icall (mb, mono_handle_new_full);
+ /* tmp = argI */
+ mono_mb_emit_byte (mb, CEE_DUP);
+ /* handleI = tmp */
+ mono_mb_emit_stloc (mb, handles_locals[j].handle);
+ break;
+ case ICALL_HANDLES_WRAP_VALUETYPE_REF:
+ /* (void) mono_handle_new_full (argI, TRUE); argI */
+ mono_mb_emit_ldarg (mb, j);
+ mono_mb_emit_byte (mb, CEE_DUP);
+ mono_mb_emit_byte (mb, CEE_LDC_I4_1);
+ mono_mb_emit_icall (mb, mono_handle_new_full);
+ mono_mb_emit_byte (mb, CEE_POP);
+#if 0
+ fprintf (stderr, " Method %s.%s.%s has byref valuetype argument %d\n", method->klass->name_space, method->klass->name, method->name, i);
+#endif
+ break;
+ default:
+ g_assert_not_reached ();
}
}
mono_mb_emit_ldloc_addr (mb, error_var);
mono_mb_emit_byte (mb, CEE_LDIND_REF);
mono_mb_patch_branch (mb, pos);
}
- if (outarg_handle != NULL) {
+ if (save_handles_to_locals) {
for (i = 0; i < sig->param_count; i++) {
- if (outarg_handle[i] != -1) {
+ int j = i + sig->hasthis;
+ switch (handles_locals [j].wrap) {
+ case ICALL_HANDLES_WRAP_NONE:
+ case ICALL_HANDLES_WRAP_OBJ:
+ case ICALL_HANDLES_WRAP_VALUETYPE_REF:
+ break;
+ case ICALL_HANDLES_WRAP_OBJ_INOUT:
/* *argI_raw = MONO_HANDLE_RAW (handleI) */
/* argI_raw */
- mono_mb_emit_ldarg (mb, i + sig->hasthis);
+ mono_mb_emit_ldarg (mb, j);
/* handleI */
- mono_mb_emit_ldloc (mb, outarg_handle[i]);
+ mono_mb_emit_ldloc (mb, handles_locals [j].handle);
/* MONO_HANDLE_RAW(handleI) */
mono_mb_emit_ldflda (mb, MONO_HANDLE_PAYLOAD_OFFSET (MonoObject));
mono_mb_emit_byte (mb, CEE_LDIND_REF);
/* *argI_raw = MONO_HANDLE_RAW(handleI) */
mono_mb_emit_byte (mb, CEE_STIND_REF);
+ break;
+ default:
+ g_assert_not_reached ();
}
}
- g_free (outarg_handle);
- outarg_handle = NULL;
}
+ g_free (handles_locals);
+
mono_mb_emit_ldloc (mb, thread_info_var);
mono_mb_emit_ldloc_addr (mb, stack_mark_var);
mono_mb_emit_ldloc_addr (mb, error_var);
/**
* mono_marshal_get_native_func_wrapper:
- * @image: The image to use for memory allocation and for looking up custom marshallers.
- * @sig: The signature of the function
- * @func: The native function to wrap
+ * \param image The image to use for memory allocation and for looking up custom marshallers.
+ * \param sig The signature of the function
+ * \param func The native function to wrap
*
- * Returns a wrapper method around native functions, similar to the pinvoke
+ * \returns a wrapper method around native functions, similar to the pinvoke
* wrapper.
*/
MonoMethod *
}
}
-/*
- * generates IL code to call managed methods from unmanaged code
- * If target_handle==0, the wrapper info will be a WrapperInfo structure.
+/**
+ * mono_marshal_get_managed_wrapper:
+ * Generates IL code to call managed methods from unmanaged code
+ * If \p target_handle is \c 0, the wrapper info will be a \c WrapperInfo structure.
*/
MonoMethod *
-mono_marshal_get_managed_wrapper (MonoMethod *method, MonoClass *delegate_klass, uint32_t target_handle)
+mono_marshal_get_managed_wrapper (MonoMethod *method, MonoClass *delegate_klass, uint32_t target_handle, MonoError *error)
{
- MonoError error;
MonoMethodSignature *sig, *csig, *invoke_sig;
MonoMethodBuilder *mb;
MonoMethod *res, *invoke;
EmitMarshalContext m;
g_assert (method != NULL);
- g_assert (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL));
+ error_init (error);
+
+ if (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
+ mono_error_set_invalid_program (error, "Failed because method (%s) marked PInvokeCallback (managed method) and extern (unmanaged) simultaneously.", mono_method_full_name (method, TRUE));
+ return NULL;
+ }
/*
* FIXME: Should cache the method+delegate type pair, since the same method
* contents of the attribute without constructing it, as that might not be
* possible when running in cross-compiling mode.
*/
- cinfo = mono_custom_attrs_from_class_checked (delegate_klass, &error);
- mono_error_assert_ok (&error);
+ cinfo = mono_custom_attrs_from_class_checked (delegate_klass, error);
+ mono_error_assert_ok (error);
attr = NULL;
if (cinfo) {
for (i = 0; i < cinfo->num_attrs; ++i) {
#endif /* DISABLE_JIT */
-/*
- * This does the equivalent of mono_object_castclass_with_cache.
+/**
+ * mono_marshal_get_castclass_with_cache:
+ * This does the equivalent of \c mono_object_castclass_with_cache.
*/
MonoMethod *
mono_marshal_get_castclass_with_cache (void)
if (mono_error_set_pending_exception (&error))
return NULL;
-#ifndef DISABLE_REMOTING
- if (obj->vtable->klass == mono_defaults.transparent_proxy_class)
+ if (mono_object_is_transparent_proxy (obj))
return isinst;
-#endif
uintptr_t cache_update = (uintptr_t)obj->vtable;
if (!isinst)
return isinst;
}
-/*
- * This does the equivalent of mono_object_isinst_with_cache.
+/**
+ * mono_marshal_get_isinst_with_cache:
+ * This does the equivalent of \c mono_marshal_isinst_with_cache.
*/
MonoMethod *
mono_marshal_get_isinst_with_cache (void)
/**
* mono_marshal_get_struct_to_ptr:
- * @klass:
+ * \param klass \c MonoClass
*
- * generates IL code for StructureToPtr (object structure, IntPtr ptr, bool fDeleteOld)
+ * Generates IL code for <code>StructureToPtr (object structure, IntPtr ptr, bool fDeleteOld)</code>
*/
MonoMethod *
mono_marshal_get_struct_to_ptr (MonoClass *klass)
/**
* mono_marshal_get_ptr_to_struct:
- * @klass:
- *
- * generates IL code for PtrToStructure (IntPtr src, object structure)
+ * \param klass \c MonoClass
+ * Generates IL code for <code>PtrToStructure (IntPtr src, object structure)</code>
*/
MonoMethod *
mono_marshal_get_ptr_to_struct (MonoClass *klass)
return res;
}
-/*
- * generates IL code for the synchronized wrapper: the generated method
- * calls METHOD while locking 'this' or the parent type.
+/**
+ * mono_marshal_get_synchronized_wrapper:
+ * Generates IL code for the synchronized wrapper: the generated method
+ * calls \p method while locking \c this or the parent type.
*/
MonoMethod *
mono_marshal_get_synchronized_wrapper (MonoMethod *method)
}
-/*
- * the returned method calls 'method' unboxing the this argument
+/**
+ * mono_marshal_get_unbox_wrapper:
+ * The returned method calls \p method unboxing the \c this argument.
*/
MonoMethod *
mono_marshal_get_unbox_wrapper (MonoMethod *method)
STELEMREF_OBJECT, /*no check at all*/
STELEMREF_SEALED_CLASS, /*check vtable->klass->element_type */
STELEMREF_CLASS, /*only the klass->parents check*/
+ STELEMREF_CLASS_SMALL_IDEPTH, /* like STELEMREF_CLASS bit without the idepth check */
STELEMREF_INTERFACE, /*interfaces without variant generic arguments. */
STELEMREF_COMPLEX, /*arrays, MBR or types with variant generic args - go straight to icalls*/
STELEMREF_KIND_COUNT
};
static const char *strelemref_wrapper_name[] = {
- "object", "sealed_class", "class", "interface", "complex"
+ "object", "sealed_class", "class", "class_small_idepth", "interface", "complex"
};
static gboolean
return STELEMREF_COMPLEX;
if (mono_class_is_sealed (element_class))
return STELEMREF_SEALED_CLASS;
+ if (element_class->idepth <= MONO_DEFAULT_SUPERTABLE_SIZE)
+ return STELEMREF_CLASS_SMALL_IDEPTH;
+
return STELEMREF_CLASS;
}
mono_mb_emit_byte (mb, CEE_RET);
break;
- case STELEMREF_COMPLEX:
+ case STELEMREF_COMPLEX: {
+ int b_fast;
/*
<ldelema (bound check)>
if (!value)
*/
aklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
+ vklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
array_slot_addr = mono_mb_add_local (mb, &mono_defaults.object_class->this_arg);
#if 0
/* aklass = array->vtable->klass->element_class */
load_array_class (mb, aklass);
+ /* vklass = value->vtable->klass */
+ load_value_class (mb, vklass);
+
+ /* fastpath */
+ mono_mb_emit_ldloc (mb, vklass);
+ mono_mb_emit_ldloc (mb, aklass);
+ b_fast = mono_mb_emit_branch (mb, CEE_BEQ);
/*if (mono_object_isinst (value, aklass)) */
mono_mb_emit_ldarg (mb, 2);
/* do_store: */
mono_mb_patch_branch (mb, b1);
+ mono_mb_patch_branch (mb, b_fast);
mono_mb_emit_ldloc (mb, array_slot_addr);
mono_mb_emit_ldarg (mb, 2);
mono_mb_emit_byte (mb, CEE_STIND_REF);
mono_mb_emit_exception (mb, "ArrayTypeMismatchException", NULL);
break;
-
+ }
case STELEMREF_SEALED_CLASS:
/*
<ldelema (bound check)>
vklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
array_slot_addr = mono_mb_add_local (mb, &mono_defaults.object_class->this_arg);
-
/* ldelema (implicit bound check) */
load_array_element_address (mb);
mono_mb_emit_stloc (mb, array_slot_addr);
mono_mb_emit_exception (mb, "ArrayTypeMismatchException", NULL);
break;
- case STELEMREF_CLASS:
+ case STELEMREF_CLASS: {
/*
the method:
<ldelema (bound check)>
/* vklass = value->vtable->klass */
load_value_class (mb, vklass);
- /*if (mono_object_isinst (value, aklass)) */
- mono_mb_emit_ldarg (mb, 2);
- mono_mb_emit_ldloc (mb, aklass);
- mono_mb_emit_icall (mb, mono_object_isinst_icall);
- b2 = mono_mb_emit_branch (mb, CEE_BRFALSE);
-
/* if (vklass->idepth < aklass->idepth) goto failue */
mono_mb_emit_ldloc (mb, vklass);
mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoClass, idepth));
mono_mb_emit_byte (mb, CEE_RET);
/* do_exception: */
- mono_mb_patch_branch (mb, b2);
mono_mb_patch_branch (mb, b3);
mono_mb_patch_branch (mb, b4);
+ mono_mb_emit_exception (mb, "ArrayTypeMismatchException", NULL);
+ break;
+ }
+
+ case STELEMREF_CLASS_SMALL_IDEPTH:
+ /*
+ the method:
+ <ldelema (bound check)>
+ if (!value)
+ goto do_store;
+
+ aklass = array->vtable->klass->element_class;
+ vklass = value->vtable->klass;
+
+ if (vklass->supertypes [aklass->idepth - 1] != aklass)
+ goto do_exception;
+
+ do_store:
+ *array_slot_addr = value;
+ return;
+
+ long:
+ throw new ArrayTypeMismatchException ();
+ */
+ aklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
+ vklass = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
+ array_slot_addr = mono_mb_add_local (mb, &mono_defaults.object_class->this_arg);
+
+ /* ldelema (implicit bound check) */
+ load_array_element_address (mb);
+ mono_mb_emit_stloc (mb, array_slot_addr);
+
+ /* if (!value) goto do_store */
+ mono_mb_emit_ldarg (mb, 2);
+ b1 = mono_mb_emit_branch (mb, CEE_BRFALSE);
+
+ /* aklass = array->vtable->klass->element_class */
+ load_array_class (mb, aklass);
+
+ /* vklass = value->vtable->klass */
+ load_value_class (mb, vklass);
+
+ /* if (vklass->supertypes [aklass->idepth - 1] != aklass) goto failure */
+ mono_mb_emit_ldloc (mb, vklass);
+ mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoClass, supertypes));
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
+
+ mono_mb_emit_ldloc (mb, aklass);
+ mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoClass, idepth));
+ mono_mb_emit_byte (mb, CEE_LDIND_U2);
+ mono_mb_emit_icon (mb, 1);
+ mono_mb_emit_byte (mb, CEE_SUB);
+ mono_mb_emit_icon (mb, sizeof (void*));
+ mono_mb_emit_byte (mb, CEE_MUL);
+ mono_mb_emit_byte (mb, CEE_ADD);
+ mono_mb_emit_byte (mb, CEE_LDIND_I);
+
+ mono_mb_emit_ldloc (mb, aklass);
+ b4 = mono_mb_emit_branch (mb, CEE_BNE_UN);
+
+ /* do_store: */
+ mono_mb_patch_branch (mb, b1);
+ mono_mb_emit_ldloc (mb, array_slot_addr);
+ mono_mb_emit_ldarg (mb, 2);
+ mono_mb_emit_byte (mb, CEE_STIND_REF);
+ mono_mb_emit_byte (mb, CEE_RET);
+
+ /* do_exception: */
+ mono_mb_patch_branch (mb, b4);
+
mono_mb_emit_exception (mb, "ArrayTypeMismatchException", NULL);
break;
return res;
}
+/**
+ * mono_marshal_get_stelemref:
+ */
MonoMethod*
mono_marshal_get_stelemref (void)
{
/**
* mono_marshal_get_array_address:
- * @rank: rank of the array type
- * @elem_size: size in bytes of an element of an array.
+ * \param rank rank of the array type
+ * \param elem_size size in bytes of an element of an array.
*
* Returns a MonoMethod that implements the code to get the address
- * of an element in a multi-dimenasional array of @rank dimensions.
+ * of an element in a multi-dimenasional array of \p rank dimensions.
* The returned method takes an array as the first argument and then
- * @rank indexes for the @rank dimensions.
+ * \p rank indexes for the \p rank dimensions.
* If ELEM_SIZE is 0, read the array size from the array object.
*/
MonoMethod*
}
#endif
+/**
+ * mono_marshal_alloc:
+ */
void*
-mono_marshal_alloc (gulong size, MonoError *error)
+mono_marshal_alloc (gsize size, MonoError *error)
{
gpointer res;
- mono_error_init (error);
+ error_init (error);
res = mono_marshal_alloc_co_task_mem (size);
if (!res)
/* This is a JIT icall, it sets the pending exception and returns NULL on error. */
static void*
-ves_icall_marshal_alloc (gulong size)
+ves_icall_marshal_alloc (gsize size)
{
MonoError error;
void *ret = mono_marshal_alloc (size, &error);
}
#endif
+/**
+ * mono_marshal_free:
+ */
void
mono_marshal_free (gpointer ptr)
{
mono_marshal_free_co_task_mem (ptr);
}
+/**
+ * mono_marshal_free_array:
+ */
void
mono_marshal_free_array (gpointer *ptr, int size)
{
* mono_marshal_set_last_error:
*
* This function is invoked to set the last error value from a P/Invoke call
- * which has SetLastError set.
+ * which has \c SetLastError set.
*/
void
mono_marshal_set_last_error (void)
{
MonoError error;
MonoString *result = NULL;
- mono_error_init (&error);
+ error_init (&error);
if (ptr == NULL)
mono_error_set_argument_null (&error, "ptr", "");
else
MonoString *res = NULL;
MonoDomain *domain = mono_domain_get ();
- mono_error_init (&error);
+ error_init (&error);
if (ptr == NULL) {
res = NULL;
MonoMethod *method;
gpointer pa [2];
- mono_error_init (error);
+ error_init (error);
method = mono_marshal_get_ptr_to_struct (dst->vtable->klass);
/**
* mono_marshal_load_type_info:
*
- * Initialize klass::marshal_info using information from metadata. This function can
+ * Initialize \c klass::marshal_info using information from metadata. This function can
* recursively call itself, and the caller is responsible to avoid that by calling
- * mono_marshal_is_loading_type_info () beforehand.
+ * \c mono_marshal_is_loading_type_info beforehand.
*
* LOCKING: Acquires the loader lock.
*/
/**
* mono_class_native_size:
- * @klass: a class
- *
- * Returns: the native size of an object instance (when marshaled
+ * \param klass a class
+ * \returns the native size of an object instance (when marshaled
* to unmanaged code)
*/
gint32
return 0;
}
+/**
+ * mono_marshal_type_size:
+ */
gint32
mono_marshal_type_size (MonoType *type, MonoMarshalSpec *mspec, guint32 *align,
gboolean as_field, gboolean unicode)
return 0;
}
-/* This is a JIT icall, it sets the pending exception and return NULL on error */
+/**
+ * mono_marshal_asany:
+ * This is a JIT icall, it sets the pending exception and returns NULL on error.
+ */
gpointer
mono_marshal_asany (MonoObject *o, MonoMarshalNative string_encoding, int param_attrs)
{
return NULL;
}
-/* This is a JIT icall, it sets the pending exception */
+/**
+ * mono_marshal_free_asany:
+ * This is a JIT icall, it sets the pending exception
+ */
void
mono_marshal_free_asany (MonoObject *o, gpointer ptr, MonoMarshalNative string_encoding, int param_attrs)
{
}
}
+/*
+ * mono_marshal_get_generic_array_helper:
+ *
+ * Return a wrapper which is used to implement the implicit interfaces on arrays.
+ * The wrapper routes calls to METHOD, which is one of the InternalArray_ methods in Array.
+ */
MonoMethod *
-mono_marshal_get_generic_array_helper (MonoClass *klass, MonoClass *iface, gchar *name, MonoMethod *method)
+mono_marshal_get_generic_array_helper (MonoClass *klass, gchar *name, MonoMethod *method)
{
MonoMethodSignature *sig, *csig;
MonoMethodBuilder *mb;
MonoThreadInfo *info = mono_thread_info_current ();
mono_stack_mark_init (info, stackmark);
- mono_error_init (error);
+ error_init (error);
return info;
}
mono_icall_end (MonoThreadInfo *info, HandleStackMark *stackmark, MonoError *error)
{
mono_stack_mark_pop (info, stackmark);
- mono_error_set_pending_exception (error);
+ if (G_UNLIKELY (!is_ok (error)))
+ mono_error_set_pending_exception (error);
}
projects / mono.git / blobdiff