-/*
- * method-builder.c: Functions for creating IL methods at runtime.
+/**
+ * \file
+ * Functions for creating IL methods at runtime.
*
* Author:
* Paolo Molaro (lupus@ximian.com)
m->inline_info = 1;
m->wrapper_type = type;
-#ifndef DISABLE_JIT
+#ifdef ENABLE_ILGEN
mb->code_size = 40;
mb->code = (unsigned char *)g_malloc (mb->code_size);
mb->init_locals = TRUE;
return mb;
}
+/**
+ * mono_mb_new:
+ */
MonoMethodBuilder *
mono_mb_new (MonoClass *klass, const char *name, MonoWrapperType type)
{
return mb;
}
+/**
+ * mono_mb_free:
+ */
void
mono_mb_free (MonoMethodBuilder *mb)
{
-#ifndef DISABLE_JIT
+#ifdef ENABLE_ILGEN
GList *l;
for (l = mb->locals_list; l; l = l->next) {
/**
* mono_mb_create_method:
- *
- * Create a MonoMethod from this method builder.
- * Returns: the newly created method.
- *
+ * Create a \c MonoMethod from this method builder.
+ * \returns the newly created method.
*/
MonoMethod *
mono_mb_create_method (MonoMethodBuilder *mb, MonoMethodSignature *signature, int max_stack)
{
-#ifndef DISABLE_JIT
+#ifdef ENABLE_ILGEN
MonoMethodHeader *header;
#endif
MonoMethodWrapper *mw;
image = mb->method->klass->image;
-#ifndef DISABLE_JIT
+#ifdef ENABLE_ILGEN
if (mb->dynamic) {
method = mb->method;
mw = (MonoMethodWrapper*)method;
else
method->name = mono_image_strdup (image, mb->name);
-#ifndef DISABLE_JIT
+#ifdef ENABLE_ILGEN
mw->header = header = (MonoMethodHeader *)
mono_image_alloc0 (image, MONO_SIZEOF_METHOD_HEADER + mb->locals * sizeof (MonoType *));
#endif
}
-#ifndef DISABLE_JIT
+#ifdef ENABLE_ILGEN
/* Free the locals list so mono_mb_free () doesn't free the types twice */
g_list_free (mb->locals_list);
mb->locals_list = NULL;
if (!signature->hasthis)
method->flags |= METHOD_ATTRIBUTE_STATIC;
-#ifndef DISABLE_JIT
+#ifdef ENABLE_ILGEN
if (max_stack < 8)
max_stack = 8;
mw->method_data = data;
}
-#ifndef DISABLE_JIT
+#ifdef ENABLE_ILGEN
/*{
static int total_code = 0;
static int total_alloc = 0;
return method;
}
+/**
+ * mono_mb_add_data:
+ */
guint32
mono_mb_add_data (MonoMethodBuilder *mb, gpointer data)
{
return g_list_length ((GList *)mw->method_data);
}
-#ifndef DISABLE_JIT
+#ifdef ENABLE_ILGEN
+/**
+ * mono_mb_add_local:
+ */
int
mono_mb_add_local (MonoMethodBuilder *mb, MonoType *type)
{
return res;
}
+/**
+ * mono_mb_patch_addr:
+ */
void
mono_mb_patch_addr (MonoMethodBuilder *mb, int pos, int value)
{
mb->code [pos + 3] = (value >> 24) & 0xff;
}
+/**
+ * mono_mb_patch_addr_s:
+ */
void
mono_mb_patch_addr_s (MonoMethodBuilder *mb, int pos, gint8 value)
{
*((gint8 *)(&mb->code [pos])) = value;
}
+/**
+ * mono_mb_emit_byte:
+ */
void
mono_mb_emit_byte (MonoMethodBuilder *mb, guint8 op)
{
mb->code [mb->pos++] = op;
}
+/**
+ * mono_mb_emit_ldflda:
+ */
void
mono_mb_emit_ldflda (MonoMethodBuilder *mb, gint32 offset)
{
}
}
+/**
+ * mono_mb_emit_i4:
+ */
void
mono_mb_emit_i4 (MonoMethodBuilder *mb, gint32 data)
{
mb->pos += 8;
}
+/**
+ * mono_mb_emit_i2:
+ */
void
mono_mb_emit_i2 (MonoMethodBuilder *mb, gint16 data)
{
mono_mb_emit_i4 (mb, mono_mb_add_data (mb, data));
}
+/**
+ * mono_mb_emit_ldstr:
+ */
void
mono_mb_emit_ldstr (MonoMethodBuilder *mb, char *str)
{
mono_mb_emit_op (mb, CEE_LDSTR, str);
}
+/**
+ * mono_mb_emit_ldarg:
+ */
void
mono_mb_emit_ldarg (MonoMethodBuilder *mb, guint argnum)
{
}
}
+/**
+ * mono_mb_emit_ldarg_addr:
+ */
void
mono_mb_emit_ldarg_addr (MonoMethodBuilder *mb, guint argnum)
{
}
}
+/**
+ * mono_mb_emit_ldloc_addr:
+ */
void
mono_mb_emit_ldloc_addr (MonoMethodBuilder *mb, guint locnum)
{
}
}
+/**
+ * mono_mb_emit_ldloc:
+ */
void
mono_mb_emit_ldloc (MonoMethodBuilder *mb, guint num)
{
}
}
+/**
+ * mono_mb_emit_stloc:
+ */
void
mono_mb_emit_stloc (MonoMethodBuilder *mb, guint num)
{
}
}
+/**
+ * mono_mb_emit_icon:
+ */
void
mono_mb_emit_icon (MonoMethodBuilder *mb, gint32 value)
{
return mb->pos;
}
+/**
+ * mono_mb_emit_branch:
+ */
guint32
mono_mb_emit_branch (MonoMethodBuilder *mb, guint8 op)
{
mono_mb_emit_op (mb, CEE_CALLI, sig);
}
+/**
+ * mono_mb_emit_managed_call:
+ */
void
mono_mb_emit_managed_call (MonoMethodBuilder *mb, MonoMethod *method, MonoMethodSignature *opt_sig)
{
mono_mb_emit_op (mb, CEE_CALL, method);
}
+/**
+ * mono_mb_emit_native_call:
+ */
void
mono_mb_emit_native_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, gpointer func)
{
mono_mb_emit_byte (mb, CEE_THROW);
}
+/**
+ * mono_mb_emit_exception:
+ */
void
mono_mb_emit_exception (MonoMethodBuilder *mb, const char *exc_name, const char *msg)
{
mono_mb_emit_exception_full (mb, "System", exc_name, msg);
}
+/**
+ * mono_mb_emit_exception_for_error:
+ */
+void
+mono_mb_emit_exception_for_error (MonoMethodBuilder *mb, MonoError *error)
+{
+ /*
+ * If at some point there is need to support other types of errors,
+ * the behaviour should conform with mono_error_prepare_exception().
+ */
+ g_assert (mono_error_get_error_code (error) == MONO_ERROR_GENERIC && "Unsupported error code.");
+ mono_mb_emit_exception_full (mb, "System", mono_error_get_exception_name (error), mono_error_get_message (error));
+}
+
+/**
+ * mono_mb_emit_add_to_local:
+ */
void
mono_mb_emit_add_to_local (MonoMethodBuilder *mb, guint16 local, gint32 incr)
{
projects / mono.git / blobdiff