2 * method-builder.c: Functions for creating IL methods at runtime.
5 * Paolo Molaro (lupus@ximian.com)
7 * Copyright 2002-2003 Ximian, Inc (http://www.ximian.com)
8 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
9 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
14 #include "mono/metadata/abi-details.h"
15 #include "mono/metadata/method-builder.h"
16 #include "mono/metadata/tabledefs.h"
17 #include "mono/metadata/exception.h"
18 #include "mono/metadata/appdomain.h"
19 #include "mono/metadata/debug-helpers.h"
20 #include "mono/metadata/metadata-internals.h"
21 #include "mono/metadata/domain-internals.h"
25 /* #define DEBUG_RUNTIME_CODE */
27 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
31 #include "mono/cil/opcode.def"
36 #ifdef DEBUG_RUNTIME_CODE
38 indenter (MonoDisHelper *dh, MonoMethod *method, guint32 ip_offset)
40 return g_strdup (" ");
43 static MonoDisHelper marshal_dh = {
53 static MonoMethodBuilder *
54 mono_mb_new_base (MonoClass *klass, MonoWrapperType type)
56 MonoMethodBuilder *mb;
59 g_assert (klass != NULL);
61 mb = g_new0 (MonoMethodBuilder, 1);
63 mb->method = m = (MonoMethod *)g_new0 (MonoMethodWrapper, 1);
67 m->wrapper_type = type;
71 mb->code = (unsigned char *)g_malloc (mb->code_size);
72 mb->init_locals = TRUE;
74 /* placeholder for the wrapper always at index 1 */
75 mono_mb_add_data (mb, NULL);
81 mono_mb_new_no_dup_name (MonoClass *klass, const char *name, MonoWrapperType type)
83 MonoMethodBuilder *mb = mono_mb_new_base (klass, type);
84 mb->name = (char*)name;
85 mb->no_dup_name = TRUE;
90 mono_mb_new (MonoClass *klass, const char *name, MonoWrapperType type)
92 MonoMethodBuilder *mb = mono_mb_new_base (klass, type);
93 mb->name = g_strdup (name);
98 mono_mb_free (MonoMethodBuilder *mb)
103 for (l = mb->locals_list; l; l = l->next) {
104 /* Allocated in mono_mb_add_local () */
107 g_list_free (mb->locals_list);
110 if (!mb->no_dup_name)
116 if (!mb->no_dup_name)
123 * mono_mb_create_method:
125 * Create a MonoMethod from this method builder.
126 * Returns: the newly created method.
130 mono_mb_create_method (MonoMethodBuilder *mb, MonoMethodSignature *signature, int max_stack)
133 MonoMethodHeader *header;
135 MonoMethodWrapper *mw;
141 g_assert (mb != NULL);
143 image = mb->method->klass->image;
148 mw = (MonoMethodWrapper*)method;
150 method->name = mb->name;
151 method->dynamic = TRUE;
153 mw->header = header = (MonoMethodHeader *)
154 g_malloc0 (MONO_SIZEOF_METHOD_HEADER + mb->locals * sizeof (MonoType *));
156 header->code = mb->code;
158 for (i = 0, l = mb->locals_list; l; l = l->next, i++) {
159 header->locals [i] = (MonoType*)l->data;
164 /* Realloc the method info into a mempool */
166 method = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethodWrapper));
167 memcpy (method, mb->method, sizeof (MonoMethodWrapper));
168 mw = (MonoMethodWrapper*) method;
171 method->name = mb->name;
173 method->name = mono_image_strdup (image, mb->name);
176 mw->header = header = (MonoMethodHeader *)
177 mono_image_alloc0 (image, MONO_SIZEOF_METHOD_HEADER + mb->locals * sizeof (MonoType *));
179 header->code = (const unsigned char *)mono_image_alloc (image, mb->pos);
180 memcpy ((char*)header->code, mb->code, mb->pos);
182 for (i = 0, l = mb->locals_list; l; l = l->next, i++) {
183 header->locals [i] = (MonoType*)l->data;
188 /* Free the locals list so mono_mb_free () doesn't free the types twice */
189 g_list_free (mb->locals_list);
190 mb->locals_list = NULL;
192 method->signature = signature;
193 if (!signature->hasthis)
194 method->flags |= METHOD_ATTRIBUTE_STATIC;
200 header->max_stack = max_stack;
202 header->code_size = mb->pos;
203 header->num_locals = mb->locals;
204 header->init_locals = mb->init_locals;
206 header->num_clauses = mb->num_clauses;
207 header->clauses = mb->clauses;
209 method->skip_visibility = mb->skip_visibility;
212 i = g_list_length ((GList *)mw->method_data);
216 l = g_list_reverse ((GList *)mw->method_data);
217 if (method_is_dynamic (method))
218 data = (void **)g_malloc (sizeof (gpointer) * (i + 1));
220 data = (void **)mono_image_alloc (image, sizeof (gpointer) * (i + 1));
221 /* store the size in the first element */
222 data [0] = GUINT_TO_POINTER (i);
224 for (tmp = l; tmp; tmp = tmp->next) {
225 data [i++] = tmp->data;
229 mw->method_data = data;
234 static int total_code = 0;
235 static int total_alloc = 0;
236 total_code += mb->pos;
237 total_alloc += mb->code_size;
238 g_print ("code size: %d of %d (allocated: %d)\n", mb->pos, total_code, total_alloc);
241 #ifdef DEBUG_RUNTIME_CODE
242 printf ("RUNTIME CODE FOR %s\n", mono_method_full_name (method, TRUE));
243 printf ("%s\n", mono_disasm_code (&marshal_dh, method, mb->code, mb->code + mb->pos));
246 if (mb->param_names) {
247 char **param_names = (char **)mono_image_alloc0 (image, signature->param_count * sizeof (gpointer));
248 for (i = 0; i < signature->param_count; ++i)
249 param_names [i] = mono_image_strdup (image, mb->param_names [i]);
251 mono_image_lock (image);
252 if (!image->wrapper_param_names)
253 image->wrapper_param_names = g_hash_table_new (NULL, NULL);
254 g_hash_table_insert (image->wrapper_param_names, method, param_names);
255 mono_image_unlock (image);
263 mono_mb_add_data (MonoMethodBuilder *mb, gpointer data)
265 MonoMethodWrapper *mw;
267 g_assert (mb != NULL);
269 mw = (MonoMethodWrapper *)mb->method;
271 /* one O(n) is enough */
272 mw->method_data = g_list_prepend ((GList *)mw->method_data, data);
274 return g_list_length ((GList *)mw->method_data);
280 mono_mb_add_local (MonoMethodBuilder *mb, MonoType *type)
286 * Have to make a copy early since type might be sig->ret,
287 * which is transient, see mono_metadata_signature_dup_internal_with_padding ().
289 t = mono_metadata_type_dup (NULL, type);
291 g_assert (mb != NULL);
292 g_assert (type != NULL);
295 mb->locals_list = g_list_append (mb->locals_list, t);
302 mono_mb_patch_addr (MonoMethodBuilder *mb, int pos, int value)
304 mb->code [pos] = value & 0xff;
305 mb->code [pos + 1] = (value >> 8) & 0xff;
306 mb->code [pos + 2] = (value >> 16) & 0xff;
307 mb->code [pos + 3] = (value >> 24) & 0xff;
311 mono_mb_patch_addr_s (MonoMethodBuilder *mb, int pos, gint8 value)
313 *((gint8 *)(&mb->code [pos])) = value;
317 mono_mb_emit_byte (MonoMethodBuilder *mb, guint8 op)
319 if (mb->pos >= mb->code_size) {
320 mb->code_size += mb->code_size >> 1;
321 mb->code = (unsigned char *)g_realloc (mb->code, mb->code_size);
324 mb->code [mb->pos++] = op;
328 mono_mb_emit_ldflda (MonoMethodBuilder *mb, gint32 offset)
330 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
331 mono_mb_emit_byte (mb, CEE_MONO_OBJADDR);
334 mono_mb_emit_icon (mb, offset);
335 mono_mb_emit_byte (mb, CEE_ADD);
340 mono_mb_emit_i4 (MonoMethodBuilder *mb, gint32 data)
342 if ((mb->pos + 4) >= mb->code_size) {
343 mb->code_size += mb->code_size >> 1;
344 mb->code = (unsigned char *)g_realloc (mb->code, mb->code_size);
347 mono_mb_patch_addr (mb, mb->pos, data);
352 mono_mb_emit_i8 (MonoMethodBuilder *mb, gint64 data)
354 if ((mb->pos + 8) >= mb->code_size) {
355 mb->code_size += mb->code_size >> 1;
356 mb->code = (unsigned char *)g_realloc (mb->code, mb->code_size);
359 mono_mb_patch_addr (mb, mb->pos, data);
360 mono_mb_patch_addr (mb, mb->pos + 4, data >> 32);
365 mono_mb_emit_i2 (MonoMethodBuilder *mb, gint16 data)
367 if ((mb->pos + 2) >= mb->code_size) {
368 mb->code_size += mb->code_size >> 1;
369 mb->code = (unsigned char *)g_realloc (mb->code, mb->code_size);
372 mb->code [mb->pos] = data & 0xff;
373 mb->code [mb->pos + 1] = (data >> 8) & 0xff;
378 mono_mb_emit_op (MonoMethodBuilder *mb, guint8 op, gpointer data)
380 mono_mb_emit_byte (mb, op);
381 mono_mb_emit_i4 (mb, mono_mb_add_data (mb, data));
385 mono_mb_emit_ldstr (MonoMethodBuilder *mb, char *str)
387 mono_mb_emit_op (mb, CEE_LDSTR, str);
391 mono_mb_emit_ldarg (MonoMethodBuilder *mb, guint argnum)
394 mono_mb_emit_byte (mb, CEE_LDARG_0 + argnum);
395 } else if (argnum < 256) {
396 mono_mb_emit_byte (mb, CEE_LDARG_S);
397 mono_mb_emit_byte (mb, argnum);
399 mono_mb_emit_byte (mb, CEE_PREFIX1);
400 mono_mb_emit_byte (mb, CEE_LDARG);
401 mono_mb_emit_i2 (mb, argnum);
406 mono_mb_emit_ldarg_addr (MonoMethodBuilder *mb, guint argnum)
409 mono_mb_emit_byte (mb, CEE_LDARGA_S);
410 mono_mb_emit_byte (mb, argnum);
412 mono_mb_emit_byte (mb, CEE_PREFIX1);
413 mono_mb_emit_byte (mb, CEE_LDARGA);
414 mono_mb_emit_i2 (mb, argnum);
419 mono_mb_emit_ldloc_addr (MonoMethodBuilder *mb, guint locnum)
422 mono_mb_emit_byte (mb, CEE_LDLOCA_S);
423 mono_mb_emit_byte (mb, locnum);
425 mono_mb_emit_byte (mb, CEE_PREFIX1);
426 mono_mb_emit_byte (mb, CEE_LDLOCA);
427 mono_mb_emit_i2 (mb, locnum);
432 mono_mb_emit_ldloc (MonoMethodBuilder *mb, guint num)
435 mono_mb_emit_byte (mb, CEE_LDLOC_0 + num);
436 } else if (num < 256) {
437 mono_mb_emit_byte (mb, CEE_LDLOC_S);
438 mono_mb_emit_byte (mb, num);
440 mono_mb_emit_byte (mb, CEE_PREFIX1);
441 mono_mb_emit_byte (mb, CEE_LDLOC);
442 mono_mb_emit_i2 (mb, num);
447 mono_mb_emit_stloc (MonoMethodBuilder *mb, guint num)
450 mono_mb_emit_byte (mb, CEE_STLOC_0 + num);
451 } else if (num < 256) {
452 mono_mb_emit_byte (mb, CEE_STLOC_S);
453 mono_mb_emit_byte (mb, num);
455 mono_mb_emit_byte (mb, CEE_PREFIX1);
456 mono_mb_emit_byte (mb, CEE_STLOC);
457 mono_mb_emit_i2 (mb, num);
462 mono_mb_emit_icon (MonoMethodBuilder *mb, gint32 value)
464 if (value >= -1 && value < 8) {
465 mono_mb_emit_byte (mb, CEE_LDC_I4_0 + value);
466 } else if (value >= -128 && value <= 127) {
467 mono_mb_emit_byte (mb, CEE_LDC_I4_S);
468 mono_mb_emit_byte (mb, value);
470 mono_mb_emit_byte (mb, CEE_LDC_I4);
471 mono_mb_emit_i4 (mb, value);
476 mono_mb_emit_icon8 (MonoMethodBuilder *mb, gint64 value)
478 mono_mb_emit_byte (mb, CEE_LDC_I8);
479 mono_mb_emit_i8 (mb, value);
483 mono_mb_get_label (MonoMethodBuilder *mb)
489 mono_mb_get_pos (MonoMethodBuilder *mb)
495 mono_mb_emit_branch (MonoMethodBuilder *mb, guint8 op)
498 mono_mb_emit_byte (mb, op);
500 mono_mb_emit_i4 (mb, 0);
505 mono_mb_emit_short_branch (MonoMethodBuilder *mb, guint8 op)
508 mono_mb_emit_byte (mb, op);
510 mono_mb_emit_byte (mb, 0);
516 mono_mb_emit_branch_label (MonoMethodBuilder *mb, guint8 op, guint32 label)
518 mono_mb_emit_byte (mb, op);
519 mono_mb_emit_i4 (mb, label - (mb->pos + 4));
523 mono_mb_patch_branch (MonoMethodBuilder *mb, guint32 pos)
525 mono_mb_patch_addr (mb, pos, mb->pos - (pos + 4));
529 mono_mb_patch_short_branch (MonoMethodBuilder *mb, guint32 pos)
531 mono_mb_patch_addr_s (mb, pos, mb->pos - (pos + 1));
535 mono_mb_emit_ptr (MonoMethodBuilder *mb, gpointer ptr)
537 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
538 mono_mb_emit_op (mb, CEE_MONO_LDPTR, ptr);
542 mono_mb_emit_calli (MonoMethodBuilder *mb, MonoMethodSignature *sig)
544 mono_mb_emit_op (mb, CEE_CALLI, sig);
548 mono_mb_emit_managed_call (MonoMethodBuilder *mb, MonoMethod *method, MonoMethodSignature *opt_sig)
550 mono_mb_emit_op (mb, CEE_CALL, method);
554 mono_mb_emit_native_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, gpointer func)
556 mono_mb_emit_ptr (mb, func);
557 mono_mb_emit_calli (mb, sig);
561 mono_mb_emit_icall (MonoMethodBuilder *mb, gpointer func)
563 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
564 mono_mb_emit_op (mb, CEE_MONO_ICALL, func);
568 mono_mb_emit_exception_full (MonoMethodBuilder *mb, const char *exc_nspace, const char *exc_name, const char *msg)
570 MonoMethod *ctor = NULL;
572 MonoClass *mme = mono_class_load_from_name (mono_defaults.corlib, exc_nspace, exc_name);
573 mono_class_init (mme);
574 ctor = mono_class_get_method_from_name (mme, ".ctor", 0);
576 mono_mb_emit_op (mb, CEE_NEWOBJ, ctor);
578 mono_mb_emit_byte (mb, CEE_DUP);
579 mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoException, message));
580 mono_mb_emit_ldstr (mb, (char*)msg);
581 mono_mb_emit_byte (mb, CEE_STIND_REF);
583 mono_mb_emit_byte (mb, CEE_THROW);
587 mono_mb_emit_exception (MonoMethodBuilder *mb, const char *exc_name, const char *msg)
589 mono_mb_emit_exception_full (mb, "System", exc_name, msg);
593 mono_mb_emit_add_to_local (MonoMethodBuilder *mb, guint16 local, gint32 incr)
595 mono_mb_emit_ldloc (mb, local);
596 mono_mb_emit_icon (mb, incr);
597 mono_mb_emit_byte (mb, CEE_ADD);
598 mono_mb_emit_stloc (mb, local);
602 mono_mb_set_clauses (MonoMethodBuilder *mb, int num_clauses, MonoExceptionClause *clauses)
604 mb->num_clauses = num_clauses;
605 mb->clauses = clauses;
609 * mono_mb_set_param_names:
611 * PARAM_NAMES should have length equal to the sig->param_count, the caller retains
612 * ownership of the array, and its entries.
615 mono_mb_set_param_names (MonoMethodBuilder *mb, const char **param_names)
617 mb->param_names = param_names;
620 #endif /* DISABLE_JIT */