#undef MONO_SIZEOF_SUNPATH
#undef NEED_LINK_UNLINK
#undef PTHREAD_POINTER_ID
+#undef MONO_USE_EXC_TABLES
;;
*-*-linux*)
platform_win32=no
- CPPFLAGS="$CPPFLAGS -DGC_LINUX_THREADS -D_GNU_SOURCE -D_REENTRANT"
+ AC_DEFINE(MONO_USE_EXC_TABLES)
+ CPPFLAGS="$CPPFLAGS -DGC_LINUX_THREADS -D_GNU_SOURCE -D_REENTRANT -fexceptions"
libdl="-ldl"
;;
*-*-solaris*)
catch handler: receives the exception object in ECX. They store that
object into a local variable, so that rethrow can access the object.
+
+
+gcc support for Exceptions
+==========================
+
+gcc supports exceptions in files compiled with the -fexception option. gcc
+generates DWARF exceptions tables in that case, so it is possible to unwind the
+stack. The method to read those exception tables is contained in libgcc.a, and
+in newer versions of glibc (glibc 2.2.5 for example), and it is called
+__frame_state_for(). Another usable glibc function is backtrace_symbols() which
+returns the function name corresponding to a code address.
+
+We dynamically check if those features are available using g_module_symbol(),
+and we use them only when available. If not available we use the LMF as
+fallback.
+
+Using gcc exception information prevents us from saving the LMF at each native
+call, so this is a way to speed up native calls. This is especially valuable
+for internal calls, because we can make sure that all internal calls are
+compiled with -fexceptions (we compile the whole mono runtime with that
+option).
+
+All native function are able to call function without exception tables, and so
+we are unable to restore all caller saved registers if an exception is raised
+in such function. Well, its possible if the previous function already saves all
+registers. So we only omit the the LMF if a function has an exception table
+able to restore all caller saved registers.
+
+One problem is that gcc almost never saves all caller saved registers, because
+it is just unnecessary in normal situations. But there is a trick forcing gcc
+to save all register, we just need to call __builtin_unwind_init() at the
+beginning of a function. That way gcc generates code to save all caller saved
+register on the stack.
+
+
+
+
+
\ No newline at end of file
+2002-11-28 Dietmar Maurer <dietmar@ximian.com>
+
+ * exception.c (x86_unwind_native_frame): support exceptions inside
+ native code using gcc generated exception tables (-fexception).
+
+2002-11-19 Dietmar Maurer <dietmar@ximian.com>
+
+ * exception.c: include some code from Zoltan Varga, but modified
+ it slightly.
+
2002-11-27 Dietmar Maurer <dietmar@ximian.com>
* exception.c: massive code cleanups. The code is still
#define MONO_CONTEXT_GET_IP(ctx) ((gpointer)((ctx)->SC_EIP))
#define MONO_CONTEXT_GET_BP(ctx) ((gpointer)((ctx)->SC_EBP))
+#ifdef MONO_USE_EXC_TABLES
+
+/*************************************/
+/* STACK UNWINDING STUFF */
+/*************************************/
+
+/* These definitions are from unwind-dw2.c in glibc 2.2.5 */
+
+/* For x86 */
+#define DWARF_FRAME_REGISTERS 17
+
+typedef struct frame_state
+{
+ void *cfa;
+ void *eh_ptr;
+ long cfa_offset;
+ long args_size;
+ long reg_or_offset[DWARF_FRAME_REGISTERS+1];
+ unsigned short cfa_reg;
+ unsigned short retaddr_column;
+ char saved[DWARF_FRAME_REGISTERS+1];
+} frame_state;
+
+static long
+get_sigcontext_reg (struct sigcontext *ctx, int dwarf_regnum)
+{
+ switch (dwarf_regnum) {
+ case X86_EAX:
+ return ctx->eax;
+ case X86_EBX:
+ return ctx->ebx;
+ case X86_ECX:
+ return ctx->ecx;
+ case X86_EDX:
+ return ctx->edx;
+ case X86_ESI:
+ return ctx->esi;
+ case X86_EDI:
+ return ctx->edi;
+ case X86_EBP:
+ return ctx->ebp;
+ case X86_ESP:
+ return ctx->esp;
+ default:
+ g_assert_not_reached ();
+ }
+
+ return 0;
+}
+
+static void
+set_sigcontext_reg (struct sigcontext *ctx, int dwarf_regnum, long value)
+{
+ switch (dwarf_regnum) {
+ case X86_EAX:
+ ctx->eax = value;
+ break;
+ case X86_EBX:
+ ctx->ebx = value;
+ break;
+ case X86_ECX:
+ ctx->ecx = value;
+ break;
+ case X86_EDX:
+ ctx->edx = value;
+ break;
+ case X86_ESI:
+ ctx->esi = value;
+ break;
+ case X86_EDI:
+ ctx->edi = value;
+ break;
+ case X86_EBP:
+ ctx->ebp = value;
+ break;
+ case X86_ESP:
+ ctx->esp = value;
+ break;
+ case 8:
+ ctx->eip = value;
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+typedef struct frame_state * (*framesf) (void *, struct frame_state *);
+
+static framesf frame_state_for = NULL;
+
+static gboolean inited = FALSE;
+
+typedef char ** (*get_backtrace_symbols_type) (void *__const *__array, int __size);
+
+static get_backtrace_symbols_type get_backtrace_symbols = NULL;
+
+static void
+init_frame_state_for (void)
+{
+ GModule *module;
+
+ /*
+ * There are two versions of __frame_state_for: one in libgcc.a and the
+ * other in glibc.so. We need the version from glibc.
+ * For more info, see this:
+ * http://gcc.gnu.org/ml/gcc/2002-08/msg00192.html
+ */
+ if ((module = g_module_open ("libc.so.6", G_MODULE_BIND_LAZY))) {
+
+ if (!g_module_symbol (module, "__frame_state_for", (gpointer*)&frame_state_for))
+ frame_state_for = NULL;
+
+ if (!g_module_symbol (module, "backtrace_symbols", (gpointer*)&get_backtrace_symbols)) {
+ get_backtrace_symbols = NULL;
+ frame_state_for = NULL;
+ }
+
+ g_module_close (module);
+ }
+
+ inited = TRUE;
+}
+
+/* mono_has_unwind_info:
+ *
+ * Tests if a function has an DWARF exception table able to restore
+ * all caller saved registers.
+ */
+gboolean
+mono_has_unwind_info (MonoMethod *method)
+{
+ struct frame_state state_in;
+ struct frame_state *res;
+
+ if (!inited)
+ init_frame_state_for ();
+
+ if (!frame_state_for)
+ return FALSE;
+
+ g_assert (method->addr);
+
+ memset (&state_in, 0, sizeof (state_in));
+
+ /* offset 10 is just a guess, but it works for all methods tested */
+ if ((res = frame_state_for ((char *)method->addr + 10, &state_in))) {
+
+ if (res->saved [X86_EBX] != 1 ||
+ res->saved [X86_EDI] != 1 ||
+ res->saved [X86_EBP] != 1 ||
+ res->saved [X86_ESI] != 1) {
+ return FALSE;
+ }
+ return TRUE;
+ } else
+ return FALSE;
+}
+
+struct stack_frame
+{
+ void *next;
+ void *return_address;
+};
+
+static MonoJitInfo *
+x86_unwind_native_frame (MonoDomain *domain, MonoJitTlsData *jit_tls, struct sigcontext *ctx,
+ struct sigcontext *new_ctx, MonoLMF *lmf, char **trace)
+{
+ struct stack_frame *frame;
+ gpointer max_stack;
+ MonoJitInfo *ji;
+ struct frame_state state_in;
+ struct frame_state *res;
+
+ if (trace)
+ *trace = NULL;
+
+ if (!inited)
+ init_frame_state_for ();
+
+ if (!frame_state_for)
+ return FALSE;
+
+ frame = MONO_CONTEXT_GET_BP (ctx);
+
+ max_stack = lmf ? lmf : jit_tls->end_of_stack;
+
+ *new_ctx = *ctx;
+
+ memset (&state_in, 0, sizeof (state_in));
+
+ while ((gpointer)frame->next < (gpointer)max_stack) {
+ gpointer ip, addr = frame->return_address;
+ void *cfa;
+ char *tmp, **symbols;
+
+ if (trace) {
+ ip = MONO_CONTEXT_GET_IP (new_ctx);
+ symbols = get_backtrace_symbols (&ip, 1);
+ if (*trace)
+ tmp = g_strdup_printf ("%s\nin (unmanaged) %s", *trace, symbols [0]);
+ else
+ tmp = g_strdup_printf ("in (unmanaged) %s", symbols [0]);
+
+ free (symbols);
+ g_free (*trace);
+ *trace = tmp;
+ }
+
+ if ((res = frame_state_for (addr, &state_in))) {
+ int i;
+
+ cfa = (gint8*) (get_sigcontext_reg (new_ctx, res->cfa_reg) + res->cfa_offset);
+ frame = (struct stack_frame *)((gint8*)cfa - 8);
+ for (i = 0; i < DWARF_FRAME_REGISTERS + 1; i++) {
+ int how = res->saved[i];
+ long val;
+ g_assert ((how == 0) || (how == 1));
+
+ if (how == 1) {
+ val = * (long*) ((gint8*)cfa + res->reg_or_offset[i]);
+ set_sigcontext_reg (new_ctx, i, val);
+ }
+ }
+ new_ctx->esp = (long)cfa;
+
+ if (res->saved [X86_EBX] == 1 &&
+ res->saved [X86_EDI] == 1 &&
+ res->saved [X86_EBP] == 1 &&
+ res->saved [X86_ESI] == 1 &&
+ (ji = mono_jit_info_table_find (domain, frame->return_address))) {
+ //printf ("FRAME CFA %s\n", mono_method_full_name (ji->method, TRUE));
+ return ji;
+ }
+
+ } else {
+ //printf ("FRAME %p %p %p\n", frame, MONO_CONTEXT_GET_IP (new_ctx), mono_jit_info_table_find (domain, MONO_CONTEXT_GET_IP (new_ctx)));
+
+ MONO_CONTEXT_SET_IP (new_ctx, frame->return_address);
+ frame = frame->next;
+ MONO_CONTEXT_SET_BP (new_ctx, frame);
+
+ /* stop if we detect an unexpected managed frame */
+ if (mono_jit_info_table_find (domain, frame->return_address)) {
+ if (trace) {
+ g_free (*trace);
+ *trace = NULL;
+ }
+ return NULL;
+ }
+ }
+ }
+
+ if (!lmf)
+ g_assert_not_reached ();
+
+ if (trace) {
+ g_free (*trace);
+ *trace = NULL;
+ }
+ return NULL;
+}
+
+#endif
+
/*
* arch_get_restore_context:
*
if (native_offset)
*native_offset = -1;
- *new_ctx = *ctx;
-
if (ji != NULL) {
char *source_location, *tmpaddr, *fname;
gint32 address, iloffset;
int offset;
+ *new_ctx = *ctx;
+
if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
/* remove any unused lmf */
*lmf = (*lmf)->previous_lmf;
new_ctx->SC_EBP = *((int *)ctx->SC_EBP);
return ji;
-
+#ifdef MONO_USE_EXC_TABLES
+ } else if ((ji = x86_unwind_native_frame (domain, jit_tls, ctx, new_ctx, *lmf, trace))) {
+ return ji;
+#endif
} else if (*lmf) {
+ *new_ctx = *ctx;
+
if (trace)
*trace = g_strdup_printf ("in (unmanaged) %s", mono_method_full_name ((*lmf)->method, TRUE));
return ji;
- } else {
- /* no lmf available - usually a serious error? */
- new_ctx->SC_EBP = (unsigned long)jit_tls->end_of_stack;
- return NULL;
}
- g_assert_not_reached ();
+ return NULL;
}
MonoArray *
ji = mono_arch_find_jit_info (domain, jit_tls, ctx, &new_ctx,
test_only ? &trace : NULL, &lmf, NULL);
- g_assert (ji);
+ if (!ji) {
+ g_warning ("Exception insinde function without unwind info");
+ g_assert_not_reached ();
+ }
if (ji->method != mono_start_method) {
{
MonoMethod *invoke;
MonoObject *(*runtime_invoke) (MonoObject *this, void **params, MonoObject **exc);
+
invoke = mono_marshal_get_runtime_invoke (method);
runtime_invoke = mono_compile_method (invoke);
return runtime_invoke (obj, params, exc);
static gpointer
ves_array_element_address (MonoArray *this, ...)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *class;
va_list ap;
int i, ind, esize;
return NULL;
}
+#ifdef MONO_USE_EXC_TABLES
+static gboolean
+mono_type_blittable (MonoType *type)
+{
+ if (type->byref)
+ return FALSE;
+
+ switch (type->type){
+ case MONO_TYPE_VOID:
+ case MONO_TYPE_I1:
+ case MONO_TYPE_U1:
+ case MONO_TYPE_I2:
+ case MONO_TYPE_U2:
+ case MONO_TYPE_I4:
+ case MONO_TYPE_U4:
+ case MONO_TYPE_I8:
+ case MONO_TYPE_U8:
+ case MONO_TYPE_R4:
+ case MONO_TYPE_R8:
+ case MONO_TYPE_I:
+ case MONO_TYPE_U:
+ return TRUE;
+ case MONO_TYPE_VALUETYPE:
+ case MONO_TYPE_CLASS:
+ return type->data.klass->blittable;
+ break;
+ default:
+ break;
+ }
+
+ return FALSE;
+}
+
+gboolean
+mono_method_blittable (MonoMethod *method)
+{
+ MonoMethodSignature *sig;
+ int i;
+
+ if (!method->addr)
+ return FALSE;
+
+ if (!mono_has_unwind_info (method)) {
+ return FALSE;
+ }
+
+ if (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)
+ return TRUE;
+
+ sig = method->signature;
+
+ if (!mono_type_blittable (sig->ret))
+ return FALSE;
+
+ for (i = 0; i < sig->param_count; i++)
+ if (!mono_type_blittable (sig->params [i]))
+ return FALSE;
+
+ return TRUE;
+}
+#endif
+
/**
* mono_compile_method:
* @method: pointer to the method info
if (!method->info) {
MonoMethod *nm;
-
- nm = mono_marshal_get_native_wrapper (method);
- method->info = mono_compile_method (nm);
+
+ if (!method->addr && (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
+ mono_lookup_pinvoke_call (method);
+#ifdef MONO_USE_EXC_TABLES
+ if (mono_method_blittable (method)) {
+ method->info = method->addr;
+ } else {
+#endif
+ nm = mono_marshal_get_native_wrapper (method);
+ method->info = mono_compile_method (nm);
+#ifdef MONO_USE_EXC_TABLES
+ }
+#endif
}
return method->info;
}
int
arch_activation_frame_size (MonoMethodSignature *sig);
+gboolean
+mono_has_unwind_info (MonoMethod *method);
+
+gboolean
+mono_method_blittable (MonoMethod *method);
+
#endif
(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) {
MonoMethod *nm;
- nm = mono_marshal_get_native_wrapper (method);
- method->info = mono_compile_method (nm);
+ if (!method->addr && (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
+ mono_lookup_pinvoke_call (method);
+
+#ifdef MONO_USE_EXC_TABLES
+ if (mono_method_blittable (method)) {
+ method->info = method->addr;
+ } else {
+#endif
+ nm = mono_marshal_get_native_wrapper (method);
+ method->info = mono_compile_method (nm);
+#ifdef MONO_USE_EXC_TABLES
+ }
+#endif
return method->info;
}
+2002-11-28 Dietmar Maurer <dietmar@ximian.com>
+
+ * loader.c (mono_get_method): set signature->pinvoke for native calls
+
2002-11-20 Dick Porter <dick@ximian.com>
* threads.c (mono_thread_init): Set the main thread's handle
void
ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain* domain = mono_domain_get ();
MonoAssembly *assembly;
gchar *str;
MonoObject *
ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *add = ad->data;
MonoDomain *cur = mono_domain_get ();
MonoObject *o;
void
ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *add = ad->data;
MonoDomain *cur = mono_domain_get ();
MonoObject *o;
MonoAppDomainSetup *
ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
{
+ MONO_ARCH_SAVE_REGS;
+
g_assert (ad != NULL);
g_assert (ad->data != NULL);
MonoString *
ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
{
+ MONO_ARCH_SAVE_REGS;
+
g_assert (ad != NULL);
g_assert (ad->data != NULL);
MonoAppDomain *
ves_icall_System_AppDomain_getCurDomain ()
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *add = mono_domain_get ();
return add->domain;
}
MonoAppDomain *
ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_domain_get ();
MonoClass *adclass;
MonoAppDomain *ad;
MonoArray *
ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = ad->data;
static MonoClass *System_Reflection_Assembly;
MonoArray *res;
MonoReflectionAssembly *
ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_domain_get ();
char *name, *filename;
MonoImageOpenStatus status = MONO_IMAGE_OK;
MonoReflectionAssembly *
ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoReflectionAssemblyName *assRef, MonoObject *evidence)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = ad->data;
char *name;
MonoImageOpenStatus status = MONO_IMAGE_OK;
void
ves_icall_System_AppDomain_Unload (MonoAppDomain *ad)
{
+ MONO_ARCH_SAVE_REGS;
+
mono_domain_unload (ad->data, FALSE);
}
ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
MonoObject *evidence, MonoArray *args)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *cdom = mono_domain_get ();
MonoAssembly *assembly;
MonoImage *image;
* CSharp value type System.Decimal
*/
+#include <mono/metadata/exception.h>
#include <stdio.h>
#include <memory.h>
#include <stdlib.h>
/* performs a += b */
gint32 mono_decimalIncr(/*[In, Out]*/decimal_repr* pA, /*[In]*/decimal_repr* pB)
{
+ MONO_ARCH_SAVE_REGS;
+
guint64 alo, ahi, blo, bhi;
int log2A, log2B, log2Result, log10Result, rc;
int subFlag, sign, scaleA, scaleB;
gint32 mono_decimal2string(/*[In]*/decimal_repr* pA, gint32 digits, gint32 decimals,
MonoArray* pArray, gint32 bufSize, gint32* pDecPos, gint32* pSign)
{
+ MONO_ARCH_SAVE_REGS;
+
guint16 tmp[41];
guint16 *buf = (guint16*) mono_array_addr(pArray, guint16, 0);
guint16 *q, *p = tmp;
*/
gint32 mono_decimal2UInt64(/*[In]*/decimal_repr* pA, guint64* pResult)
{
+ MONO_ARCH_SAVE_REGS;
+
guint64 alo, ahi;
int scale;
*/
gint32 mono_decimal2Int64(/*[In]*/decimal_repr* pA, gint64* pResult)
{
+ MONO_ARCH_SAVE_REGS;
+
guint64 alo, ahi;
int sign, scale;
void mono_decimalFloorAndTrunc(/*[In, Out]*/decimal_repr* pA, gint32 floorFlag)
{
+ MONO_ARCH_SAVE_REGS;
+
guint64 alo, ahi;
guint32 factor, rest;
int scale, sign, idx;
void mono_decimalRound(/*[In, Out]*/decimal_repr* pA, gint32 decimals)
{
+ MONO_ARCH_SAVE_REGS;
+
guint64 alo, ahi;
int scale, sign;
gint32 mono_decimalMult(/*[In, Out]*/decimal_repr* pA, /*[In]*/decimal_repr* pB)
{
+ MONO_ARCH_SAVE_REGS;
+
guint64 low, mid, high;
guint32 factor;
int scale, sign, rc;
gint32 mono_decimalDiv(/*[Out]*/decimal_repr* pC, /*[In]*/decimal_repr* pA, /*[In]*/decimal_repr* pB)
{
+ MONO_ARCH_SAVE_REGS;
+
guint64 clo, chi; /* result */
int scale, texp, rc;
gint32 mono_decimalIntDiv(/*[Out]*/decimal_repr* pC, /*[In]*/decimal_repr* pA, /*[In]*/decimal_repr* pB)
{
+ MONO_ARCH_SAVE_REGS;
+
guint64 clo, chi; /* result */
int scale, texp, rc;
gint32 mono_decimalCompare(/*[In]*/decimal_repr* pA, /*[In]*/decimal_repr* pB)
{
+ MONO_ARCH_SAVE_REGS;
+
int log2a, log2b, delta, sign;
decimal_repr aa;
double mono_decimal2double(/*[In]*/decimal_repr* pA)
{
+ MONO_ARCH_SAVE_REGS;
+
double d;
guint64 alo, ahi, mantisse;
guint32 overhang, factor, roundBits;
/* a *= 10^exp */
gint32 mono_decimalSetExponent(/*[In, Out]*/decimal_repr* pA, gint32 texp)
{
+ MONO_ARCH_SAVE_REGS;
+
guint64 alo, ahi;
int rc;
int scale = pA->signscale.scale;
#ifndef _MONO_METADATA_EXCEPTION_H_
#define _MONO_METADATA_EXCEPTION_H_
+#include <config.h>
+
+#ifdef MONO_USE_EXC_TABLES
+#define MONO_ARCH_SAVE_REGS __builtin_unwind_init ()
+#else
+#define MONO_ARCH_SAVE_REGS
+#endif
+
#include <mono/metadata/object.h>
#include <mono/metadata/image.h>
MonoBoolean
ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
MonoBoolean
ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
ves_icall_System_IO_MonoIO_FindFirstFile (MonoString *path, MonoIOStat *stat,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
WIN32_FIND_DATA data;
HANDLE result;
ves_icall_System_IO_MonoIO_FindNextFile (HANDLE find, MonoIOStat *stat,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
WIN32_FIND_DATA data;
gboolean result;
MonoBoolean
ves_icall_System_IO_MonoIO_FindClose (HANDLE find, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
MonoString *
ves_icall_System_IO_MonoIO_GetCurrentDirectory (gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString *result;
gunichar2 *buf;
int len;
ves_icall_System_IO_MonoIO_SetCurrentDirectory (MonoString *path,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest,
MonoBoolean overwrite, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
MonoBoolean
ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
gint32
ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 ret;
*error=ERROR_SUCCESS;
ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
gint32
ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean result;
WIN32_FILE_ATTRIBUTE_DATA data;
gint32 access_mode, gint32 share,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
HANDLE ret;
*error=ERROR_SUCCESS;
MonoBoolean
ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
gint32 dest_offset, gint32 count,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
guchar *buffer;
gboolean result;
guint32 n;
gint32 src_offset, gint32 count,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
guchar *buffer;
gboolean result;
guint32 n;
ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
guint32 offset_hi;
*error=ERROR_SUCCESS;
MonoBoolean
ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
*error=ERROR_SUCCESS;
gint64
ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gint64 length;
guint32 length_hi;
ves_icall_System_IO_MonoIO_SetLength (HANDLE handle, gint64 length,
gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gint64 offset, offset_set;
gint32 offset_hi;
gint32 length_hi;
gint64 last_access_time,
gint64 last_write_time, gint32 *error)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
const FILETIME *creation_filetime;
const FILETIME *last_access_filetime;
HANDLE
ves_icall_System_IO_MonoIO_get_ConsoleOutput ()
{
+ MONO_ARCH_SAVE_REGS;
+
return GetStdHandle (STD_OUTPUT_HANDLE);
}
HANDLE
ves_icall_System_IO_MonoIO_get_ConsoleInput ()
{
+ MONO_ARCH_SAVE_REGS;
+
return GetStdHandle (STD_INPUT_HANDLE);
}
HANDLE
ves_icall_System_IO_MonoIO_get_ConsoleError ()
{
+ MONO_ARCH_SAVE_REGS;
+
return GetStdHandle (STD_ERROR_HANDLE);
}
ves_icall_System_IO_MonoIO_CreatePipe (HANDLE *read_handle,
HANDLE *write_handle)
{
+ MONO_ARCH_SAVE_REGS;
+
SECURITY_ATTRIBUTES attr;
gboolean ret;
gunichar2
ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar ()
{
+ MONO_ARCH_SAVE_REGS;
+
#if defined (PLATFORM_WIN32)
return (gunichar2) 0x003a; /* colon */
#else
gunichar2
ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar ()
{
+ MONO_ARCH_SAVE_REGS;
+
#if defined (PLATFORM_WIN32)
return (gunichar2) 0x005c; /* backslash */
#else
gunichar2
ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar ()
{
+ MONO_ARCH_SAVE_REGS;
+
#if defined (PLATFORM_WIN32)
return (gunichar2) 0x002f; /* forward slash */
#else
gunichar2
ves_icall_System_IO_MonoIO_get_PathSeparator ()
{
+ MONO_ARCH_SAVE_REGS;
+
#if defined (PLATFORM_WIN32)
return (gunichar2) 0x003b; /* semicolon */
#else
MonoArray *
ves_icall_System_IO_MonoIO_get_InvalidPathChars ()
{
+ MONO_ARCH_SAVE_REGS;
+
MonoArray *chars;
MonoDomain *domain;
int i, n;
#include <mono/metadata/gc.h>
#include <mono/metadata/threads.h>
#include <mono/metadata/tabledefs.h>
+#include <mono/metadata/exception.h>
#define GC_I_HIDE_POINTERS
#include <mono/os/gc_wrapper.h>
void
ves_icall_System_GC_InternalCollect (int generation)
{
+ MONO_ARCH_SAVE_REGS;
+
#if HAVE_BOEHM_GC
GC_gcollect ();
#endif
gint64
ves_icall_System_GC_GetTotalMemory (MonoBoolean forceCollection)
{
+ MONO_ARCH_SAVE_REGS;
+
#if HAVE_BOEHM_GC
if (forceCollection)
GC_gcollect ();
void
ves_icall_System_GC_KeepAlive (MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
/*
* Does nothing.
*/
void
ves_icall_System_GC_ReRegisterForFinalize (MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
object_register_finalizer (obj, run_finalize);
}
void
ves_icall_System_GC_SuppressFinalize (MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
object_register_finalizer (obj, NULL);
}
void
ves_icall_System_GC_WaitForPendingFinalizers (void)
{
+ MONO_ARCH_SAVE_REGS;
}
/*static CRITICAL_SECTION handle_section;*/
MonoObject *
ves_icall_System_GCHandle_GetTarget (guint32 handle)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoObject *obj;
gint32 type;
guint32
ves_icall_System_GCHandle_GetTargetHandle (MonoObject *obj, guint32 handle, gint32 type)
{
+ MONO_ARCH_SAVE_REGS;
+
gpointer val = obj;
guint32 h, idx = next_handle++;
void
ves_icall_System_GCHandle_FreeHandle (guint32 handle)
{
+ MONO_ARCH_SAVE_REGS;
+
int idx = handle >> 2;
int type = handle & 0x3;
gpointer
ves_icall_System_GCHandle_GetAddrOfPinnedObject (guint32 handle)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoObject *obj;
int type = handle & 0x3;
static MonoString *
mono_double_ToStringImpl (double value)
{
+ MONO_ARCH_SAVE_REGS;
+
/* FIXME: Handle formats, etc. */
MonoString *s;
gchar *retVal;
static double
mono_double_ParseImpl (char *ptr)
{
+ MONO_ARCH_SAVE_REGS;
+
return bsd_strtod (ptr, NULL);
}
static MonoString *
mono_float_ToStringImpl (float value)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_double_ToStringImpl (value);
}
static MonoObject *
ves_icall_System_Array_GetValueImpl (MonoObject *this, guint32 pos)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *ac;
MonoArray *ao;
gint32 esize;
static MonoObject *
ves_icall_System_Array_GetValue (MonoObject *this, MonoObject *idxs)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *ac, *ic;
MonoArray *ao, *io;
gint32 i, pos, *ind;
static void
ves_icall_System_Array_SetValueImpl (MonoArray *this, MonoObject *value, guint32 pos)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *ac, *vc, *ec;
gint32 esize, vsize;
gpointer *ea, *va;
ves_icall_System_Array_SetValue (MonoArray *this, MonoObject *value,
MonoArray *idxs)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *ac, *ic;
gint32 i, pos, *ind;
static MonoArray *
ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *aklass;
MonoArray *array;
gint32 *sizes, i;
static gint32
ves_icall_System_Array_GetRank (MonoObject *this)
{
+ MONO_ARCH_SAVE_REGS;
+
return this->vtable->klass->rank;
}
static gint32
ves_icall_System_Array_GetLength (MonoArray *this, gint32 dimension)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
if ((dimension < 0) || (dimension >= rank))
mono_raise_exception (mono_get_exception_index_out_of_range ());
static gint32
ves_icall_System_Array_GetLowerBound (MonoArray *this, gint32 dimension)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
if ((dimension < 0) || (dimension >= rank))
mono_raise_exception (mono_get_exception_index_out_of_range ());
static void
ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* dest, int dest_idx, int length)
{
+ MONO_ARCH_SAVE_REGS;
+
int element_size = mono_array_element_size (source->obj.vtable->klass);
void * dest_addr = mono_array_addr_with_size (dest, element_size, dest_idx);
void * source_addr = mono_array_addr_with_size (source, element_size, source_idx);
static void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray *array, MonoClassField *field_handle)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass = array->obj.vtable->klass;
guint32 size = mono_array_element_size (klass);
int i;
static gint
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void)
{
+ MONO_ARCH_SAVE_REGS;
+
return offsetof (MonoString, chars);
}
static MonoObject *
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
if ((obj == NULL) || (! (obj->vtable->klass->valuetype)))
return obj;
else
static void
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (MonoType *handle)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass;
MONO_CHECK_ARG_NULL (handle);
static MonoObject *
ves_icall_System_Object_MemberwiseClone (MonoObject *this)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_object_clone (this);
}
static gint32
ves_icall_System_Object_GetHashCode (MonoObject *this)
{
+ MONO_ARCH_SAVE_REGS;
+
register guint32 key;
key = (GPOINTER_TO_UINT (this) >> MONO_OBJECT_ALIGNMENT_SHIFT) * 2654435761u;
static gint32
ves_icall_System_ValueType_GetHashCode (MonoObject *this)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 i, size;
const char *p;
guint h = 0;
static MonoBoolean
ves_icall_System_ValueType_Equals (MonoObject *this, MonoObject *that)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 size;
const char *p, *s;
static MonoReflectionType *
ves_icall_System_Object_GetType (MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg);
}
static void
mono_type_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
mtype->type = &obj->vtable->klass->byval_arg;
g_assert (mtype->type->type);
}
static gint32
ves_icall_AssemblyBuilder_getToken (MonoReflectionAssemblyBuilder *assb, MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_image_create_token (assb->dynamic_assembly, obj);
}
static gint32
ves_icall_AssemblyBuilder_getDataChunk (MonoReflectionAssemblyBuilder *assb, MonoArray *buf, gint32 offset)
{
+ MONO_ARCH_SAVE_REGS;
+
int count;
MonoDynamicAssembly *ass = assb->dynamic_assembly;
char *p = mono_array_addr (buf, char, 0);
static MonoReflectionType*
ves_icall_type_from_name (MonoString *name)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoImage *image = NULL;
MonoType *type;
gchar *str;
static MonoReflectionType*
ves_icall_type_from_handle (MonoType *handle)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_domain_get ();
MonoClass *klass = mono_class_from_mono_type (handle);
static guint32
ves_icall_type_Equals (MonoReflectionType *type, MonoReflectionType *c)
{
+ MONO_ARCH_SAVE_REGS;
+
if (type->type && c->type)
return mono_metadata_type_equal (type->type, c->type);
g_print ("type equals\n");
static guint32
ves_icall_type_GetTypeCode (MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
int t = type->type->type;
handle_enum:
switch (t) {
static guint32
ves_icall_type_is_subtype_of (MonoReflectionType *type, MonoReflectionType *c, MonoBoolean check_interfaces)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
MonoClass *klass;
MonoClass *klassc;
static guint32
ves_icall_get_attributes (MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass = mono_class_from_mono_type (type->type);
return klass->flags;
static void
ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_domain_get ();
info->parent = mono_type_get_object (domain, &method->klass->byval_arg);
static MonoArray*
ves_icall_get_parameter_info (MonoMethod *method)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_domain_get ();
MonoArray *res;
static MonoClass *System_Reflection_ParameterInfo;
static void
ves_icall_get_field_info (MonoReflectionField *field, MonoFieldInfo *info)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (field);
info->parent = mono_type_get_object (domain, &field->klass->byval_arg);
static MonoObject *
ves_icall_MonoField_GetValueInternal (MonoReflectionField *field, MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoObject *o;
MonoClassField *cf = field->field;
MonoClass *klass;
static void
ves_icall_FieldInfo_SetValueInternal (MonoReflectionField *field, MonoObject *obj, MonoObject *value)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClassField *cf = field->field;
gchar *v;
static void
ves_icall_get_property_info (MonoReflectionProperty *property, MonoPropertyInfo *info)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (property);
info->parent = mono_type_get_object (domain, &property->klass->byval_arg);
static void
ves_icall_get_event_info (MonoReflectionEvent *event, MonoEventInfo *info)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (event);
info->parent = mono_type_get_object (domain, &event->klass->byval_arg);
static MonoArray*
ves_icall_Type_GetInterfaces (MonoReflectionType* type)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (type);
MonoArray *intf;
int ninterf, i;
static MonoReflectionType*
ves_icall_MonoType_GetElementType (MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *class = mono_class_from_mono_type (type->type);
if (class->enumtype && class->enum_basetype) /* types that are modifierd typebuilkders may not have enum_basetype set */
return mono_type_get_object (mono_object_domain (type), class->enum_basetype);
static MonoReflectionType*
ves_icall_get_type_parent (MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *class = mono_class_from_mono_type (type->type);
return class->parent ? mono_type_get_object (mono_object_domain (type), &class->parent->byval_arg): NULL;
}
static MonoBoolean
ves_icall_type_ispointer (MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
return type->type->type == MONO_TYPE_PTR;
}
static MonoBoolean
ves_icall_type_isbyref (MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
return type->type->byref;
}
static MonoReflectionModule*
ves_icall_MonoType_get_Module (MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *class = mono_class_from_mono_type (type->type);
return mono_module_get_object (mono_object_domain (type), class->image);
}
static void
ves_icall_get_type_info (MonoType *type, MonoTypeInfo *info)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_domain_get ();
MonoClass *class = mono_class_from_mono_type (type);
static MonoObject *
ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this, MonoArray *params)
{
+ MONO_ARCH_SAVE_REGS;
+
/*
* Invoke from reflection is supposed to always be a virtual call (the API
* is stupid), mono_runtime_invoke_*() calls the provided method, allowing
static MonoObject *
ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this, MonoArray *params, MonoArray **outArgs)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (method);
MonoMethod *m = method->method;
MonoMethodSignature *sig = m->signature;
static MonoObject *
ves_icall_System_Enum_ToObject (MonoReflectionType *type, MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
MonoClass *enumc, *objc;
gint32 s1, s2;
static MonoObject *
ves_icall_System_Enum_get_value (MonoObject *this)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoObject *res;
MonoClass *enumc;
gpointer dst;
static void
ves_icall_get_enum_info (MonoReflectionType *type, MonoEnumInfo *info)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (type);
MonoClass *enumc = mono_class_from_mono_type (type->type);
guint i, j, nvalues, crow;
static MonoFieldInfo *
ves_icall_Type_GetField (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
MonoClass *startklass, *klass;
int i, match;
static MonoArray*
ves_icall_Type_GetFields (MonoReflectionType *type, guint32 bflags)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
GSList *l = NULL, *tmp;
MonoClass *startklass, *klass;
static MonoArray*
ves_icall_Type_GetMethods (MonoReflectionType *type, guint32 bflags)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
GSList *l = NULL, *tmp;
static MonoClass *System_Reflection_MethodInfo;
static MonoArray*
ves_icall_Type_GetConstructors (MonoReflectionType *type, guint32 bflags)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
GSList *l = NULL, *tmp;
static MonoClass *System_Reflection_ConstructorInfo;
static MonoArray*
ves_icall_Type_GetProperties (MonoReflectionType *type, guint32 bflags)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
GSList *l = NULL, *tmp;
static MonoClass *System_Reflection_PropertyInfo;
static MonoReflectionEvent *
ves_icall_MonoType_GetEvent (MonoReflectionType *type, MonoString *name, guint32 bflags)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
MonoClass *klass;
gint i;
static MonoArray*
ves_icall_Type_GetEvents (MonoReflectionType *type, guint32 bflags)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
GSList *l = NULL, *tmp;
static MonoClass *System_Reflection_EventInfo;
static MonoArray*
ves_icall_Type_GetNestedTypes (MonoReflectionType *type, guint32 bflags)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
GSList *l = NULL, *tmp;
GList *tmpn;
static MonoReflectionType*
ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *assembly, MonoString *name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
+ MONO_ARCH_SAVE_REGS;
+
gchar *str;
MonoType *type;
MonoTypeNameParse info;
static MonoString *
ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly *assembly)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (assembly);
MonoString *res;
char *name = g_strconcat (
static MonoString *
ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly *assembly)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (assembly);
MonoString *res;
char *name = g_strconcat (
}
static MonoReflectionMethod*
-ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly *assembly) {
+ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly *assembly)
+{
+ MONO_ARCH_SAVE_REGS;
+
guint32 token = mono_image_get_entry_point (assembly->assembly->image);
if (!token)
return NULL;
}
static MonoArray*
-ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly) {
+ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly)
+{
+ MONO_ARCH_SAVE_REGS;
+
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
MonoArray *result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, table->rows);
int i;
}
static MonoArray*
-ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly) {
+ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly)
+{
+ MONO_ARCH_SAVE_REGS;
+
static MonoClass *System_Reflection_AssemblyName;
MonoArray *result;
MonoAssembly **ptr;
}
static MonoObject*
-ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name) {
+ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name)
+{
+ MONO_ARCH_SAVE_REGS;
+
char *n = mono_string_to_utf8 (name);
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
guint32 i;
}
static MonoObject*
-ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name) {
+ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name)
+{
+ MONO_ARCH_SAVE_REGS;
+
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
MonoArray *result;
int i;
}
static MonoReflectionMethod*
-ves_icall_GetCurrentMethod (void) {
+ves_icall_GetCurrentMethod (void)
+{
+ MONO_ARCH_SAVE_REGS;
+
MonoMethod *m = mono_method_get_last_managed ();
return mono_method_get_object (mono_domain_get (), m, NULL);
}
static MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoMethod *m = mono_method_get_last_managed ();
return mono_assembly_get_object (mono_domain_get (), m->klass->image->assembly);
}
static MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain* domain = mono_domain_get ();
g_assert (domain->entry_assembly);
return mono_assembly_get_object (domain, domain->entry_assembly);
static MonoReflectionAssembly*
ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoMethod *m = mono_method_get_last_managed ();
MonoMethod *dest = m;
mono_stack_walk (get_caller, &dest);
static MonoString *
ves_icall_System_MonoType_getFullName (MonoReflectionType *object)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (object);
MonoString *res;
gchar *name;
static void
ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly *assembly, MonoReflectionAssemblyName *aname)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoAssemblyName *name = &assembly->assembly->aname;
if (strcmp (name->name, "corlib") == 0)
static MonoArray*
ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (assembly);
MonoArray *res;
MonoClass *klass;
static MonoReflectionType*
ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass;
int isbyref = 0, rank;
char *str = mono_string_to_utf8 (smodifiers);
ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, MonoObject *target,
MonoReflectionMethod *info)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *delegate_class = mono_class_from_mono_type (type->type);
MonoObject *delegate;
gpointer func;
static gint64
ves_icall_System_DateTime_GetNow (void)
{
+ MONO_ARCH_SAVE_REGS;
+
#ifdef PLATFORM_WIN32
SYSTEMTIME st;
FILETIME ft;
static guint32
ves_icall_System_CurrentTimeZone_GetTimeZoneData (guint32 year, MonoArray **data, MonoArray **names)
{
+ MONO_ARCH_SAVE_REGS;
+
#ifndef PLATFORM_WIN32
MonoDomain *domain = mono_domain_get ();
struct tm start, tt;
}
static gpointer
-ves_icall_System_Object_obj_address (MonoObject *this) {
+ves_icall_System_Object_obj_address (MonoObject *this)
+{
+ MONO_ARCH_SAVE_REGS;
+
return this;
}
/* System.Buffer */
static gint32
-ves_icall_System_Buffer_ByteLengthInternal (MonoArray *array) {
+ves_icall_System_Buffer_ByteLengthInternal (MonoArray *array)
+{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass;
MonoTypeEnum etype;
int length, esize;
}
static gint8
-ves_icall_System_Buffer_GetByteInternal (MonoArray *array, gint32 idx) {
+ves_icall_System_Buffer_GetByteInternal (MonoArray *array, gint32 idx)
+{
+ MONO_ARCH_SAVE_REGS;
+
return mono_array_get (array, gint8, idx);
}
static void
-ves_icall_System_Buffer_SetByteInternal (MonoArray *array, gint32 idx, gint8 value) {
+ves_icall_System_Buffer_SetByteInternal (MonoArray *array, gint32 idx, gint8 value)
+{
+ MONO_ARCH_SAVE_REGS;
+
mono_array_set (array, gint8, idx, value);
}
static void
-ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, MonoArray *dest, gint32 dest_offset, gint32 count) {
+ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, MonoArray *dest, gint32 dest_offset, gint32 count)
+{
+ MONO_ARCH_SAVE_REGS;
+
char *src_buf, *dest_buf;
src_buf = (gint8 *)src->vector + src_offset;
static MonoObject *
ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_object_domain (this);
MonoObject *res;
MonoRealProxy *rp = ((MonoRealProxy *)this);
static MonoString *
ves_icall_System_Environment_get_MachineName (void)
{
+ MONO_ARCH_SAVE_REGS;
+
#if defined (PLATFORM_WIN32)
gunichar2 *buf;
guint32 len;
static int
ves_icall_System_Environment_get_Platform (void)
{
+ MONO_ARCH_SAVE_REGS;
+
#if defined (PLATFORM_WIN32)
/* Win32NT */
return 2;
static MonoString *
ves_icall_System_Environment_get_NewLine (void)
{
+ MONO_ARCH_SAVE_REGS;
+
#if defined (PLATFORM_WIN32)
return mono_string_new (mono_domain_get (), "\r\n");
#else
static MonoString *
ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name)
{
+ MONO_ARCH_SAVE_REGS;
+
const gchar *value;
gchar *utf8_name;
static MonoArray *
ves_icall_System_Environment_GetEnvironmentVariableNames (void)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoArray *names;
MonoDomain *domain;
MonoString *str;
static gint32
ves_icall_System_Environment_get_TickCount (void)
{
+ MONO_ARCH_SAVE_REGS;
+
#if defined (PLATFORM_WIN32)
return GetTickCount();
#else
static void
ves_icall_System_Environment_Exit (int result)
{
+ MONO_ARCH_SAVE_REGS;
+
/* we may need to do some cleanup here... */
exit (result);
}
static MonoString*
-ves_icall_System_Text_Encoding_InternalCodePage (void) {
+ves_icall_System_Text_Encoding_InternalCodePage (void)
+{
+ MONO_ARCH_SAVE_REGS;
+
const char *cset;
g_get_charset (&cset);
/* g_print ("charset: %s\n", cset); */
MonoReflectionMethod *method,
MonoArray *out_args)
{
+ MONO_ARCH_SAVE_REGS;
+
mono_message_init (mono_object_domain (this), this, method, out_args);
}
static MonoBoolean
ves_icall_IsTransparentProxy (MonoObject *proxy)
{
+ MONO_ARCH_SAVE_REGS;
+
if (!proxy)
return 0;
static MonoObject *
ves_icall_System_Runtime_Serialization_FormatterServices_GetUninitializedObject_Internal (MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass;
MonoObject *obj;
MonoDomain *domain;
static MonoString *
ves_icall_System_IO_get_temp_path (void)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_string_new (mono_domain_get (), g_get_tmp_dir ());
}
static gpointer
ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod *method)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_compile_method (method);
}
static MonoString *
ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void)
{
+ MONO_ARCH_SAVE_REGS;
+
static MonoString *mcpath;
gchar *path;
result->string_ctor = 1;
result->addr = mono_lookup_internal_call (result);
+ result->signature->pinvoke = 1;
} else if (cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
+ result->signature->pinvoke = 1;
((MonoMethodPInvoke *)result)->implmap_idx = mono_metadata_implmap_from_method (image, idx - 1);
} else {
/* if this is a methodref from another module/assembly, this fails */
/* FIXME: on win32 we should probably use GlobalAlloc(). */
void*
-mono_marshal_alloc (gpointer size) {
+mono_marshal_alloc (gpointer size)
+{
+ MONO_ARCH_SAVE_REGS;
+
return g_try_malloc ((gulong)size);
}
void
-mono_marshal_free (gpointer ptr) {
+mono_marshal_free (gpointer ptr)
+{
+ MONO_ARCH_SAVE_REGS;
+
g_free (ptr);
}
}
void *
-mono_marshal_realloc (gpointer ptr, gpointer size) {
+mono_marshal_realloc (gpointer ptr, gpointer size)
+{
+ MONO_ARCH_SAVE_REGS;
+
return g_try_realloc (ptr, (gulong)size);
}
ves_icall_System_Runtime_InteropServices_Marshal_copy_to_unmanaged (MonoArray *src, gint32 start_index,
gpointer dest, gint32 length)
{
+ MONO_ARCH_SAVE_REGS;
+
int element_size;
void *source_addr;
ves_icall_System_Runtime_InteropServices_Marshal_copy_from_unmanaged (gpointer src, gint32 start_index,
MonoArray *dest, gint32 length)
{
+ MONO_ARCH_SAVE_REGS;
+
int element_size;
void *dest_addr;
gpointer
ves_icall_System_Runtime_InteropServices_Marshal_ReadIntPtr (gpointer ptr, gint32 offset)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
return *(gpointer*)(p + offset);
}
unsigned char
ves_icall_System_Runtime_InteropServices_Marshal_ReadByte (gpointer ptr, gint32 offset)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
return *(unsigned char*)(p + offset);
}
gint16
ves_icall_System_Runtime_InteropServices_Marshal_ReadInt16 (gpointer ptr, gint32 offset)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
return *(gint16*)(p + offset);
}
gint32
ves_icall_System_Runtime_InteropServices_Marshal_ReadInt32 (gpointer ptr, gint32 offset)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
return *(gint32*)(p + offset);
}
gint64
ves_icall_System_Runtime_InteropServices_Marshal_ReadInt64 (gpointer ptr, gint32 offset)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
return *(gint64*)(p + offset);
}
void
ves_icall_System_Runtime_InteropServices_Marshal_WriteByte (gpointer ptr, gint32 offset, unsigned char val)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
*(unsigned char*)(p + offset) = val;
}
void
ves_icall_System_Runtime_InteropServices_Marshal_WriteIntPtr (gpointer ptr, gint32 offset, gpointer val)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
*(gpointer*)(p + offset) = val;
}
void
ves_icall_System_Runtime_InteropServices_Marshal_WriteInt16 (gpointer ptr, gint32 offset, gint16 val)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
*(gint16*)(p + offset) = val;
}
void
ves_icall_System_Runtime_InteropServices_Marshal_WriteInt32 (gpointer ptr, gint32 offset, gint32 val)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
*(gint32*)(p + offset) = val;
}
void
ves_icall_System_Runtime_InteropServices_Marshal_WriteInt64 (gpointer ptr, gint32 offset, gint64 val)
{
+ MONO_ARCH_SAVE_REGS;
+
char *p = ptr;
*(gint64*)(p + offset) = val;
}
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_string_new (mono_domain_get (), ptr);
}
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr, gint32 len)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_string_new_len (mono_domain_get (), ptr, len);
}
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni (guint16 *ptr)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_domain_get ();
int len = 0;
guint16 *t = ptr;
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni_len (guint16 *ptr, gint32 len)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_domain_get ();
return mono_string_new_utf16 (domain, ptr, len);
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (gpointer ptr)
{
+ MONO_ARCH_SAVE_REGS;
+
g_warning ("PtrToStringBSTR not implemented");
g_assert_not_reached ();
guint32
ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error (void)
{
+ MONO_ARCH_SAVE_REGS;
+
return (GetLastError ());
}
guint32
ves_icall_System_Runtime_InteropServices_Marshal_SizeOf (MonoReflectionType *rtype)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass;
MONO_CHECK_ARG_NULL (rtype);
void
ves_icall_System_Runtime_InteropServices_Marshal_StructureToPtr (MonoObject *obj, gpointer dst, MonoBoolean delete_old)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoMethod *method;
gpointer pa [3];
void
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (gpointer src, MonoObject *dst)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoMethod *method;
gpointer pa [2];
MonoObject *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer src, MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain = mono_domain_get ();
MonoObject *res;
int
ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *type, MonoString *field_name)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoMarshalType *info;
MonoClass *klass;
char *fname;
gpointer
ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString *string)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_string_to_utf8 (string);
}
gpointer
ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (MonoString *string)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_memdup (mono_string_chars (string), mono_string_length (string)*2);
}
void
ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure (gpointer src, MonoReflectionType *type)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass;
MONO_CHECK_ARG_NULL (src);
#include <mono/metadata/loader.h>
#include <mono/metadata/object.h>
#include <mono/metadata/gc.h>
+#include <mono/metadata/exception.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/assembly.h>
#include <mono/metadata/threadpool.h>
MonoArray*
mono_array_clone (MonoArray *array)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoArray *o;
int size, i;
guint32 *sizes;
#include <mono/metadata/appdomain.h>
#include <mono/metadata/image.h>
#include <mono/metadata/cil-coff.h>
+#include <mono/metadata/exception.h>
#include <mono/io-layer/io-layer.h>
#undef DEBUG
HANDLE ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid)
{
+ MONO_ARCH_SAVE_REGS;
+
HANDLE handle;
/* GetCurrentProcess returns a pseudo-handle, so use
guint32 ves_icall_System_Diagnostics_Process_GetPid_internal (void)
{
+ MONO_ARCH_SAVE_REGS;
+
return(GetCurrentProcessId ());
}
void ves_icall_System_Diagnostics_Process_Process_free_internal (MonoObject *this,
HANDLE process)
{
+ MONO_ARCH_SAVE_REGS;
+
#ifdef THREAD_DEBUG
g_message (G_GNUC_PRETTY_FUNCTION ": Closing process %p, handle %p",
this, process);
/* Returns an array of System.Diagnostics.ProcessModule */
MonoArray *ves_icall_System_Diagnostics_Process_GetModules_internal (MonoObject *this)
{
+ MONO_ARCH_SAVE_REGS;
+
/* I was going to use toolhelp for this, but then realised I
* was being an idiot :)
*
void ves_icall_System_Diagnostics_FileVersionInfo_GetVersionInfo_internal (MonoObject *this, MonoString *filename)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoImage *image;
guchar *filename_utf8;
MonoBoolean ves_icall_System_Diagnostics_Process_Start_internal (MonoString *cmd, MonoString *dirname, HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, MonoProcInfo *process_info)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
gunichar2 *dir;
STARTUPINFO startinfo={0};
MonoBoolean ves_icall_System_Diagnostics_Process_WaitForExit_internal (MonoObject *this, HANDLE process, gint32 ms)
{
+ MONO_ARCH_SAVE_REGS;
+
guint32 ret;
if(ms<0) {
gint64 ves_icall_System_Diagnostics_Process_ExitTime_internal (HANDLE process)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
gint64 ticks;
FILETIME create_time, exit_time, kernel_time, user_time;
gint64 ves_icall_System_Diagnostics_Process_StartTime_internal (HANDLE process)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
gint64 ticks;
FILETIME create_time, exit_time, kernel_time, user_time;
gint32 ves_icall_System_Diagnostics_Process_ExitCode_internal (HANDLE process)
{
+ MONO_ARCH_SAVE_REGS;
+
guint32 code;
GetExitCodeProcess (process, &code);
MonoString *ves_icall_System_Diagnostics_Process_ProcessName_internal (HANDLE process)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString *string;
gboolean ok;
HMODULE mod;
/* Returns an array of pids */
MonoArray *ves_icall_System_Diagnostics_Process_GetProcesses_internal (void)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoArray *procs;
gboolean ret;
guint32 needed, count, i;
MonoBoolean ves_icall_System_Diagnostics_Process_GetWorkingSet_internal (HANDLE process, guint32 *min, guint32 *max)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
ret=GetProcessWorkingSetSize (process, min, max);
MonoBoolean ves_icall_System_Diagnostics_Process_SetWorkingSet_internal (HANDLE process, guint32 min, guint32 max, MonoBoolean use_min)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
guint32 ws_min;
guint32 ws_max;
#include "mono/metadata/tokentype.h"
#include "mono/metadata/appdomain.h"
#include "mono/metadata/opcodes.h"
+#include <mono/metadata/exception.h>
#include <stdio.h>
#include <glib.h>
#include <errno.h>
guint32
mono_image_insert_string (MonoReflectionAssemblyBuilder *assembly, MonoString *str)
{
+ MONO_ARCH_SAVE_REGS;
+
guint32 idx;
char buf [16];
char *b = buf;
void
mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
{
+ MONO_ARCH_SAVE_REGS;
+
static const guchar entrycode [16] = {0xff, 0x25, 0};
MonoDynamicAssembly *assembly;
MonoImage *image;
MonoArray*
mono_reflection_get_custom_attrs (MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
guint32 idx, mtoken, i, len;
guint32 cols [MONO_CUSTOM_ATTR_SIZE];
MonoClass *klass;
*/
MonoArray*
mono_reflection_get_custom_attrs_blob (MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues) {
+
+ MONO_ARCH_SAVE_REGS;
+
MonoArray *result;
MonoMethodSignature *sig;
MonoObject *arg;
void
mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass, *parent;
klass = g_new0 (MonoClass, 1);
void
mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass;
klass = my_mono_class_from_mono_type (tb->type.type);
MonoReflectionType*
mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoClass *klass;
MonoReflectionType* res;
MonoArray *
mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDynamicAssembly *assembly = sig->module->assemblyb->dynamic_assembly;
guint32 na = mono_array_length (sig->arguments);
guint32 buflen, i;
MonoArray *
mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDynamicAssembly *assembly = sig->module->assemblyb->dynamic_assembly;
guint32 na = mono_array_length (sig->arguments);
guint32 buflen, i;
gpointer ves_icall_System_Net_Sockets_Socket_Socket_internal(MonoObject *this, gint32 family, gint32 type, gint32 proto)
{
+ MONO_ARCH_SAVE_REGS;
+
SOCKET sock;
gint32 sock_family;
gint32 sock_proto;
*/
void ves_icall_System_Net_Sockets_Socket_Close_internal(SOCKET sock)
{
+ MONO_ARCH_SAVE_REGS;
+
#ifdef DEBUG
g_message (G_GNUC_PRETTY_FUNCTION ": closing 0x%x", sock);
#endif
gint32 ves_icall_System_Net_Sockets_SocketException_WSAGetLastError_internal(void)
{
+ MONO_ARCH_SAVE_REGS;
+
#ifdef DEBUG
g_message(G_GNUC_PRETTY_FUNCTION ": returning %d", WSAGetLastError());
#endif
gint32 ves_icall_System_Net_Sockets_Socket_Available_internal(SOCKET sock)
{
+ MONO_ARCH_SAVE_REGS;
+
int ret, amount;
ret=ioctlsocket(sock, FIONREAD, &amount);
void ves_icall_System_Net_Sockets_Socket_Blocking_internal(SOCKET sock,
gboolean block)
{
+ MONO_ARCH_SAVE_REGS;
+
int ret;
ret=ioctlsocket(sock, FIONBIO, &block);
gpointer ves_icall_System_Net_Sockets_Socket_Accept_internal(SOCKET sock)
{
+ MONO_ARCH_SAVE_REGS;
+
SOCKET newsock;
newsock=accept(sock, NULL, 0);
void ves_icall_System_Net_Sockets_Socket_Listen_internal(SOCKET sock,
guint32 backlog)
{
+ MONO_ARCH_SAVE_REGS;
+
int ret;
ret=listen(sock, backlog);
extern MonoObject *ves_icall_System_Net_Sockets_Socket_LocalEndPoint_internal(SOCKET sock)
{
+ MONO_ARCH_SAVE_REGS;
+
struct sockaddr sa;
int salen;
int ret;
extern MonoObject *ves_icall_System_Net_Sockets_Socket_RemoteEndPoint_internal(SOCKET sock)
{
+ MONO_ARCH_SAVE_REGS;
+
struct sockaddr sa;
int salen;
int ret;
extern void ves_icall_System_Net_Sockets_Socket_Bind_internal(SOCKET sock, MonoObject *sockaddr)
{
+ MONO_ARCH_SAVE_REGS;
+
struct sockaddr *sa;
int sa_size;
int ret;
extern void ves_icall_System_Net_Sockets_Socket_Connect_internal(SOCKET sock, MonoObject *sockaddr)
{
+ MONO_ARCH_SAVE_REGS;
+
struct sockaddr *sa;
int sa_size;
int ret;
gint32 ves_icall_System_Net_Sockets_Socket_Receive_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags)
{
+ MONO_ARCH_SAVE_REGS;
+
int ret;
guchar *buf;
gint32 alen;
gint32 ves_icall_System_Net_Sockets_Socket_RecvFrom_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject **sockaddr)
{
+ MONO_ARCH_SAVE_REGS;
+
int ret;
guchar *buf;
gint32 alen;
gint32 ves_icall_System_Net_Sockets_Socket_Send_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags)
{
+ MONO_ARCH_SAVE_REGS;
+
int ret;
guchar *buf;
gint32 alen;
gint32 ves_icall_System_Net_Sockets_Socket_SendTo_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject *sockaddr)
{
+ MONO_ARCH_SAVE_REGS;
+
int ret;
guchar *buf;
gint32 alen;
void ves_icall_System_Net_Sockets_Socket_Select_internal(MonoArray **read_socks, MonoArray **write_socks, MonoArray **err_socks, gint32 timeout)
{
+ MONO_ARCH_SAVE_REGS;
+
fd_set readfds, writefds, errfds;
struct timeval tv;
div_t divvy;
void ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal(SOCKET sock, gint32 level, gint32 name, MonoObject **obj_val)
{
+ MONO_ARCH_SAVE_REGS;
+
int system_level;
int system_name;
int ret;
void ves_icall_System_Net_Sockets_Socket_GetSocketOption_arr_internal(SOCKET sock, gint32 level, gint32 name, MonoArray **byte_val)
{
+ MONO_ARCH_SAVE_REGS;
+
int system_level;
int system_name;
int ret;
void ves_icall_System_Net_Sockets_Socket_SetSocketOption_internal(SOCKET sock, gint32 level, gint32 name, MonoObject *obj_val, MonoArray *byte_val, gint32 int_val)
{
+ MONO_ARCH_SAVE_REGS;
+
int system_level;
int system_name;
int ret;
void ves_icall_System_Net_Sockets_Socket_Shutdown_internal(SOCKET sock,
gint32 how)
{
+ MONO_ARCH_SAVE_REGS;
+
int ret;
/* Currently, the values for how (recv=0, send=1, both=2) match
extern MonoBoolean ves_icall_System_Net_Dns_GetHostByName_internal(MonoString *host, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list)
{
+ MONO_ARCH_SAVE_REGS;
+
char *hostname;
struct hostent *he;
extern MonoBoolean ves_icall_System_Net_Dns_GetHostByAddr_internal(MonoString *addr, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list)
{
+ MONO_ARCH_SAVE_REGS;
+
struct in_addr inaddr;
struct hostent *he;
char *address;
extern MonoBoolean ves_icall_System_Net_Dns_GetHostName_internal(MonoString **h_name)
{
+ MONO_ARCH_SAVE_REGS;
+
guchar hostname[256];
int ret;
MonoString *
ves_icall_System_String_ctor_charp (gpointer dummy, gunichar2 *value)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 i, length;
MonoDomain *domain;
MonoString *
ves_icall_System_String_ctor_char_int (gpointer dummy, gunichar2 value, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
MonoString *res;
gunichar2 *chars;
MonoString *
ves_icall_System_String_ctor_charp_int_int (gpointer dummy, gunichar2 *value, gint32 sindex, gint32 length)
{
+ MONO_ARCH_SAVE_REGS;
+
gunichar2 *begin;
MonoDomain * domain;
MonoString *
ves_icall_System_String_ctor_sbytep (gpointer dummy, gint8 *value)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
domain = mono_domain_get ();
MonoString *
ves_icall_System_String_ctor_sbytep_int_int (gpointer dummy, gint8 *value, gint32 sindex, gint32 length)
{
+ MONO_ARCH_SAVE_REGS;
+
char *begin;
MonoDomain *domain;
MonoString *
ves_icall_System_String_ctor_chara (gpointer dummy, MonoArray *value)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
MONO_CHECK_ARG_NULL (value);
ves_icall_System_String_ctor_chara_int_int (gpointer dummy, MonoArray *value,
gint32 sindex, gint32 length)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoDomain *domain;
MONO_CHECK_ARG_NULL (value);
ves_icall_System_String_ctor_encoding (gpointer dummy, gint8 *value, gint32 sindex,
gint32 length, MonoObject *enc)
{
+ MONO_ARCH_SAVE_REGS;
+
g_warning("string.ctor with encoding obj unimplemented");
g_assert_not_reached ();
return NULL;
MonoBoolean
ves_icall_System_String_InternalEquals (MonoString *str1, MonoString *str2)
{
+ MONO_ARCH_SAVE_REGS;
+
gunichar2 *str1ptr;
gunichar2 *str2ptr;
gint32 str1len;
MonoString *
ves_icall_System_String_InternalJoin (MonoString *separator, MonoArray * value, gint32 sindex, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString * ret;
gint32 length;
gint32 pos;
MonoString *
ves_icall_System_String_InternalInsert (MonoString *me, gint32 sindex, MonoString *value)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString * ret;
gunichar2 *src;
gunichar2 *insertsrc;
MonoString *
ves_icall_System_String_InternalReplace_Char (MonoString *me, gunichar2 oldChar, gunichar2 newChar)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString *ret;
gunichar2 *src;
gunichar2 *dest;
MonoString *
ves_icall_System_String_InternalReplace_Str (MonoString *me, MonoString *oldValue, MonoString *newValue)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString *ret;
gunichar2 *src;
gunichar2 *dest;
MonoString *
ves_icall_System_String_InternalRemove (MonoString *me, gint32 sindex, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString * ret;
gint32 srclen;
gunichar2 *dest;
void
ves_icall_System_String_InternalCopyTo (MonoString *me, gint32 sindex, MonoArray *dest, gint32 dindex, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
gunichar2 *destptr = (gunichar2 *) mono_array_addr(dest, gunichar2, dindex);
gunichar2 *src = mono_string_chars(me);
MonoArray *
ves_icall_System_String_InternalSplit (MonoString *me, MonoArray *separator, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString * tmpstr;
MonoArray * retarr;
gunichar2 *src;
MonoString *
ves_icall_System_String_InternalTrim (MonoString *me, MonoArray *chars, gint32 typ)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString * ret;
gunichar2 *src, *dest;
gint32 srclen, newlen, arrlen;
gint32
ves_icall_System_String_InternalIndexOf_Char (MonoString *me, gunichar2 value, gint32 sindex, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 pos;
gunichar2 *src;
gint32
ves_icall_System_String_InternalIndexOf_Str (MonoString *me, MonoString *value, gint32 sindex, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 lencmpstr;
gint32 pos, i;
gunichar2 *src;
gint32
ves_icall_System_String_InternalIndexOfAny (MonoString *me, MonoArray *arr, gint32 sindex, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 pos;
gint32 loop;
gint32 arraysize;
gint32
ves_icall_System_String_InternalLastIndexOf_Char (MonoString *me, gunichar2 value, gint32 sindex, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 pos;
gunichar2 *src;
gint32
ves_icall_System_String_InternalLastIndexOf_Str (MonoString *me, MonoString *value, gint32 sindex, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 lencmpstr;
gint32 pos;
gunichar2 *src;
gint32
ves_icall_System_String_InternalLastIndexOfAny (MonoString *me, MonoArray *anyOf, gint32 sindex, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 pos;
gint32 loop;
gint32 arraysize;
MonoString *
ves_icall_System_String_InternalPad (MonoString *me, gint32 width, gunichar2 chr, MonoBoolean right)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString * ret;
gunichar2 *src;
gunichar2 *dest;
MonoString *
ves_icall_System_String_InternalToLower (MonoString *me)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoString * ret;
gunichar2 *src;
gunichar2 *dest;
MonoString *
ves_icall_System_String_InternalToUpper (MonoString *me)
{
+ MONO_ARCH_SAVE_REGS;
+
int i;
MonoString * ret;
gunichar2 *src;
MonoString *
ves_icall_System_String_InternalAllocateStr (gint32 length)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_string_new_size(mono_domain_get (), length);
}
void
ves_icall_System_String_InternalStrcpy_Str (MonoString *dest, gint32 destPos, MonoString *src)
{
+ MONO_ARCH_SAVE_REGS;
+
gunichar2 *srcptr;
gunichar2 *destptr;
void
ves_icall_System_String_InternalStrcpy_StrN (MonoString *dest, gint32 destPos, MonoString *src, gint32 startPos, gint32 count)
{
+ MONO_ARCH_SAVE_REGS;
+
gunichar2 *srcptr;
gunichar2 *destptr;
MonoString *
ves_icall_System_String_InternalIntern (MonoString *str)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_string_intern(str);
}
MonoString *
ves_icall_System_String_InternalIsInterned (MonoString *str)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_string_is_interned(str);
}
gint32
ves_icall_System_String_InternalCompareStr_N (MonoString *s1, gint32 i1, MonoString *s2, gint32 i2, gint32 length, MonoBoolean inCase)
{
+ MONO_ARCH_SAVE_REGS;
+
/* c translation of C# code from old string.cs.. :) */
gint32 lenstr1;
gint32 lenstr2;
gint32
ves_icall_System_String_GetHashCode (MonoString *me)
{
+ MONO_ARCH_SAVE_REGS;
+
int i, h = 0;
gunichar2 *data = mono_string_chars (me);
gunichar2
ves_icall_System_String_get_Chars (MonoString *me, gint32 idx)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_string_chars(me)[idx];
}
#define __USE_ISOC99\r
#include <math.h>\r
#include <mono/metadata/sysmath.h>\r
+#include <mono/metadata/exception.h>\r
\r
#ifndef NAN\r
# if G_BYTE_ORDER == G_BIG_ENDIAN\r
gdouble \r
ves_icall_System_Math_Sin (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return sin (x);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Cos (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return cos (x);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Tan (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return tan (x);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Sinh (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return sinh (x);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Cosh (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return cosh (x);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Tanh (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return tanh (x);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Acos (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
if (x < -1 || x > 1)\r
return NAN;\r
\r
gdouble \r
ves_icall_System_Math_Asin (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
if (x < -1 || x > 1)\r
return NAN;\r
\r
gdouble \r
ves_icall_System_Math_Atan (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return atan (x);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Atan2 (gdouble y, gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return atan2 (y, x);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Exp (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return exp (x);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Log (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
if (x == 0)\r
return -HUGE_VAL;\r
else if (x < 0)\r
gdouble \r
ves_icall_System_Math_Log10 (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
if (x == 0)\r
return -HUGE_VAL;\r
else if (x < 0)\r
gdouble \r
ves_icall_System_Math_Pow (gdouble x, gdouble y)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
return pow (x, y);\r
}\r
\r
gdouble \r
ves_icall_System_Math_Sqrt (gdouble x)\r
{\r
+ MONO_ARCH_SAVE_REGS;\r
+\r
if (x < 0)\r
return NAN;\r
\r
HANDLE ves_icall_System_Threading_Thread_Thread_internal(MonoThread *this,
MonoObject *start)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoMulticastDelegate *delegate = (MonoMulticastDelegate*)start;
guint32 (*start_func)(void *);
struct StartInfo *start_info;
void ves_icall_System_Threading_Thread_Thread_free_internal (MonoThread *this,
HANDLE thread)
{
+ MONO_ARCH_SAVE_REGS;
+
#ifdef THREAD_DEBUG
g_message (G_GNUC_PRETTY_FUNCTION ": Closing thread %p, handle %p",
this, thread);
void ves_icall_System_Threading_Thread_Start_internal(MonoThread *this,
HANDLE thread)
{
+ MONO_ARCH_SAVE_REGS;
+
#ifdef THREAD_DEBUG
g_message(G_GNUC_PRETTY_FUNCTION ": Launching thread %p", this);
#endif
void ves_icall_System_Threading_Thread_Sleep_internal(gint32 ms)
{
+ MONO_ARCH_SAVE_REGS;
+
#ifdef THREAD_DEBUG
g_message(G_GNUC_PRETTY_FUNCTION ": Sleeping for %d ms", ms);
#endif
gint32
ves_icall_System_Threading_Thread_GetDomainID (void)
{
+ MONO_ARCH_SAVE_REGS;
+
return mono_domain_get()->domain_id;
}
MonoThread *
mono_thread_current (void)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoThread *thread;
/* Find the current thread object */
gboolean ves_icall_System_Threading_Thread_Join_internal(MonoThread *this,
int ms, HANDLE thread)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean ret;
if(ms== -1) {
void ves_icall_System_Threading_Thread_SlotHash_store(MonoObject *data)
{
+ MONO_ARCH_SAVE_REGS;
+
#ifdef THREAD_DEBUG
g_message(G_GNUC_PRETTY_FUNCTION ": Storing key %p", data);
#endif
MonoObject *ves_icall_System_Threading_Thread_SlotHash_lookup(void)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoObject *data;
data=TlsGetValue(slothash_key);
gboolean ves_icall_System_Threading_Monitor_Monitor_try_enter(MonoObject *obj,
int ms)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoThreadsSync *mon;
guint32 ret;
void ves_icall_System_Threading_Monitor_Monitor_exit(MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoThreadsSync *mon;
#ifdef THREAD_LOCK_DEBUG
gboolean ves_icall_System_Threading_Monitor_Monitor_test_owner(MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoThreadsSync *mon;
gboolean ret=FALSE;
gboolean ves_icall_System_Threading_Monitor_Monitor_test_synchronised(MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoThreadsSync *mon;
gboolean ret=FALSE;
void ves_icall_System_Threading_Monitor_Monitor_pulse(MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean have_waiters;
MonoThreadsSync *mon;
void ves_icall_System_Threading_Monitor_Monitor_pulse_all(MonoObject *obj)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean have_waiters=FALSE;
MonoThreadsSync *mon;
gboolean ves_icall_System_Threading_Monitor_Monitor_wait(MonoObject *obj,
int ms)
{
+ MONO_ARCH_SAVE_REGS;
+
gboolean last_waiter;
MonoThreadsSync *mon;
guint32 save_count;
/* FIXME: exitContext isnt documented */
gboolean ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext)
{
+ MONO_ARCH_SAVE_REGS;
+
HANDLE *handles;
guint32 numhandles;
guint32 ret;
/* FIXME: exitContext isnt documented */
gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext)
{
+ MONO_ARCH_SAVE_REGS;
+
HANDLE *handles;
guint32 numhandles;
guint32 ret;
/* FIXME: exitContext isnt documented */
gboolean ves_icall_System_Threading_WaitHandle_WaitOne_internal(MonoObject *this, HANDLE handle, gint32 ms, gboolean exitContext)
{
+ MONO_ARCH_SAVE_REGS;
+
guint32 ret;
#ifdef THREAD_WAIT_DEBUG
return(TRUE);
}
-HANDLE ves_icall_System_Threading_Mutex_CreateMutex_internal (MonoBoolean owned,char *name) {
- return(CreateMutex(NULL,owned,name));
+HANDLE ves_icall_System_Threading_Mutex_CreateMutex_internal (MonoBoolean owned,char *name) {
+ MONO_ARCH_SAVE_REGS;
+
+ return(CreateMutex(NULL,owned,name));
}
void ves_icall_System_Threading_Mutex_ReleaseMutex_internal (HANDLE handle ) {
+ MONO_ARCH_SAVE_REGS;
+
ReleaseMutex(handle);
}
HANDLE ves_icall_System_Threading_Events_CreateEvent_internal (MonoBoolean manual,
MonoBoolean initial,
char *name) {
+ MONO_ARCH_SAVE_REGS;
+
return (CreateEvent(NULL,manual,initial,name));
}
gboolean ves_icall_System_Threading_Events_SetEvent_internal (HANDLE handle) {
+ MONO_ARCH_SAVE_REGS;
+
return (SetEvent(handle));
}
gboolean ves_icall_System_Threading_Events_ResetEvent_internal (HANDLE handle) {
+ MONO_ARCH_SAVE_REGS;
+
return (ResetEvent(handle));
}
gint32 ves_icall_System_Threading_Interlocked_Increment_Int (gint32 *location)
{
+ MONO_ARCH_SAVE_REGS;
+
return InterlockedIncrement (location);
}
gint64 ves_icall_System_Threading_Interlocked_Increment_Long (gint64 *location)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 lowret;
gint32 highret;
gint32 ves_icall_System_Threading_Interlocked_Decrement_Int (gint32 *location)
{
+ MONO_ARCH_SAVE_REGS;
+
return InterlockedDecrement(location);
}
gint64 ves_icall_System_Threading_Interlocked_Decrement_Long (gint64 * location)
{
+ MONO_ARCH_SAVE_REGS;
+
gint32 lowret;
gint32 highret;
gint32 ves_icall_System_Threading_Interlocked_Exchange_Int (gint32 *location1, gint32 value)
{
+ MONO_ARCH_SAVE_REGS;
+
return InterlockedExchange(location1, value);
}
MonoObject * ves_icall_System_Threading_Interlocked_Exchange_Object (MonoObject **location1, MonoObject *value)
{
+ MONO_ARCH_SAVE_REGS;
+
return (MonoObject *) InterlockedExchangePointer((gpointer *) location1, value);
}
gfloat ves_icall_System_Threading_Interlocked_Exchange_Single (gfloat *location1, gfloat value)
{
+ MONO_ARCH_SAVE_REGS;
+
IntFloatUnion val, ret;
val.fval = value;
gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int(gint32 *location1, gint32 value, gint32 comparand)
{
+ MONO_ARCH_SAVE_REGS;
+
return InterlockedCompareExchange(location1, value, comparand);
}
MonoObject * ves_icall_System_Threading_Interlocked_CompareExchange_Object (MonoObject **location1, MonoObject *value, MonoObject *comparand)
{
+ MONO_ARCH_SAVE_REGS;
+
return (MonoObject *) InterlockedCompareExchangePointer((gpointer *) location1, value, comparand);
}
gfloat ves_icall_System_Threading_Interlocked_CompareExchange_Single (gfloat *location1, gfloat value, gfloat comparand)
{
+ MONO_ARCH_SAVE_REGS;
+
IntFloatUnion val, ret, cmp;
val.fval = value;
void
ves_icall_System_Threading_Thread_Abort (MonoThread *thread, MonoObject *state)
{
+ MONO_ARCH_SAVE_REGS;
+
thread->abort_state = state;
thread->abort_exc = mono_get_exception_thread_abort ();
void
ves_icall_System_Threading_Thread_ResetAbort (void)
{
+ MONO_ARCH_SAVE_REGS;
+
MonoThread *thread = mono_thread_current ();
if (!thread->abort_exc) {
#include <mono/metadata/object.h>
#include <mono/metadata/unicode.h>
+#include <mono/metadata/exception.h>
static MonoUnicodeCategory catmap[] = {
/* G_UNICODE_CONTROL = */ Control,
double
ves_icall_System_Char_GetNumericValue (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return (double)g_unichar_digit_value (c);
}
MonoUnicodeCategory
ves_icall_System_Char_GetUnicodeCategory (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return catmap [g_unichar_type (c)];
}
gboolean
ves_icall_System_Char_IsControl (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_unichar_iscntrl (c);
}
gboolean
ves_icall_System_Char_IsDigit (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_unichar_isdigit (c);
}
gboolean
ves_icall_System_Char_IsLetter (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_unichar_isalpha (c);
}
gboolean
ves_icall_System_Char_IsLower (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_unichar_islower (c);
}
gboolean
ves_icall_System_Char_IsUpper (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_unichar_isupper (c);
}
gboolean
ves_icall_System_Char_IsNumber (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
GUnicodeType t = g_unichar_type (c);
return t == G_UNICODE_DECIMAL_NUMBER ||
t == G_UNICODE_LETTER_NUMBER ||
gboolean
ves_icall_System_Char_IsPunctuation (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_unichar_ispunct (c);
}
gboolean
ves_icall_System_Char_IsSeparator (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
GUnicodeType t = g_unichar_type (c);
return (t == G_UNICODE_LINE_SEPARATOR ||
gboolean
ves_icall_System_Char_IsSurrogate (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return (g_unichar_type (c) == G_UNICODE_SURROGATE);
}
gboolean
ves_icall_System_Char_IsSymbol (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
GUnicodeType t = g_unichar_type (c);
return (t == G_UNICODE_CURRENCY_SYMBOL ||
gboolean
ves_icall_System_Char_IsWhiteSpace (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_unichar_isspace (c);
}
gunichar2
ves_icall_System_Char_ToLower (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_unichar_tolower (c);
}
gunichar2
ves_icall_System_Char_ToUpper (gunichar2 c)
{
+ MONO_ARCH_SAVE_REGS;
+
return g_unichar_toupper (c);
}
projects / mono.git / commitdiff