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