-static MonoDebuggerRangeInfo *
-allocate_range_entry (MonoDebuggerSymbolFile *symfile)
-{
- MonoDebuggerRangeInfo *retval;
- guint32 size, chunks;
-
- if (!symfile->range_table) {
- size = sizeof (MonoDebuggerRangeInfo) * RANGE_TABLE_CHUNK_SIZE;
- symfile->range_table = g_malloc0 (size);
- symfile->num_range_entries = 1;
- return symfile->range_table;
- }
-
- if (!((symfile->num_range_entries + 1) % RANGE_TABLE_CHUNK_SIZE)) {
- chunks = (symfile->num_range_entries + 1) / RANGE_TABLE_CHUNK_SIZE;
- size = sizeof (MonoDebuggerRangeInfo) * RANGE_TABLE_CHUNK_SIZE * (chunks + 1);
-
- symfile->range_table = g_realloc (symfile->range_table, size);
- }
-
- retval = symfile->range_table + symfile->num_range_entries;
- symfile->num_range_entries++;
- return retval;
-}
-
-static MonoDebuggerClassInfo *
-allocate_class_entry (MonoDebuggerSymbolFile *symfile)
-{
- MonoDebuggerClassInfo *retval;
- MonoDebuggerClassTable *table;
- guint32 size;
-
- if (!symfile->class_table_start) {
- table = g_new0 (MonoDebuggerClassTable, 1);
- symfile->class_table_start = symfile->current_class_table = table;
-
- size = sizeof (MonoDebuggerClassInfo) * CLASS_TABLE_CHUNK_SIZE;
- table->data = g_malloc0 (size);
- table->size = CLASS_TABLE_CHUNK_SIZE;
- table->index = 1;
-
- return table->data;
- }
-
- table = symfile->current_class_table;
- if (table->index >= table->size) {
- table = g_new0 (MonoDebuggerClassTable, 1);
-
- symfile->current_class_table->next = table;
- symfile->current_class_table = table;
-
- size = sizeof (MonoDebuggerClassInfo) * CLASS_TABLE_CHUNK_SIZE;
- table->data = g_malloc0 (size);
- table->size = CLASS_TABLE_CHUNK_SIZE;
- table->index = 1;
-
- return table->data;
- }
-
- retval = table->data + table->index;
- table->index++;
- return retval;
-}
-
-/*
- * Allocate a new entry of size `size' in the type table.
- * Returns the global offset which is to be used to reference this type and
- * a pointer (in the `ptr' argument) which is to be used to write the type.
- */
-static guint32
-allocate_type_entry (MonoDebuggerSymbolTable *table, guint32 size, guint8 **ptr)
-{
- guint32 retval;
- guint8 *data;
-
- g_assert (size + 4 < TYPE_TABLE_CHUNK_SIZE);
- g_assert (ptr != NULL);
-
- /* Initialize things if necessary. */
- if (!table->current_type_table) {
- table->current_type_table = g_malloc0 (TYPE_TABLE_CHUNK_SIZE);
- table->type_table_size = TYPE_TABLE_CHUNK_SIZE;
- table->type_table_chunk_size = TYPE_TABLE_CHUNK_SIZE;
- table->type_table_offset = MONO_DEBUGGER_TYPE_MAX + 1;
- }
-
- again:
- /* First let's check whether there's still enough room in the current_type_table. */
- if (table->type_table_offset + size + 4 < table->type_table_size) {
- retval = table->type_table_offset;
- table->type_table_offset += size + 4;
- data = ((guint8 *) table->current_type_table) + retval - table->type_table_start;
- *(gint32 *) data = size;
- data += sizeof(gint32);
- *ptr = data;
- return retval;
- }
-
- /* Add the current_type_table to the type_tables vector and ... */
- if (!table->type_tables) {
- guint32 tsize = sizeof (gpointer) * TYPE_TABLE_PTR_CHUNK_SIZE;
- table->type_tables = g_malloc0 (tsize);
- }
-
- if (!((table->num_type_tables + 1) % TYPE_TABLE_PTR_CHUNK_SIZE)) {
- guint32 chunks = (table->num_type_tables + 1) / TYPE_TABLE_PTR_CHUNK_SIZE;
- guint32 tsize = sizeof (gpointer) * TYPE_TABLE_PTR_CHUNK_SIZE * (chunks + 1);
-
- table->type_tables = g_realloc (table->type_tables, tsize);
- }
-
- table->type_tables [table->num_type_tables++] = table->current_type_table;
-
- /* .... allocate a new current_type_table. */
- table->current_type_table = g_malloc0 (TYPE_TABLE_CHUNK_SIZE);
- table->type_table_start = table->type_table_offset = table->type_table_size;
- table->type_table_size += TYPE_TABLE_CHUNK_SIZE;
-
- goto again;
-}
-
-/*
- * Allocate a new entry of size `size' in the misc table.
- * Returns the global offset which is to be used to reference this entry and
- * a pointer (in the `ptr' argument) which is to be used to write the entry.
- */
-static guint32
-allocate_misc_entry (MonoDebuggerSymbolTable *table, guint32 size, guint8 **ptr)
-{
- guint32 retval;
- guint8 *data;
-
- g_assert (size + 4 < MISC_TABLE_CHUNK_SIZE);
- g_assert (ptr != NULL);
-
- /* Initialize things if necessary. */
- if (!table->current_misc_table) {
- table->current_misc_table = g_malloc0 (MISC_TABLE_CHUNK_SIZE);
- table->misc_table_size = MISC_TABLE_CHUNK_SIZE;
- table->misc_table_chunk_size = MISC_TABLE_CHUNK_SIZE;
- table->misc_table_offset = 1;
- }
-
- again:
- /* First let's check whether there's still enough room in the current_misc_table. */
- if (table->misc_table_offset + size + 4 < table->misc_table_size) {
- retval = table->misc_table_offset;
- table->misc_table_offset += size + 4;
- data = ((guint8 *) table->current_misc_table) + retval - table->misc_table_start;
- *(gint32 *) data = size;
- data += sizeof(gint32);
- *ptr = data;
- return retval;
- }
-
- /* Add the current_misc_table to the misc_tables vector and ... */
- if (!table->misc_tables) {
- guint32 tsize = sizeof (gpointer) * MISC_TABLE_PTR_CHUNK_SIZE;
- table->misc_tables = g_malloc0 (tsize);
- }
-
- if (!((table->num_misc_tables + 1) % MISC_TABLE_PTR_CHUNK_SIZE)) {
- guint32 chunks = (table->num_misc_tables + 1) / MISC_TABLE_PTR_CHUNK_SIZE;
- guint32 tsize = sizeof (gpointer) * MISC_TABLE_PTR_CHUNK_SIZE * (chunks + 1);
-
- table->misc_tables = g_realloc (table->misc_tables, tsize);
- }
-
- table->misc_tables [table->num_misc_tables++] = table->current_misc_table;
-
- /* .... allocate a new current_misc_table. */
- table->current_misc_table = g_malloc0 (MISC_TABLE_CHUNK_SIZE);
- table->misc_table_start = table->misc_table_offset = table->misc_table_size;
- table->misc_table_size += MISC_TABLE_CHUNK_SIZE;
-
- goto again;
-}
-
-static gboolean
-property_is_static (MonoProperty *prop)
-{
- MonoMethod *method;
-
- method = prop->get;
- if (!method)
- method = prop->set;
-
- return method->flags & METHOD_ATTRIBUTE_STATIC;
-}
-
-static gboolean
-event_is_static (MonoEvent *ev)
-{
- MonoMethod *method;
-
- method = ev->add;
-
- return method->flags & METHOD_ATTRIBUTE_STATIC;
-}
-
-static guint32
-do_write_class (MonoDebuggerSymbolTable *table, MonoClass *klass, MonoDebuggerClassInfo *cinfo)
-{
- guint8 buffer [BUFSIZ], *ptr = buffer, *old_ptr;
- GPtrArray *methods = NULL, *static_methods = NULL, *ctors = NULL, *cctors = NULL;
- int num_fields = 0, num_static_fields = 0, num_properties = 0, num_static_properties = 0;
- int num_events = 0, num_static_events = 0;
- int num_methods = 0, num_static_methods = 0, num_params = 0, num_static_params = 0, base_offset = 0;
- int num_ctors = 0, num_ctor_params = 0;
- int num_cctors = 0;
- int field_info_size = 0, static_field_info_size = 0, property_info_size = 0, event_info_size = 0, static_event_info_size = 0;
- int static_property_info_size = 0, method_info_size = 0, static_method_info_size = 0;
- int ctor_info_size = 0, cctor_info_size = 0, iface_info_size = 0;
- guint32 size, data_size, offset, data_offset;
- GHashTable *method_slots = NULL;
- int i;
-
- if (klass->init_pending)
- g_warning (G_STRLOC ": %p - %s.%s", klass, klass->name_space, klass->name);
- g_assert (!klass->init_pending);
- mono_class_init (klass);
-
- offset = GPOINTER_TO_UINT (g_hash_table_lookup (class_table, klass));
- if (offset)
- return offset;
-
- if (klass->enumtype) {
- offset = allocate_type_entry (table, 13, &ptr);
- if (cinfo)
- cinfo->type_info = offset;
- g_hash_table_insert (class_table, klass, GUINT_TO_POINTER (offset));
-
- *ptr++ = MONO_DEBUGGER_TYPE_KIND_ENUM;
- WRITE_UINT32 (ptr, klass->instance_size);
- WRITE_UINT32 (ptr, MONO_DEBUGGER_TYPE_ENUM);
- WRITE_UINT32 (ptr, write_type (table, klass->enum_basetype));
- return offset;
- }
-
- for (i = 0; i < klass->field.count; i++)
- if (!(klass->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC))
- ++num_fields;
- else
- ++num_static_fields;
-
- for (i = 0; i < klass->property.count; i++)
- if (!property_is_static (&klass->properties [i]))
- ++num_properties;
- else
- ++num_static_properties;
-
- for (i = 0; i < klass->event.count; i++)
- if (!event_is_static (&klass->events [i]))
- ++num_events;
- else
- ++num_static_events;
-
- method_slots = g_hash_table_new (NULL, NULL);
- methods = g_ptr_array_new ();
- static_methods = g_ptr_array_new ();
- ctors = g_ptr_array_new ();
- cctors = g_ptr_array_new ();
-
- for (i = 0; i < klass->method.count; i++) {
- MonoMethod *method = klass->methods [i];
-
- if (!strcmp (method->name, ".cctor")) {
- ++num_cctors;
- g_ptr_array_add (cctors, method);
- continue;
- }
-
- if (!strcmp (method->name, ".ctor")) {
- ++num_ctors;
- num_ctor_params += method->signature->param_count;
- g_ptr_array_add (ctors, method);
- continue;
- }
-
- if (method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME)
- continue;
-
- if (method->slot != -1) {
- if (g_hash_table_lookup (method_slots, GUINT_TO_POINTER (method->slot)))
- continue;
- g_hash_table_insert (method_slots, GUINT_TO_POINTER (method->slot), method);
- }
-
- if (method->flags & METHOD_ATTRIBUTE_STATIC) {
- ++num_static_methods;
- num_static_params += method->signature->param_count;
- g_ptr_array_add (static_methods, method);
- } else {
- ++num_methods;
- num_params += method->signature->param_count;
- g_ptr_array_add (methods, method);
- }
- }
-
- g_hash_table_destroy (method_slots);
-
- field_info_size = num_fields * 8;
- static_field_info_size = num_static_fields * 8;
- property_info_size = num_properties * (4 + 2 * sizeof (gpointer));
- static_property_info_size = num_static_properties * (4 + 2 * sizeof (gpointer));
- event_info_size = num_events * (4 + 2 * sizeof (gpointer));
- static_event_info_size = num_static_events * (4 + 2 * sizeof (gpointer));
- method_info_size = num_methods * (2 * 4 + sizeof (gpointer)) + num_params * 4;
- static_method_info_size = num_static_methods * (2 * 4 + sizeof (gpointer)) +
- num_static_params * 4;
- ctor_info_size = num_ctors * (2 * 4 + sizeof (gpointer)) + num_ctor_params * 4;
- cctor_info_size = num_cctors * (2 * 4 + sizeof (gpointer));
- iface_info_size = klass->interface_count * 4;
-
- size = 98 + sizeof (gpointer) + field_info_size + static_field_info_size +
- property_info_size + static_property_info_size + event_info_size +
- static_event_info_size + method_info_size + static_method_info_size +
- ctor_info_size + cctor_info_size + iface_info_size;
-
- data_size = size;
-
- offset = allocate_type_entry (table, data_size, &ptr);
- old_ptr = ptr;
-
- if (cinfo)
- cinfo->type_info = offset;
-
- g_hash_table_insert (class_table, klass, GUINT_TO_POINTER (offset));
-
- *ptr++ = MONO_DEBUGGER_TYPE_KIND_CLASS_INFO;
-
- if (klass->valuetype)
- base_offset = - sizeof (MonoObject);
-
- WRITE_UINT32 (ptr, klass->instance_size + base_offset);
- *ptr++ = klass->valuetype;
- WRITE_POINTER (ptr, klass);
- data_offset = 0;
- WRITE_UINT32 (ptr, num_fields);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += field_info_size;
- WRITE_UINT32 (ptr, num_properties);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += property_info_size;
- WRITE_UINT32 (ptr, num_events);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += event_info_size;
- WRITE_UINT32 (ptr, num_methods);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += method_info_size;
- WRITE_UINT32 (ptr, num_static_fields);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += static_field_info_size;
- WRITE_UINT32 (ptr, num_static_properties);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += static_property_info_size;
- WRITE_UINT32 (ptr, num_static_events);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += static_event_info_size;
- WRITE_UINT32 (ptr, num_static_methods);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += static_method_info_size;
- WRITE_UINT32 (ptr, num_ctors);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += ctor_info_size;
- WRITE_UINT32 (ptr, num_cctors);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += cctor_info_size;
- WRITE_UINT32 (ptr, klass->interface_count);
- WRITE_UINT32 (ptr, data_offset);
- data_offset += iface_info_size;
-
- if (klass->parent && (klass->parent != mono_defaults.object_class))
- WRITE_UINT32 (ptr, write_class (table, klass->parent));
- else
- WRITE_UINT32 (ptr, 0);
-
- for (i = 0; i < klass->field.count; i++) {
- if (klass->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC)
- continue;
-
- WRITE_UINT32 (ptr, klass->fields [i].offset + base_offset);
- WRITE_UINT32 (ptr, write_type (table, klass->fields [i].type));
- }
-
- for (i = 0; i < klass->property.count; i++) {
- if (property_is_static (&klass->properties [i]))
- continue;
-
- if (klass->properties [i].get)
- WRITE_UINT32 (ptr, write_type (table, klass->properties [i].get->signature->ret));
- else
- WRITE_UINT32 (ptr, 0);
- WRITE_POINTER (ptr, klass->properties [i].get);
- WRITE_POINTER (ptr, klass->properties [i].set);
- }
-
- for (i = 0; i < klass->event.count; i++) {
- if (event_is_static (&klass->events[i]))
- continue;
-
- if (klass->events [i].add) {
- WRITE_UINT32 (ptr, write_type (table, klass->events [i].add->signature->params[0]));
- }
- else {
- g_warning ("event add method not defined");
- WRITE_UINT32 (ptr, 0);
- }
- WRITE_POINTER (ptr, klass->events [i].add);
- WRITE_POINTER (ptr, klass->events [i].remove);
- /* raise? other? */
- }
-
- for (i = 0; i < methods->len; i++) {
- MonoMethod *method = g_ptr_array_index (methods, i);
- int j;
-
- WRITE_POINTER (ptr, method);
- if ((method->signature->ret) && (method->signature->ret->type != MONO_TYPE_VOID))
- WRITE_UINT32 (ptr, write_type (table, method->signature->ret));
- else
- WRITE_UINT32 (ptr, 0);
- WRITE_UINT32 (ptr, method->signature->param_count);
- for (j = 0; j < method->signature->param_count; j++)
- WRITE_UINT32 (ptr, write_type (table, method->signature->params [j]));
- }
-
- g_ptr_array_free (methods, FALSE);
-
- for (i = 0; i < klass->field.count; i++) {
- if (!(klass->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC))
- continue;
-
- WRITE_UINT32 (ptr, klass->fields [i].offset);
- WRITE_UINT32 (ptr, write_type (table, klass->fields [i].type));
- }
-
- for (i = 0; i < klass->property.count; i++) {
- if (!property_is_static (&klass->properties [i]))
- continue;
-
- if (klass->properties [i].get)
- WRITE_UINT32 (ptr, write_type (table, klass->properties [i].get->signature->ret));
- else
- WRITE_UINT32 (ptr, 0);
- WRITE_POINTER (ptr, klass->properties [i].get);
- WRITE_POINTER (ptr, klass->properties [i].set);
- }
-
- for (i = 0; i < klass->event.count; i++) {
- if (!event_is_static (&klass->events[i]))
- continue;
-
- if (klass->events [i].add) {
- WRITE_UINT32 (ptr, write_type (table, klass->events [i].add->signature->params[0]));
- }
- else {
- g_warning ("event add method not defined");
- WRITE_UINT32 (ptr, 0);
- }
- WRITE_POINTER (ptr, klass->events [i].add);
- WRITE_POINTER (ptr, klass->events [i].remove);
- /* raise? other? */
- }
-
- for (i = 0; i < static_methods->len; i++) {
- MonoMethod *method = g_ptr_array_index (static_methods, i);
- int j;
-
- WRITE_POINTER (ptr, method);
- if ((method->signature->ret) && (method->signature->ret->type != MONO_TYPE_VOID))
- WRITE_UINT32 (ptr, write_type (table, method->signature->ret));
- else
- WRITE_UINT32 (ptr, 0);
- WRITE_UINT32 (ptr, method->signature->param_count);
- for (j = 0; j < method->signature->param_count; j++)
- WRITE_UINT32 (ptr, write_type (table, method->signature->params [j]));
- }
-
- g_ptr_array_free (static_methods, FALSE);
-
- for (i = 0; i < ctors->len; i++) {
- MonoMethod *ctor = g_ptr_array_index (ctors, i);
- int j;
-
- WRITE_POINTER (ptr, ctor);
- WRITE_UINT32 (ptr, 0);
- WRITE_UINT32 (ptr, ctor->signature->param_count);
- for (j = 0; j < ctor->signature->param_count; j++)
- WRITE_UINT32 (ptr, write_type (table, ctor->signature->params [j]));
- }
-
- g_ptr_array_free (ctors, FALSE);
-
- for (i = 0; i < cctors->len; i++) {
- MonoMethod *cctor = g_ptr_array_index (cctors, i);
-
- WRITE_POINTER (ptr, cctor);
- WRITE_UINT32 (ptr, 0);
- WRITE_UINT32 (ptr, 0);
- }
-
- g_ptr_array_free (cctors, FALSE);
-
- for (i = 0; i < klass->interface_count; i++)
- WRITE_UINT32 (ptr, write_class (table, klass->interfaces [i]));
-
- if (ptr - old_ptr != data_size) {
- g_warning (G_STRLOC ": %d,%d,%d", ptr - old_ptr, data_size, sizeof (gpointer));
- if (klass)
- g_warning (G_STRLOC ": %s.%s", klass->name_space, klass->name);
- g_assert_not_reached ();
- }
-
- return offset;
-}
-
-/*
- * Adds type `type' to the type table and returns its offset.
- */
-static guint32
-write_type (MonoDebuggerSymbolTable *table, MonoType *type)
-{
- guint8 buffer [BUFSIZ], *ptr = buffer;
- guint32 size, offset;
- MonoClass *klass;
-
- offset = GPOINTER_TO_UINT (g_hash_table_lookup (type_table, type));
- if (offset)
- return offset;
-
- klass = mono_class_from_mono_type (type);
- if (type->type == MONO_TYPE_CLASS)
- return write_class (table, klass);
-
- // mono_class_init (klass);
-
- switch (type->type) {
- case MONO_TYPE_VOID:
- return MONO_DEBUGGER_TYPE_VOID;
-
- case MONO_TYPE_BOOLEAN:
- return MONO_DEBUGGER_TYPE_BOOLEAN;
-
- case MONO_TYPE_I1:
- return MONO_DEBUGGER_TYPE_I1;
-
- case MONO_TYPE_U1:
- return MONO_DEBUGGER_TYPE_U1;
-
- case MONO_TYPE_CHAR:
- return MONO_DEBUGGER_TYPE_CHAR;
-
- case MONO_TYPE_I2:
- return MONO_DEBUGGER_TYPE_I2;
-
- case MONO_TYPE_U2:
- return MONO_DEBUGGER_TYPE_U2;
-
- case MONO_TYPE_I4:
- return MONO_DEBUGGER_TYPE_I4;
-
- case MONO_TYPE_U4:
- return MONO_DEBUGGER_TYPE_U4;
-
- case MONO_TYPE_I8:
- return MONO_DEBUGGER_TYPE_I8;
-
- case MONO_TYPE_U8:
- return MONO_DEBUGGER_TYPE_U8;
-
- case MONO_TYPE_R4:
- return MONO_DEBUGGER_TYPE_R4;
-
- case MONO_TYPE_R8:
- return MONO_DEBUGGER_TYPE_R8;
-
- case MONO_TYPE_STRING:
- return MONO_DEBUGGER_TYPE_STRING;
-
- case MONO_TYPE_I:
- return MONO_DEBUGGER_TYPE_I;
-
- case MONO_TYPE_U:
- return MONO_DEBUGGER_TYPE_U;
-
- case MONO_TYPE_SZARRAY: {
- MonoArray array;
-
- *ptr++ = MONO_DEBUGGER_TYPE_KIND_SZARRAY;
- WRITE_UINT32 (ptr, sizeof (MonoArray));
- WRITE_UINT32 (ptr, MONO_DEBUGGER_TYPE_ARRAY);
- *ptr++ = (guint8*)&array.max_length - (guint8*)&array;
- *ptr++ = sizeof (array.max_length);
- *ptr++ = (guint8*)&array.vector - (guint8*)&array;
- WRITE_UINT32 (ptr, write_type (table, &type->data.klass->byval_arg));
- break;
- }
-
- case MONO_TYPE_ARRAY: {
- MonoArray array;
- MonoArrayBounds bounds;
-
- *ptr++ = MONO_DEBUGGER_TYPE_KIND_ARRAY;
- WRITE_UINT32 (ptr, sizeof (MonoArray));
- WRITE_UINT32 (ptr, MONO_DEBUGGER_TYPE_ARRAY);
- *ptr++ = (guint8*)&array.max_length - (guint8*)&array;
- *ptr++ = sizeof (array.max_length);
- *ptr++ = (guint8*)&array.vector - (guint8*)&array;
- *ptr++ = klass->rank;
- *ptr++ = (guint8*)&array.bounds - (guint8*)&array;
- *ptr++ = sizeof (MonoArrayBounds);
- *ptr++ = (guint8*)&bounds.lower_bound - (guint8*)&bounds;
- *ptr++ = sizeof (bounds.lower_bound);
- *ptr++ = (guint8*)&bounds.length - (guint8*)&bounds;
- *ptr++ = sizeof (bounds.length);
- WRITE_UINT32 (ptr, write_type (table, &type->data.array->eklass->byval_arg));
- break;
- }
-
- case MONO_TYPE_VALUETYPE:
- case MONO_TYPE_CLASS:
- case MONO_TYPE_GENERICINST:
- case MONO_TYPE_OBJECT:
- return write_class (table, klass);
-
- case MONO_TYPE_PTR:
- *ptr++ = MONO_DEBUGGER_TYPE_KIND_POINTER;
- WRITE_UINT32 (ptr, sizeof (gpointer));
- WRITE_UINT32 (ptr, write_type (table, type->data.type));
- break;
-
- default:
- /* g_message (G_STRLOC ": %s.%s - %p - %d", klass->name_space, klass->name, klass, type->type); */
- *ptr++ = MONO_DEBUGGER_TYPE_KIND_UNKNOWN;
- WRITE_UINT32 (ptr, klass->instance_size);
- WRITE_UINT32 (ptr, write_class (table, klass));
- break;
- }
-
- size = ptr - buffer;
- offset = allocate_type_entry (mono_debugger_symbol_table, size, &ptr);
- memcpy (ptr, buffer, size);
-
- return offset;
-}
-
-MonoReflectionMethod *
-ves_icall_MonoDebugger_GetMethod (MonoReflectionAssembly *assembly, guint32 token)
-{
- MonoMethod *method;
-
- method = mono_get_method (mono_assembly_get_image (assembly->assembly), token, NULL);
-
- return mono_method_get_object (mono_domain_get (), method, NULL);
-}
-
-int
-ves_icall_MonoDebugger_GetMethodToken (MonoReflectionAssembly *assembly, MonoReflectionMethod *method)
-{
- return method->method->token;
-}
-
-MonoReflectionType *
-ves_icall_MonoDebugger_GetType (MonoReflectionAssembly *assembly, guint32 token)
-{
- MonoClass *klass;
-
- klass = mono_class_get (mono_assembly_get_image (assembly->assembly), token);
- if (!klass) {
- g_warning (G_STRLOC ": %x", token);
- return NULL;
- }
-
- return mono_type_get_object (mono_domain_get (), &klass->byval_arg);
-}
-
-MonoReflectionType *
-ves_icall_MonoDebugger_GetLocalTypeFromSignature (MonoReflectionAssembly *assembly, MonoArray *signature)
-{
- MonoDomain *domain;
- MonoImage *image;
- MonoType *type;
- const char *ptr;
- int len = 0;
-
- MONO_CHECK_ARG_NULL (assembly);
- MONO_CHECK_ARG_NULL (signature);
-
- domain = mono_domain_get();
- image = mono_assembly_get_image (assembly->assembly);
-
- ptr = mono_array_addr (signature, char, 0);
- g_assert (*ptr++ == 0x07);
- len = mono_metadata_decode_value (ptr, &ptr);
- g_assert (len == 1);
-
- type = mono_metadata_parse_type (image, MONO_PARSE_LOCAL, 0, ptr, &ptr);
-
- return mono_type_get_object (domain, type);
-}
-