mono/metadata/icall-table.h

   1 /**
   2  * \file
   3  * Copyright 2016 Microsoft
   4  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   5  */
   6 #ifndef __MONO_METADATA_ICALL_TABLE_H__
   7 #define __MONO_METADATA_ICALL_TABLE_H__
   8
   9 #include <config.h>
  10 #include <glib.h>
  11 #include <mono/utils/mono-publib.h>
  12 #include "marshal.h"
  13
  14 #define MONO_ICALL_TABLE_CALLBACKS_VERSION 2
  15
  16 typedef struct {
  17         int version;
  18         gpointer (*lookup) (MonoMethod *method, char *classname, char *methodname, char *sigstart, gboolean *uses_handles);
  19         const char* (*lookup_icall_symbol) (gpointer func);
  20 } MonoIcallTableCallbacks;
  21
  22 void
  23 mono_install_icall_table_callbacks (MonoIcallTableCallbacks *cb);
  24
  25 MONO_API void
  26 mono_icall_table_init (void);
  27
  28 // It helps for types to be single tokens, though this can be relaxed in some places.
  29 // Marshaling a "ptr" does nothing -- just pass it on unchanged.
  30 // Marshaling a "ref" also does nothing at this layer, but
  31 // creates a handle in  marshal-ilgen.c.
  32 // "ref" means "can be an interior pointer".
  33 // "ptr" means "to a local".
  34 // It is generally difficult to know, and "ref" is safer.
  35 // Presently it does not matter.
  36 typedef gint32  *gint32_ptr;
  37 typedef guchar *guchar_ptr;
  38 typedef const guchar *const_guchar_ptr;
  39 typedef gpointer *gpointer_ptr;
  40 typedef const char *const_char_ptr;
  41 typedef char *char_ptr;
  42 typedef char **char_ptr_ptr;
  43 typedef gunichar2 *gunichar2_ptr;
  44 typedef const gunichar2 *const_gunichar2_ptr;
  45 typedef int *int_ptr;
  46 typedef int **int_ptr_ref;
  47 typedef guint8 **guint8_ptr_ref;
  48 typedef GPtrArray *GPtrArray_ptr;
  49 typedef MonoAssemblyName *MonoAssemblyName_ptr;
  50 typedef MonoBoolean *MonoBoolean_ptr;
  51 typedef MonoClass *MonoClass_ptr;
  52 typedef MonoClassField *MonoClassField_ptr;
  53 typedef MonoEvent *MonoEvent_ptr;
  54 typedef MonoImage *MonoImage_ptr;
  55 typedef MonoMethod *MonoMethod_ptr;
  56 typedef MonoNativeOverlapped *MonoNativeOverlapped_ptr;
  57 typedef MonoProperty *MonoProperty_ptr;
  58 typedef MonoPropertyInfo *MonoPropertyInfo_ref;
  59 typedef MonoType *MonoType_ptr;
  60 typedef MonoTypedRef *MonoTypedRef_ptr;
  61 typedef MonoStackCrawlMark *MonoStackCrawlMark_ptr;
  62 typedef MonoVTable *MonoVTable_ptr;
  63 typedef unsigned *unsigned_ptr;
  64 typedef mono_unichar2 *mono_unichar2_ptr;
  65 typedef mono_unichar4 *mono_unichar4_ptr;
  66 typedef WSABUF *WSABUF_ptr;
  67
  68 typedef char **char_ptr_ref;
  69 typedef gint32  *gint32_ref;
  70 typedef gint64  *gint64_ref;
  71 typedef gpointer *gpointer_ref;
  72 typedef gsize *gsize_ref;
  73 typedef guint32 *guint32_ref;
  74 typedef guint64 *guint64_ref;
  75 typedef int *int_ref;
  76 typedef gint32 *gint32_ref;
  77 typedef MonoAssemblyName *MonoAssemblyName_ref;
  78 typedef MonoBoolean *MonoBoolean_ref;
  79 typedef MonoClassField *MonoClassField_ref;
  80 typedef MonoEvent *MonoEvent_ref;
  81 typedef MonoEventInfo *MonoEventInfo_ref;
  82 typedef MonoMethod *MonoMethod_ref;
  83 typedef MonoMethodInfo *MonoMethodInfo_ref;
  84 typedef MonoNativeOverlapped *MonoNativeOverlapped_ref;
  85 typedef MonoResolveTokenError *MonoResolveTokenError_ref;
  86 typedef MonoType *MonoType_ref;
  87 typedef MonoTypedRef *MonoTypedRef_ref;
  88 typedef MonoW32ProcessInfo *MonoW32ProcessInfo_ref;
  89 typedef MonoGenericParamInfo *MonoGenericParamInfo_ptr;
  90
  91 // Maybe do this in TYPED_HANDLE_DECL.
  92 typedef MonoArray MonoArrayOut;
  93 typedef MonoArray MonoArrayInOut;
  94 typedef MonoObject MonoObjectOut;
  95 typedef MonoObject MonoObjectInOut;
  96 typedef MonoObjectHandle MonoObjectOutHandle;
  97 typedef MonoObjectHandle MonoObjectInOutHandle;
  98 typedef MonoArrayHandle MonoArrayOutHandle;
  99 typedef MonoArrayHandle MonoArrayInOutHandle;
 100 typedef MonoString MonoStringOut;
 101 typedef MonoStringHandle MonoStringOutHandle;
 102 typedef MonoReflectionModule MonoReflectionModuleOut;
 103 typedef MonoReflectionModuleHandle MonoReflectionModuleOutHandle;
 104
 105 // How the arguments and return value of an icall should be wrapped.
 106 // The names and meanings are from marshal-ilgen.c.
 107 //      ICALL_HANDLES_WRAP_NONE
 108 //      ICALL_HANDLES_WRAP_OBJ
 109 //      ICALL_HANDLES_WRAP_OBJ_INOUT
 110 //      ICALL_HANDLES_WRAP_OBJ_OUT
 111 //      ICALL_HANDLES_WRAP_VALUETYPE_REF
 112 //
 113 // In the present implementation, all that matters is, handle-or-not,
 114 // in and out and inout are the same, and none and valuetype_ref are the same.
 115 // Handle creation is in marshal-ilgen.c.
 116
 117 // Map a type to a type class: Void and above.
 118 #define MONO_HANDLE_TYPE_WRAP_void                      Void
 119 #define MONO_HANDLE_TYPE_WRAP_GPtrArray_ptr             ICALL_HANDLES_WRAP_NONE
 120 #define MONO_HANDLE_TYPE_WRAP_MonoBoolean               ICALL_HANDLES_WRAP_NONE
 121 #define MONO_HANDLE_TYPE_WRAP_const_gunichar2_ptr       ICALL_HANDLES_WRAP_NONE
 122 #define MONO_HANDLE_TYPE_WRAP_gunichar2_ptr             ICALL_HANDLES_WRAP_NONE
 123 #define MONO_HANDLE_TYPE_WRAP_gint                      ICALL_HANDLES_WRAP_NONE
 124 #define MONO_HANDLE_TYPE_WRAP_gint32                    ICALL_HANDLES_WRAP_NONE
 125 #define MONO_HANDLE_TYPE_WRAP_gint64                    ICALL_HANDLES_WRAP_NONE
 126 #define MONO_HANDLE_TYPE_WRAP_gpointer                  ICALL_HANDLES_WRAP_NONE
 127 #define MONO_HANDLE_TYPE_WRAP_gconstpointer             ICALL_HANDLES_WRAP_NONE
 128 #define MONO_HANDLE_TYPE_WRAP_gsize                     ICALL_HANDLES_WRAP_NONE
 129 #define MONO_HANDLE_TYPE_WRAP_gssize                    ICALL_HANDLES_WRAP_NONE
 130 #define MONO_HANDLE_TYPE_WRAP_guchar_ptr                ICALL_HANDLES_WRAP_NONE
 131 #define MONO_HANDLE_TYPE_WRAP_guint                     ICALL_HANDLES_WRAP_NONE
 132 #define MONO_HANDLE_TYPE_WRAP_const_guchar_ptr          ICALL_HANDLES_WRAP_NONE
 133 #define MONO_HANDLE_TYPE_WRAP_guint32                   ICALL_HANDLES_WRAP_NONE
 134 #define MONO_HANDLE_TYPE_WRAP_guint64                   ICALL_HANDLES_WRAP_NONE
 135 #define MONO_HANDLE_TYPE_WRAP_int                       ICALL_HANDLES_WRAP_NONE
 136 #define MONO_HANDLE_TYPE_WRAP_uint                      ICALL_HANDLES_WRAP_NONE
 137 #define MONO_HANDLE_TYPE_WRAP_PInfo                     ICALL_HANDLES_WRAP_NONE
 138 #define MONO_HANDLE_TYPE_WRAP_mono_bstr                 ICALL_HANDLES_WRAP_NONE
 139 #define MONO_HANDLE_TYPE_WRAP_mono_bstr_const           ICALL_HANDLES_WRAP_NONE
 140 #define MONO_HANDLE_TYPE_WRAP_unsigned_ptr              ICALL_HANDLES_WRAP_NONE
 141 #define MONO_HANDLE_TYPE_WRAP_mono_unichar2_ptr         ICALL_HANDLES_WRAP_NONE
 142 #define MONO_HANDLE_TYPE_WRAP_mono_unichar4_ptr         ICALL_HANDLES_WRAP_NONE
 143 #define MONO_HANDLE_TYPE_WRAP_MonoImage_ptr             ICALL_HANDLES_WRAP_NONE
 144 #define MONO_HANDLE_TYPE_WRAP_MonoClassField_ptr        ICALL_HANDLES_WRAP_NONE
 145 #define MONO_HANDLE_TYPE_WRAP_MonoMarshalNative         ICALL_HANDLES_WRAP_NONE
 146 #define MONO_HANDLE_TYPE_WRAP_MonoProperty_ptr          ICALL_HANDLES_WRAP_NONE
 147 #define MONO_HANDLE_TYPE_WRAP_MonoProtocolType          ICALL_HANDLES_WRAP_NONE
 148 #define MONO_HANDLE_TYPE_WRAP_size_t                    ICALL_HANDLES_WRAP_NONE
 149 #define MONO_HANDLE_TYPE_WRAP_MonoVTable_ptr            ICALL_HANDLES_WRAP_NONE
 150 #define MONO_HANDLE_TYPE_WRAP_WSABUF_ptr                ICALL_HANDLES_WRAP_NONE
 151
 152 #define MONO_HANDLE_TYPE_WRAP_MonoAssemblyName_ref      ICALL_HANDLES_WRAP_VALUETYPE_REF
 153 #define MONO_HANDLE_TYPE_WRAP_MonoBoolean_ref           ICALL_HANDLES_WRAP_VALUETYPE_REF
 154 #define MONO_HANDLE_TYPE_WRAP_MonoClassField_ref        ICALL_HANDLES_WRAP_VALUETYPE_REF
 155 #define MONO_HANDLE_TYPE_WRAP_MonoEvent_ref             ICALL_HANDLES_WRAP_VALUETYPE_REF
 156 #define MONO_HANDLE_TYPE_WRAP_MonoEventInfo_ref         ICALL_HANDLES_WRAP_VALUETYPE_REF
 157 #define MONO_HANDLE_TYPE_WRAP_MonoMethod_ref            ICALL_HANDLES_WRAP_VALUETYPE_REF
 158 #define MONO_HANDLE_TYPE_WRAP_MonoMethodInfo_ref        ICALL_HANDLES_WRAP_VALUETYPE_REF
 159 #define MONO_HANDLE_TYPE_WRAP_MonoNativeOverlapped_ref  ICALL_HANDLES_WRAP_VALUETYPE_REF
 160 #define MONO_HANDLE_TYPE_WRAP_MonoPropertyInfo_ref      ICALL_HANDLES_WRAP_VALUETYPE_REF
 161 #define MONO_HANDLE_TYPE_WRAP_MonoType_ref              ICALL_HANDLES_WRAP_VALUETYPE_REF
 162 #define MONO_HANDLE_TYPE_WRAP_MonoTypedRef_ref          ICALL_HANDLES_WRAP_VALUETYPE_REF
 163 #define MONO_HANDLE_TYPE_WRAP_gint32_ref                ICALL_HANDLES_WRAP_VALUETYPE_REF
 164 #define MONO_HANDLE_TYPE_WRAP_gint64_ref                ICALL_HANDLES_WRAP_VALUETYPE_REF
 165 #define MONO_HANDLE_TYPE_WRAP_gpointer_ref              ICALL_HANDLES_WRAP_VALUETYPE_REF
 166 #define MONO_HANDLE_TYPE_WRAP_gsize_ref                 ICALL_HANDLES_WRAP_VALUETYPE_REF
 167 #define MONO_HANDLE_TYPE_WRAP_guint32_ref               ICALL_HANDLES_WRAP_VALUETYPE_REF
 168 #define MONO_HANDLE_TYPE_WRAP_guint64_ref               ICALL_HANDLES_WRAP_VALUETYPE_REF
 169 #define MONO_HANDLE_TYPE_WRAP_int_ref                   ICALL_HANDLES_WRAP_VALUETYPE_REF
 170 #define MONO_HANDLE_TYPE_WRAP_gint32_ref                        ICALL_HANDLES_WRAP_VALUETYPE_REF
 171 #define MONO_HANDLE_TYPE_WRAP_int_ptr_ref               ICALL_HANDLES_WRAP_VALUETYPE_REF
 172 #define MONO_HANDLE_TYPE_WRAP_char_ptr_ref              ICALL_HANDLES_WRAP_VALUETYPE_REF
 173 #define MONO_HANDLE_TYPE_WRAP_guint8_ptr_ref            ICALL_HANDLES_WRAP_VALUETYPE_REF
 174 #define MONO_HANDLE_TYPE_WRAP_MonoResolveTokenError_ref ICALL_HANDLES_WRAP_VALUETYPE_REF
 175
 176 #define MONO_HANDLE_TYPE_WRAP_char_ptr                  ICALL_HANDLES_WRAP_NONE
 177 #define MONO_HANDLE_TYPE_WRAP_const_char_ptr            ICALL_HANDLES_WRAP_NONE
 178 #define MONO_HANDLE_TYPE_WRAP_MonoClass_ptr             ICALL_HANDLES_WRAP_NONE
 179 #define MONO_HANDLE_TYPE_WRAP_MonoEvent_ptr             ICALL_HANDLES_WRAP_NONE
 180 #define MONO_HANDLE_TYPE_WRAP_MonoGenericParamInfo_ptr  ICALL_HANDLES_WRAP_NONE
 181 #define MONO_HANDLE_TYPE_WRAP_MonoMethod_ptr            ICALL_HANDLES_WRAP_NONE
 182 #define MONO_HANDLE_TYPE_WRAP_MonoNativeOverlapped_ptr  ICALL_HANDLES_WRAP_NONE
 183 #define MONO_HANDLE_TYPE_WRAP_MonoType_ptr              ICALL_HANDLES_WRAP_NONE
 184 #define MONO_HANDLE_TYPE_WRAP_MonoTypedRef_ptr          ICALL_HANDLES_WRAP_NONE
 185 #define MONO_HANDLE_TYPE_WRAP_MonoStackCrawlMark_ptr    ICALL_HANDLES_WRAP_NONE
 186 #define MONO_HANDLE_TYPE_WRAP_gint32_ptr                ICALL_HANDLES_WRAP_NONE
 187 #define MONO_HANDLE_TYPE_WRAP_gpointer_ptr              ICALL_HANDLES_WRAP_NONE
 188
 189 // Please keep this sorted (grep ICALL_HANDLES_WRAP_OBJ$ | sort)
 190 #define MONO_HANDLE_TYPE_WRAP_MonoAppContext                    ICALL_HANDLES_WRAP_OBJ
 191 #define MONO_HANDLE_TYPE_WRAP_MonoAppDomain                     ICALL_HANDLES_WRAP_OBJ
 192 #define MONO_HANDLE_TYPE_WRAP_MonoAppDomainSetup                ICALL_HANDLES_WRAP_OBJ
 193 #define MONO_HANDLE_TYPE_WRAP_MonoArray                         ICALL_HANDLES_WRAP_OBJ
 194 #define MONO_HANDLE_TYPE_WRAP_MonoComInteropProxy               ICALL_HANDLES_WRAP_OBJ
 195 #define MONO_HANDLE_TYPE_WRAP_MonoComObject                     ICALL_HANDLES_WRAP_OBJ
 196 #define MONO_HANDLE_TYPE_WRAP_MonoDelegate                      ICALL_HANDLES_WRAP_OBJ
 197 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionDynamicMethod       ICALL_HANDLES_WRAP_OBJ
 198 #define MONO_HANDLE_TYPE_WRAP_MonoException                     ICALL_HANDLES_WRAP_OBJ
 199 #define MONO_HANDLE_TYPE_WRAP_MonoInternalThread                ICALL_HANDLES_WRAP_OBJ
 200 #define MONO_HANDLE_TYPE_WRAP_MonoObject                        ICALL_HANDLES_WRAP_OBJ
 201 #define MONO_HANDLE_TYPE_WRAP_MonoManifestResourceInfo          ICALL_HANDLES_WRAP_OBJ
 202 #define MONO_HANDLE_TYPE_WRAP_MonoMulticastDelegate             ICALL_HANDLES_WRAP_OBJ
 203 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionAssembly            ICALL_HANDLES_WRAP_OBJ
 204 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionAssemblyBuilder     ICALL_HANDLES_WRAP_OBJ
 205 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionEvent               ICALL_HANDLES_WRAP_OBJ
 206 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionMonoEvent           ICALL_HANDLES_WRAP_OBJ
 207 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionField               ICALL_HANDLES_WRAP_OBJ
 208 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionMarshalAsAttribute  ICALL_HANDLES_WRAP_OBJ
 209 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionMethod              ICALL_HANDLES_WRAP_OBJ
 210 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionMethodBody          ICALL_HANDLES_WRAP_OBJ
 211 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionModule              ICALL_HANDLES_WRAP_OBJ
 212 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionModuleBuilder       ICALL_HANDLES_WRAP_OBJ
 213 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionParameter           ICALL_HANDLES_WRAP_OBJ
 214 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionProperty            ICALL_HANDLES_WRAP_OBJ
 215 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionSigHelper           ICALL_HANDLES_WRAP_OBJ
 216 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionType                ICALL_HANDLES_WRAP_OBJ
 217 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionTypeBuilder         ICALL_HANDLES_WRAP_OBJ
 218 #define MONO_HANDLE_TYPE_WRAP_MonoString                        ICALL_HANDLES_WRAP_OBJ
 219 #define MONO_HANDLE_TYPE_WRAP_MonoStringBuilder                 ICALL_HANDLES_WRAP_OBJ
 220 #define MONO_HANDLE_TYPE_WRAP_MonoThreadObject                  ICALL_HANDLES_WRAP_OBJ
 221 #define MONO_HANDLE_TYPE_WRAP_MonoW32ProcessStartInfo           ICALL_HANDLES_WRAP_OBJ
 222
 223 #define MONO_HANDLE_TYPE_WRAP_MonoObjectOut             ICALL_HANDLES_WRAP_OBJ_OUT
 224 #define MONO_HANDLE_TYPE_WRAP_MonoStringOut             ICALL_HANDLES_WRAP_OBJ_OUT
 225 #define MONO_HANDLE_TYPE_WRAP_MonoArrayOut              ICALL_HANDLES_WRAP_OBJ_OUT
 226 #define MONO_HANDLE_TYPE_WRAP_MonoReflectionModuleOut   ICALL_HANDLES_WRAP_OBJ_OUT
 227
 228 #define MONO_HANDLE_TYPE_WRAP_MonoW32ProcessInfo_ref    ICALL_HANDLES_WRAP_VALUETYPE_REF
 229
 230 // These are rare, and could be eliminated.
 231 // They could be return values, or just separate out parameters.
 232 #define MONO_HANDLE_TYPE_WRAP_MonoObjectInOut   ICALL_HANDLES_WRAP_OBJ_INOUT
 233 #define MONO_HANDLE_TYPE_WRAP_MonoArrayInOut    ICALL_HANDLES_WRAP_OBJ_INOUT
 234
 235 // Do macro_prefix for type type, mapping type to a type class.
 236 // Note that the macro can further be followed by parameters.
 237 #define MONO_HANDLE_DO3(macro_prefix, type) macro_prefix ## type
 238 #define MONO_HANDLE_DO2(macro_prefix, type) MONO_HANDLE_DO3 (macro_prefix, type)
 239 #define MONO_HANDLE_DO(macro_prefix, type)  MONO_HANDLE_DO2 (macro_prefix, MONO_HANDLE_TYPE_WRAP_ ## type)
 240
 241 #define MONO_HANDLE_RETURN_BEGIN(type)                          MONO_HANDLE_DO (MONO_HANDLE_RETURN_BEGIN_, type) (type)
 242 #define MONO_HANDLE_RETURN_BEGIN_Void(type)                     /* nothing */
 243 #define MONO_HANDLE_RETURN_BEGIN_ICALL_HANDLES_WRAP_NONE(type)  type icall_result =
 244 #define MONO_HANDLE_RETURN_BEGIN_ICALL_HANDLES_WRAP_OBJ(type)   type ## Handle icall_result =
 245
 246 #define MONO_HANDLE_RETURN_END(type)                            MONO_HANDLE_DO (MONO_HANDLE_RETURN_END_, type);
 247 #define MONO_HANDLE_RETURN_END_Void                             HANDLE_FUNCTION_RETURN ()
 248 #define MONO_HANDLE_RETURN_END_ICALL_HANDLES_WRAP_NONE          HANDLE_FUNCTION_RETURN_VAL (icall_result)
 249 #define MONO_HANDLE_RETURN_END_ICALL_HANDLES_WRAP_OBJ           HANDLE_FUNCTION_RETURN_OBJ (icall_result)
 250
 251 // Convert raw handles to typed handles, just by casting and copying a pointer.
 252 #define MONO_HANDLE_MARSHAL(type, n)                                    MONO_HANDLE_DO (MONO_HANDLE_MARSHAL_, type) (type, n)
 253 #define MONO_HANDLE_MARSHAL_ICALL_HANDLES_WRAP_NONE(type, n)            a ## n
 254 #define MONO_HANDLE_MARSHAL_ICALL_HANDLES_WRAP_OBJ(type, n)             *(type ## Handle*)&a ## n
 255 #define MONO_HANDLE_MARSHAL_ICALL_HANDLES_WRAP_OBJ_OUT(type, n)         *(type ## Handle*)&a ## n
 256 #define MONO_HANDLE_MARSHAL_ICALL_HANDLES_WRAP_OBJ_INOUT(type, n)       *(type ## Handle*)&a ## n
 257 #define MONO_HANDLE_MARSHAL_ICALL_HANDLES_WRAP_VALUETYPE_REF(type, n)   a ## n
 258
 259 // Declare and initialize a local for an object in, out, inout parameters, upon input.
 260 #define MONO_HANDLE_REGISTER_ICALL_LOCALS(type, n)                                      MONO_HANDLE_DO (MONO_HANDLE_REGISTER_ICALL_LOCALS_, type) (type, n)
 261 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_ICALL_HANDLES_WRAP_NONE(type, n)              /* nothing */
 262 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_ICALL_HANDLES_WRAP_OBJ(type, n)               type ## Handle a ## n = MONO_HANDLE_NEW (type, a ## n ## _raw);
 263 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_ICALL_HANDLES_WRAP_OBJ_OUT(type, n)           unused_untested_looks_correct1 type ## Handle a ## n = MONO_HANDLE_NEW (type, NULL);
 264 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_ICALL_HANDLES_WRAP_OBJ_INOUT(type, n)         unused_untested_looks_correct2 type ## Handle a ## n = MONO_HANDLE_NEW (type, *a ## n ## _raw);
 265 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_ICALL_HANDLES_WRAP_VALUETYPE_REF(type, n)     FIXME restore mono_icall_handle_new_interior from e8b037642104527bd9b9ba70d502210b9c12d2b8 \
 266                                                                                         type ## Handle a ## n = mono_icall_handle_new_interior (a ## n ## _raw);
 267 // Produce all the locals, i.e. up to one per parameter.
 268 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_0()                                   /* nothing  */
 269 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_1(t0)                                 MONO_HANDLE_REGISTER_ICALL_LOCALS (t0, 0)
 270 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_2(t0, t1)                             MONO_HANDLE_REGISTER_ICALL_LOCALS_1 (t0)                                MONO_HANDLE_REGISTER_ICALL_LOCALS (t1, 1)
 271 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_3(t0, t1, t2)                         MONO_HANDLE_REGISTER_ICALL_LOCALS_2 (t0, t1)                            MONO_HANDLE_REGISTER_ICALL_LOCALS (t2, 2)
 272 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_4(t0, t1, t2, t3)                     MONO_HANDLE_REGISTER_ICALL_LOCALS_3 (t0, t1, t2)                        MONO_HANDLE_REGISTER_ICALL_LOCALS (t3, 3)
 273 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_5(t0, t1, t2, t3, t4)                 MONO_HANDLE_REGISTER_ICALL_LOCALS_4 (t0, t1, t2, t3)                    MONO_HANDLE_REGISTER_ICALL_LOCALS (t4, 4)
 274 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_6(t0, t1, t2, t3, t4, t5)             MONO_HANDLE_REGISTER_ICALL_LOCALS_5 (t0, t1, t2, t3, t4)                MONO_HANDLE_REGISTER_ICALL_LOCALS (t5, 5)
 275 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_7(t0, t1, t2, t3, t4, t5, t6)         MONO_HANDLE_REGISTER_ICALL_LOCALS_6 (t0, t1, t2, t3, t4, t5)            MONO_HANDLE_REGISTER_ICALL_LOCALS (t6, 6)
 276 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_8(t0, t1, t2, t3, t4, t5, t6, t7)     MONO_HANDLE_REGISTER_ICALL_LOCALS_7 (t0, t1, t2, t3, t4, t5, t6)        MONO_HANDLE_REGISTER_ICALL_LOCALS (t7, 7)
 277 #define MONO_HANDLE_REGISTER_ICALL_LOCALS_9(t0, t1, t2, t3, t4, t5, t6, t7, t8) MONO_HANDLE_REGISTER_ICALL_LOCALS_8 (t0, t1, t2, t3, t4, t5, t6, t7)    MONO_HANDLE_REGISTER_ICALL_LOCALS (t8, 8)
 278
 279 // Convert a typed handle to raw pointer upon output.
 280 #define MONO_HANDLE_REGISTER_ICALL_OUT(type, n)                                 MONO_HANDLE_DO (MONO_HANDLE_REGISTER_ICALL_OUT_, type) (type, n)
 281 #define MONO_HANDLE_REGISTER_ICALL_OUT_ICALL_HANDLES_WRAP_NONE(type, n)         /* nothing */
 282 #define MONO_HANDLE_REGISTER_ICALL_OUT_ICALL_HANDLES_WRAP_OBJ(type, n)          /* nothing */
 283 #define MONO_HANDLE_REGISTER_ICALL_OUT_ICALL_HANDLES_WRAP_OBJ_OUT(type, n)      unused_untested_looks_correct3 *a ## n ## _raw = MONO_HANDLE_RAW (a ## n);
 284 #define MONO_HANDLE_REGISTER_ICALL_OUT_ICALL_HANDLES_WRAP_OBJ_INOUT             unused_untested_looks_correct4 *a ## n ## _raw = MONO_HANDLE_RAW (a ## n);
 285 #define MONO_HANDLE_REGISTER_ICALL_OUT_ICALL_HANDLES_VALUETYPE_REF(type, n)     /* nothing */
 286
 287 // Convert all the typed handles to raw pointers upon output, i.e. up to one per parameter.
 288 #define MONO_HANDLE_REGISTER_ICALL_OUT_0()                                      /* nothing  */
 289 #define MONO_HANDLE_REGISTER_ICALL_OUT_1(t0)                                    MONO_HANDLE_REGISTER_ICALL_OUT (t0, 0)
 290 #define MONO_HANDLE_REGISTER_ICALL_OUT_2(t0, t1)                                MONO_HANDLE_REGISTER_ICALL_OUT_1 (t0)                                   MONO_HANDLE_REGISTER_ICALL_OUT (t1, 1)
 291 #define MONO_HANDLE_REGISTER_ICALL_OUT_3(t0, t1, t2)                            MONO_HANDLE_REGISTER_ICALL_OUT_2 (t0, t1)                               MONO_HANDLE_REGISTER_ICALL_OUT (t2, 2)
 292 #define MONO_HANDLE_REGISTER_ICALL_OUT_4(t0, t1, t2, t3)                        MONO_HANDLE_REGISTER_ICALL_OUT_3 (t0, t1, t2)                           MONO_HANDLE_REGISTER_ICALL_OUT (t3, 3)
 293 #define MONO_HANDLE_REGISTER_ICALL_OUT_5(t0, t1, t2, t3, t4)                    MONO_HANDLE_REGISTER_ICALL_OUT_4 (t0, t1, t2, t3)                       MONO_HANDLE_REGISTER_ICALL_OUT (t4, 4)
 294 #define MONO_HANDLE_REGISTER_ICALL_OUT_6(t0, t1, t2, t3, t4, t5)                MONO_HANDLE_REGISTER_ICALL_OUT_5 (t0, t1, t2, t3, t4)                   MONO_HANDLE_REGISTER_ICALL_OUT (t5, 5)
 295 #define MONO_HANDLE_REGISTER_ICALL_OUT_7(t0, t1, t2, t3, t4, t5, t6)            MONO_HANDLE_REGISTER_ICALL_OUT_6 (t0, t1, t2, t3, t4, t5)               MONO_HANDLE_REGISTER_ICALL_OUT (t6, 6)
 296 #define MONO_HANDLE_REGISTER_ICALL_OUT_8(t0, t1, t2, t3, t4, t5, t6, t7)        MONO_HANDLE_REGISTER_ICALL_OUT_7 (t0, t1, t2, t3, t4, t5, t6)           MONO_HANDLE_REGISTER_ICALL_OUT (t7, 7)
 297 #define MONO_HANDLE_REGISTER_ICALL_OUT_9(t0, t1, t2, t3, t4, t5, t6, t7, t8)    MONO_HANDLE_REGISTER_ICALL_OUT_8 (t0, t1, t2, t3, t4, t5, t6, t7)       MONO_HANDLE_REGISTER_ICALL_OUT (t8, 8)
 298
 299 #define MONO_HANDLE_TYPE_TYPED(type)                                    MONO_HANDLE_DO (MONO_HANDLE_TYPE_TYPED_, type) (type)
 300 #define MONO_HANDLE_TYPE_TYPED_Void(type)                               type
 301 #define MONO_HANDLE_TYPE_TYPED_ICALL_HANDLES_WRAP_NONE(type)            type
 302 #define MONO_HANDLE_TYPE_TYPED_ICALL_HANDLES_WRAP_OBJ(type)             type ## Handle
 303 #define MONO_HANDLE_TYPE_TYPED_ICALL_HANDLES_WRAP_OBJ_OUT(type)         type ## Handle
 304 #define MONO_HANDLE_TYPE_TYPED_ICALL_HANDLES_WRAP_OBJ_INOUT(type)       type ## Handle
 305 #define MONO_HANDLE_TYPE_TYPED_ICALL_HANDLES_WRAP_VALUETYPE_REF(type)   type
 306
 307 // Map a type to a raw handle, or itself.
 308 #define MONO_HANDLE_TYPE_RAWHANDLE(type)                                        MONO_HANDLE_DO (MONO_HANDLE_TYPE_RAWHANDLE_, type) (type)
 309 #define MONO_HANDLE_TYPE_RAWHANDLE_Void(type)                                   type
 310 #define MONO_HANDLE_TYPE_RAWHANDLE_ICALL_HANDLES_WRAP_NONE(type)                type
 311 #define MONO_HANDLE_TYPE_RAWHANDLE_ICALL_HANDLES_WRAP_OBJ(type)                 MonoRawHandle
 312 #define MONO_HANDLE_TYPE_RAWHANDLE_ICALL_HANDLES_WRAP_OBJ_OUT(type)             MonoRawHandle
 313 #define MONO_HANDLE_TYPE_RAWHANDLE_ICALL_HANDLES_WRAP_OBJ_INOUT(type)           MonoRawHandle
 314 #define MONO_HANDLE_TYPE_RAWHANDLE_ICALL_HANDLES_WRAP_VALUETYPE_REF(type)       type
 315
 316 // Map a type to a raw pointer, or itself.
 317 #define MONO_HANDLE_TYPE_RAWPOINTER(type)                                       MONO_HANDLE_DO (MONO_HANDLE_TYPE_RAWPOINTER_, type) (type)
 318 #define MONO_HANDLE_TYPE_RAWPOINTER_Void(type)                                  type
 319 #define MONO_HANDLE_TYPE_RAWPOINTER_ICALL_HANDLES_WRAP_NONE(type)               type
 320 #define MONO_HANDLE_TYPE_RAWPOINTER_ICALL_HANDLES_WRAP_OBJ(type)                type*
 321 // Only used for return types.
 322 //#define MONO_HANDLE_TYPE_RAWPOINTER_ICALL_HANDLES_WRAP_OBJ_OUT(type)          type*
 323 //#define MONO_HANDLE_TYPE_RAWPOINTER_ICALL_HANDLES_WRAP_OBJ_INOUT(type)        type*
 324 #define MONO_HANDLE_TYPE_RAWPOINTER_ICALL_HANDLES_WRAP_VALUETYPE_REF(type)      type
 325
 326 // Type/name in raw handle prototype and implementation.
 327 #define MONO_HANDLE_ARG_RAWHANDLE(type, n)                                      MONO_HANDLE_DO (MONO_HANDLE_ARG_RAWHANDLE_, type) (type, n)
 328 #define MONO_HANDLE_ARG_RAWHANDLE_ICALL_HANDLES_WRAP_NONE(type, n)              MONO_HANDLE_TYPE_RAWHANDLE (type) a ## n
 329 #define MONO_HANDLE_ARG_RAWHANDLE_ICALL_HANDLES_WRAP_OBJ(type, n)               MONO_HANDLE_TYPE_RAWHANDLE (type) a ## n
 330 #define MONO_HANDLE_ARG_RAWHANDLE_ICALL_HANDLES_WRAP_OBJ_OUT(type, n)           MONO_HANDLE_TYPE_RAWHANDLE (type) a ## n
 331 #define MONO_HANDLE_ARG_RAWHANDLE_ICALL_HANDLES_WRAP_OBJ_INOUT(type, n) MONO_HANDLE_TYPE_RAWHANDLE (type) a ## n
 332 #define MONO_HANDLE_ARG_RAWHANDLE_ICALL_HANDLES_WRAP_VALUETYPE_REF(type, n)     MONO_HANDLE_TYPE_RAWHANDLE (type) a ## n
 333
 334 // Type/name in raw pointer prototype and implementation.
 335 #define MONO_HANDLE_ARG_RAWPOINTER(type, n)                                     MONO_HANDLE_DO (MONO_HANDLE_ARG_RAWPOINTER_, type) (type, n)
 336 #define MONO_HANDLE_ARG_RAWPOINTER_ICALL_HANDLES_WRAP_NONE(type, n)             MONO_HANDLE_TYPE_RAWPOINTER (type) a ## n
 337 #define MONO_HANDLE_ARG_RAWPOINTER_ICALL_HANDLES_WRAP_OBJ(type, n)              MONO_HANDLE_TYPE_RAWPOINTER (type) a ## n ## _raw
 338 #define MONO_HANDLE_ARG_RAWPOINTER_ICALL_HANDLES_WRAP_OBJ_OUT(type, n)          unused_untested_looks_correct5 MONO_HANDLE_TYPE_RAWPOINTER (type) a ## n ## _raw
 339 #define MONO_HANDLE_ARG_RAWPOINTER_ICALL_HANDLES_WRAP_OBJ_INOUT(type, n)        unused_untested_looks_correct6 MONO_HANDLE_TYPE_RAWPOINTER (type) a ## n ## _raw
 340 #define MONO_HANDLE_ARG_RAWPOINTER_ICALL_HANDLES_WRAP_VALUETYPE_REF(type, n)    FIXME //MONO_HANDLE_TYPE_RAWPOINTER (type) a ## n
 341
 342 // Generate a parameter list, types only, for a function accepting/returning typed handles.
 343 #define MONO_HANDLE_FOREACH_TYPE_TYPED_0()                                   /* nothing */
 344 #define MONO_HANDLE_FOREACH_TYPE_TYPED_1(t0)                                 MONO_HANDLE_TYPE_TYPED (t0)
 345 #define MONO_HANDLE_FOREACH_TYPE_TYPED_2(t0, t1)                             MONO_HANDLE_FOREACH_TYPE_TYPED_1 (t0)                              ,MONO_HANDLE_TYPE_TYPED (t1)
 346 #define MONO_HANDLE_FOREACH_TYPE_TYPED_3(t0, t1, t2)                         MONO_HANDLE_FOREACH_TYPE_TYPED_2 (t0, t1)                          ,MONO_HANDLE_TYPE_TYPED (t2)
 347 #define MONO_HANDLE_FOREACH_TYPE_TYPED_4(t0, t1, t2, t3)                     MONO_HANDLE_FOREACH_TYPE_TYPED_3 (t0, t1, t2)                      ,MONO_HANDLE_TYPE_TYPED (t3)
 348 #define MONO_HANDLE_FOREACH_TYPE_TYPED_5(t0, t1, t2, t3, t4)                 MONO_HANDLE_FOREACH_TYPE_TYPED_4 (t0, t1, t2, t3)                  ,MONO_HANDLE_TYPE_TYPED (t4)
 349 #define MONO_HANDLE_FOREACH_TYPE_TYPED_6(t0, t1, t2, t3, t4, t5)             MONO_HANDLE_FOREACH_TYPE_TYPED_5 (t0, t1, t2, t3, t4)              ,MONO_HANDLE_TYPE_TYPED (t5)
 350 #define MONO_HANDLE_FOREACH_TYPE_TYPED_7(t0, t1, t2, t3, t4, t5, t6)         MONO_HANDLE_FOREACH_TYPE_TYPED_6 (t0, t1, t2, t3, t4, t5)          ,MONO_HANDLE_TYPE_TYPED (t6)
 351 #define MONO_HANDLE_FOREACH_TYPE_TYPED_8(t0, t1, t2, t3, t4, t5, t6, t7)     MONO_HANDLE_FOREACH_TYPE_TYPED_7 (t0, t1, t2, t3, t4, t5, t6)      ,MONO_HANDLE_TYPE_TYPED (t7)
 352 #define MONO_HANDLE_FOREACH_TYPE_TYPED_9(t0, t1, t2, t3, t4, t5, t6, t7, t8) MONO_HANDLE_FOREACH_TYPE_TYPED_8 (t0, t1, t2, t3, t4, t5, t6, t7)  ,MONO_HANDLE_TYPE_TYPED (t8)
 353
 354 // Generate a parameter list, types and names, for a function accepting raw handles and a MonoError,
 355 // and returning a raw pointer. MonoError is not here, but added elsewhere.
 356 #define MONO_HANDLE_FOREACH_ARG_RAW_0()                                         /* nothing */
 357 #define MONO_HANDLE_FOREACH_ARG_RAW_1(t0)                                       MONO_HANDLE_ARG_RAWHANDLE (t0, 0)
 358 #define MONO_HANDLE_FOREACH_ARG_RAW_2(t0, t1)                                   MONO_HANDLE_FOREACH_ARG_RAW_1 (t0),                             MONO_HANDLE_ARG_RAWHANDLE (t1, 1)
 359 #define MONO_HANDLE_FOREACH_ARG_RAW_3(t0, t1, t2)                               MONO_HANDLE_FOREACH_ARG_RAW_2 (t0, t1),                         MONO_HANDLE_ARG_RAWHANDLE (t2, 2)
 360 #define MONO_HANDLE_FOREACH_ARG_RAW_4(t0, t1, t2, t3)                           MONO_HANDLE_FOREACH_ARG_RAW_3 (t0, t1, t2),                     MONO_HANDLE_ARG_RAWHANDLE (t3, 3)
 361 #define MONO_HANDLE_FOREACH_ARG_RAW_5(t0, t1, t2, t3, t4)                       MONO_HANDLE_FOREACH_ARG_RAW_4 (t0, t1, t2, t3),                 MONO_HANDLE_ARG_RAWHANDLE (t4, 4)
 362 #define MONO_HANDLE_FOREACH_ARG_RAW_6(t0, t1, t2, t3, t4, t5)                   MONO_HANDLE_FOREACH_ARG_RAW_5 (t0, t1, t2, t3, t4),             MONO_HANDLE_ARG_RAWHANDLE (t5, 5)
 363 #define MONO_HANDLE_FOREACH_ARG_RAW_7(t0, t1, t2, t3, t4, t5, t6)               MONO_HANDLE_FOREACH_ARG_RAW_6 (t0, t1, t2, t3, t4, t5),         MONO_HANDLE_ARG_RAWHANDLE (t6, 6)
 364 #define MONO_HANDLE_FOREACH_ARG_RAW_8(t0, t1, t2, t3, t4, t5, t6, t7)           MONO_HANDLE_FOREACH_ARG_RAW_7 (t0, t1, t2, t3, t4, t5, t6),     MONO_HANDLE_ARG_RAWHANDLE (t7, 7)
 365 #define MONO_HANDLE_FOREACH_ARG_RAW_9(t0, t1, t2, t3, t4, t5, t6, t7, t8)       MONO_HANDLE_FOREACH_ARG_RAW_8 (t0, t1, t2, t3, t4, t5, t6, t7), MONO_HANDLE_ARG_RAWHANDLE (t8, 8)
 366
 367 // Generate a parameter list, types and names, for a function accepting raw pointers and no MonoError,
 368 // and returning a raw pointer.
 369 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_0()                                          /* nothing */
 370 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_1(t0)                                        MONO_HANDLE_ARG_RAWPOINTER (t0, 0)
 371 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_2(t0, t1)                                    MONO_HANDLE_FOREACH_ARG_RAWPOINTER_1 (t0),                              MONO_HANDLE_ARG_RAWPOINTER (t1, 1)
 372 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_3(t0, t1, t2)                                MONO_HANDLE_FOREACH_ARG_RAWPOINTER_2 (t0, t1),                          MONO_HANDLE_ARG_RAWPOINTER (t2, 2)
 373 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_4(t0, t1, t2, t3)                            MONO_HANDLE_FOREACH_ARG_RAWPOINTER_3 (t0, t1, t2),                      MONO_HANDLE_ARG_RAWPOINTER (t3, 3)
 374 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_5(t0, t1, t2, t3, t4)                        MONO_HANDLE_FOREACH_ARG_RAWPOINTER_4 (t0, t1, t2, t3),                  MONO_HANDLE_ARG_RAWPOINTER (t4, 4)
 375 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_6(t0, t1, t2, t3, t4, t5)                    MONO_HANDLE_FOREACH_ARG_RAWPOINTER_5 (t0, t1, t2, t3, t4),              MONO_HANDLE_ARG_RAWPOINTER (t5, 5)
 376 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_7(t0, t1, t2, t3, t4, t5, t6)                MONO_HANDLE_FOREACH_ARG_RAWPOINTER_6 (t0, t1, t2, t3, t4, t5),          MONO_HANDLE_ARG_RAWPOINTER (t6, 6)
 377 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_8(t0, t1, t2, t3, t4, t5, t6, t7)            MONO_HANDLE_FOREACH_ARG_RAWPOINTER_7 (t0, t1, t2, t3, t4, t5, t6),      MONO_HANDLE_ARG_RAWPOINTER (t7, 7)
 378 #define MONO_HANDLE_FOREACH_ARG_RAWPOINTER_9(t0, t1, t2, t3, t4, t5, t6, t7, t8)        MONO_HANDLE_FOREACH_ARG_RAWPOINTER_8 (t0, t1, t2, t3, t4, t5, t6, t7),  MONO_HANDLE_ARG_RAWPOINTER (t8, 8)
 379
 380 #define MONO_HANDLE_REGISTER_ICALL_CALL_0 /*  nothing */
 381 #define MONO_HANDLE_REGISTER_ICALL_CALL_1 a0,
 382 #define MONO_HANDLE_REGISTER_ICALL_CALL_2 MONO_HANDLE_REGISTER_ICALL_CALL_1 a1,
 383 #define MONO_HANDLE_REGISTER_ICALL_CALL_3 MONO_HANDLE_REGISTER_ICALL_CALL_2 a2,
 384 #define MONO_HANDLE_REGISTER_ICALL_CALL_4 MONO_HANDLE_REGISTER_ICALL_CALL_3 a3,
 385 #define MONO_HANDLE_REGISTER_ICALL_CALL_5 MONO_HANDLE_REGISTER_ICALL_CALL_4 a4,
 386 #define MONO_HANDLE_REGISTER_ICALL_CALL_6 MONO_HANDLE_REGISTER_ICALL_CALL_5 a5,
 387 #define MONO_HANDLE_REGISTER_ICALL_CALL_7 MONO_HANDLE_REGISTER_ICALL_CALL_6 a6,
 388 #define MONO_HANDLE_REGISTER_ICALL_CALL_8 MONO_HANDLE_REGISTER_ICALL_CALL_7 a7,
 389 #define MONO_HANDLE_REGISTER_ICALL_CALL_9 MONO_HANDLE_REGISTER_ICALL_CALL_8 a8,
 390
 391 // Call from the wrapper to the actual icall, passing on the
 392 // WRAP_NONE parameters directly, casting handles from raw to typed.
 393 #define MONO_HANDLE_CALL_0()                                    /* nothing  */
 394 #define MONO_HANDLE_CALL_1(t0)                                  MONO_HANDLE_MARSHAL (t0, 0)
 395 #define MONO_HANDLE_CALL_2(t0, t1)                              MONO_HANDLE_CALL_1 (t0),                                MONO_HANDLE_MARSHAL (t1, 1)
 396 #define MONO_HANDLE_CALL_3(t0, t1, t2)                          MONO_HANDLE_CALL_2 (t0, t1),                            MONO_HANDLE_MARSHAL (t2, 2)
 397 #define MONO_HANDLE_CALL_4(t0, t1, t2, t3)                      MONO_HANDLE_CALL_3 (t0, t1, t2),                        MONO_HANDLE_MARSHAL (t3, 3)
 398 #define MONO_HANDLE_CALL_5(t0, t1, t2, t3, t4)                  MONO_HANDLE_CALL_4 (t0, t1, t2, t3),                    MONO_HANDLE_MARSHAL (t4, 4)
 399 #define MONO_HANDLE_CALL_6(t0, t1, t2, t3, t4, t5)              MONO_HANDLE_CALL_5 (t0, t1, t2, t3, t4),                MONO_HANDLE_MARSHAL (t5, 5)
 400 #define MONO_HANDLE_CALL_7(t0, t1, t2, t3, t4, t5, t6)          MONO_HANDLE_CALL_6 (t0, t1, t2, t3, t4, t5),            MONO_HANDLE_MARSHAL (t6, 6)
 401 #define MONO_HANDLE_CALL_8(t0, t1, t2, t3, t4, t5, t6, t7)      MONO_HANDLE_CALL_7 (t0, t1, t2, t3, t4, t5, t6),        MONO_HANDLE_MARSHAL (t7, 7)
 402 #define MONO_HANDLE_CALL_9(t0, t1, t2, t3, t4, t5, t6, t7, t8)  MONO_HANDLE_CALL_8 (t0, t1, t2, t3, t4, t5, t6, t7),    MONO_HANDLE_MARSHAL (t8, 8)
 403
 404 // Place a comma after a parameter list of length n, i.e. nothing for 0, else comma.
 405 #define MONO_HANDLE_COMMA_0 /* nothing */
 406 #define MONO_HANDLE_COMMA_1 ,
 407 #define MONO_HANDLE_COMMA_2 ,
 408 #define MONO_HANDLE_COMMA_3 ,
 409 #define MONO_HANDLE_COMMA_4 ,
 410 #define MONO_HANDLE_COMMA_5 ,
 411 #define MONO_HANDLE_COMMA_6 ,
 412 #define MONO_HANDLE_COMMA_7 ,
 413 #define MONO_HANDLE_COMMA_8 ,
 414 #define MONO_HANDLE_COMMA_9 ,
 415
 416 // Declare the function that takes/returns typed handles.
 417 #define MONO_HANDLE_DECLARE(id, name, func, rettype, n, argtypes)       \
 418 MONO_HANDLE_TYPE_TYPED (rettype)                                        \
 419 func (MONO_HANDLE_FOREACH_TYPE_TYPED_ ## n argtypes MONO_HANDLE_COMMA_ ## n MonoError *error)
 420
 421 // Declare the function wrapper that takes raw handles and a MonoError and returns a raw pointer.
 422 //
 423 // FIXME The error variable is on the managed side instead of native
 424 // only to satisfy fragile test external/coreclr/tests/src/CoreMangLib/cti/system/weakreference/weakreferenceisaliveb.exe.
 425 // I.e. We should have ERROR_DECL instead of error_init and MonoError parameter
 426 // should be a local instead of a parameter. The different is minor.
 427 #define MONO_HANDLE_DECLARE_RAW(id, name, func, rettype, n, argtypes)   \
 428 ICALL_EXPORT MONO_HANDLE_TYPE_RAWPOINTER (rettype)                              \
 429 func ## _raw ( MONO_HANDLE_FOREACH_ARG_RAW_ ## n argtypes MONO_HANDLE_COMMA_ ## n MonoError *error)
 430
 431 // Implement ves_icall_foo_raw over ves_icall_foo.
 432 // Raw handles are converted to/from typed handles and the rest is passed through.
 433 // This is for functions in icall-def.h.
 434
 435 #define MONO_HANDLE_IMPLEMENT(id, name, func, rettype, n, argtypes)     \
 436                                                                                 \
 437 MONO_HANDLE_DECLARE_RAW (id, name, func, rettype, n, argtypes)                  \
 438 {                                                                               \
 439         HANDLE_FUNCTION_ENTER ();                                               \
 440                                                                                 \
 441         /* FIXME Should be ERROR_DECL but for fragile test. */                  \
 442         error_init (error);                                                     \
 443                                                                                 \
 444         MONO_HANDLE_RETURN_BEGIN (rettype)                                      \
 445                                                                                 \
 446         func (MONO_HANDLE_CALL_ ## n argtypes MONO_HANDLE_COMMA_ ## n error);   \
 447                                                                                 \
 448         mono_error_set_pending_exception (error);                               \
 449                                                                                 \
 450         MONO_HANDLE_RETURN_END (rettype)                                        \
 451 }                                                                               \
 452
 453 // Declare the function that takes/returns raw pointers and no MonoError.
 454 #define MONO_HANDLE_REGISTER_ICALL_DECLARE_RAW(func, rettype, n, argtypes)      \
 455 ICALL_EXPORT MONO_HANDLE_TYPE_RAWPOINTER (rettype)                              \
 456 func ( MONO_HANDLE_FOREACH_ARG_RAWPOINTER_ ## n argtypes)
 457
 458 // Implement ves_icall_foo over ves_icall_foo_impl.
 459 //
 460 // Raw pointers are converted to/from handles and the rest is passed through.
 461 // The in/out/inout-ness of parameters must be correct. (unlike MONO_HANDLE_IMPLEMENT)
 462 // Valuetype-refs are not handled. (unlike MONO_HANDLE_IMPLEMENT)
 463 // Handle creation is less efficient than MONO_HANDLE_IMPLEMENT (marshal-ilgen.c) -- using TLS
 464 // and per-handle work.
 465 //
 466 // In future this should produce an array of IcallHandlesWrap and send that through
 467 // to emit_native_icall_wrapper_ilgen to gain its efficient handles.
 468 //
 469 // Or put the handles directly in the coop frame, or pointers to them.
 470 // i.e. one TLS access at function start and end.
 471 //
 472 // This is for functions passed to mono_register_jit_icall, etc.
 473
 474 #define MONO_HANDLE_REGISTER_ICALL_IMPLEMENT(func, rettype, n, argtypes)        \
 475                                                                                 \
 476 MONO_HANDLE_REGISTER_ICALL_DECLARE_RAW (func, rettype, n, argtypes)             \
 477 {                                                                               \
 478         HANDLE_FUNCTION_ENTER ();                                               \
 479                                                                                 \
 480         ERROR_DECL (error);                                                     \
 481                                                                                 \
 482         MONO_HANDLE_REGISTER_ICALL_LOCALS_ ## n argtypes                        \
 483                                                                                 \
 484         MONO_HANDLE_RETURN_BEGIN (rettype)                                      \
 485                                                                                 \
 486         func ## _impl (MONO_HANDLE_REGISTER_ICALL_CALL_ ## n error);                    \
 487                                                                                 \
 488         MONO_HANDLE_REGISTER_ICALL_OUT_ ## n argtypes                           \
 489                                                                                 \
 490         mono_error_set_pending_exception (error);                               \
 491                                                                                 \
 492         MONO_HANDLE_RETURN_END (rettype)                                        \
 493 }                                                                               \
 494
 495 #endif