/*
- * console-io.c: ConsoleDriver internal calls
+ * debug-helpers.c:
*
* Author:
* Mono Project (http://www.mono-project.com)
#include "mono/metadata/opcodes.h"
#include "mono/metadata/metadata-internals.h"
#include "mono/metadata/class-internals.h"
+#include "mono/metadata/object-internals.h"
#include "mono/metadata/mono-endian.h"
#include "mono/metadata/debug-helpers.h"
#include "mono/metadata/tabledefs.h"
g_string_append_c (res, '/');
}
if (include_namespace && *(class->name_space))
- g_string_sprintfa (res, "%s.", class->name_space);
- g_string_sprintfa (res, "%s", class->name);
+ g_string_append_printf (res, "%s.", class->name_space);
+ g_string_append_printf (res, "%s", class->name);
+}
+
+static MonoClass*
+find_system_class (const char *name)
+{
+ if (!strcmp (name, "void"))
+ return mono_defaults.void_class;
+ else if (!strcmp (name, "char")) return mono_defaults.char_class;
+ else if (!strcmp (name, "bool")) return mono_defaults.boolean_class;
+ else if (!strcmp (name, "byte")) return mono_defaults.byte_class;
+ else if (!strcmp (name, "sbyte")) return mono_defaults.sbyte_class;
+ else if (!strcmp (name, "uint16")) return mono_defaults.uint16_class;
+ else if (!strcmp (name, "int16")) return mono_defaults.int16_class;
+ else if (!strcmp (name, "uint")) return mono_defaults.uint32_class;
+ else if (!strcmp (name, "int")) return mono_defaults.int32_class;
+ else if (!strcmp (name, "ulong")) return mono_defaults.uint64_class;
+ else if (!strcmp (name, "long")) return mono_defaults.int64_class;
+ else if (!strcmp (name, "uintptr")) return mono_defaults.uint_class;
+ else if (!strcmp (name, "intptr")) return mono_defaults.int_class;
+ else if (!strcmp (name, "single")) return mono_defaults.single_class;
+ else if (!strcmp (name, "double")) return mono_defaults.double_class;
+ else if (!strcmp (name, "string")) return mono_defaults.string_class;
+ else if (!strcmp (name, "object")) return mono_defaults.object_class;
+ else
+ return NULL;
}
void
break;
case MONO_TYPE_ARRAY:
mono_type_get_desc (res, &type->data.array->eklass->byval_arg, include_namespace);
- g_string_sprintfa (res, "[%d]", type->data.array->rank);
+ g_string_append_printf (res, "[%d]", type->data.array->rank);
break;
case MONO_TYPE_SZARRAY:
mono_type_get_desc (res, &type->data.klass->byval_arg, include_namespace);
g_string_append (res, "<unknown>");
}
break;
+ case MONO_TYPE_TYPEDBYREF:
+ g_string_append (res, "typedbyref");
+ break;
default:
break;
}
mono_type_full_name (MonoType *type)
{
GString *str;
- char *res;
str = g_string_new ("");
mono_type_get_desc (str, type, TRUE);
-
- res = g_strdup (str->str);
- g_string_free (str, TRUE);
- return res;
+ return g_string_free (str, FALSE);
}
char*
{
int i;
char *result;
- GString *res = g_string_new ("");
+ GString *res;
+
+ if (!sig)
+ return g_strdup ("<invalid signature>");
+
+ res = g_string_new ("");
for (i = 0; i < sig->param_count; ++i) {
if (i > 0)
class_nspace = g_strdup (name);
use_args = strchr (class_nspace, '(');
if (use_args) {
+ /* Allow a ' ' between the method name and the signature */
+ if (use_args > class_nspace && use_args [-1] == ' ')
+ use_args [-1] = 0;
*use_args++ = 0;
end = strchr (use_args, ')');
if (!end) {
g_free (class_nspace);
return NULL;
}
- *method_name++ = 0;
/* allow two :: to separate the method name */
- if (*method_name == ':')
- method_name++;
+ if (method_name != class_nspace && method_name [-1] == ':')
+ method_name [-1] = 0;
+ *method_name++ = 0;
class_name = strrchr (class_nspace, '.');
if (class_name) {
*class_name++ = 0;
gboolean
mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method)
{
+ if (!desc->klass)
+ return FALSE;
if (!match_class (desc, strlen (desc->klass), method->klass))
return FALSE;
MonoMethod *method;
int i;
+ /* Handle short names for system classes */
+ if (!desc->namespace && image == mono_defaults.corlib) {
+ klass = find_system_class (desc->klass);
+ if (klass)
+ return mono_method_desc_search_in_class (desc, klass);
+ }
+
if (desc->namespace && desc->klass) {
klass = mono_class_from_name (image, desc->namespace, desc->klass);
if (!klass)
g_free (tmp);
}
if (dh->label_format)
- g_string_sprintfa (str, dh->label_format, label);
+ g_string_append_printf (str, dh->label_format, label);
i = mono_opcode_value (&ip, end);
ip++;
opcode = &mono_opcodes [i];
- g_string_sprintfa (str, "%-10s", mono_opcode_name (i));
+ g_string_append_printf (str, "%-10s", mono_opcode_name (i));
switch (opcode->argument) {
case MonoInlineNone:
g_string_append (str, tmp);
g_free (tmp);
} else {
- g_string_sprintfa (str, "0x%08x", token);
+ g_string_append_printf (str, "0x%08x", token);
}
ip += 4;
break;
const char *blob;
char *s;
size_t len2;
+ char *blob2 = NULL;
- if (!method->klass->image->dynamic) {
+ if (!image_is_dynamic (method->klass->image) && !method_is_dynamic (method)) {
token = read32 (ip);
blob = mono_metadata_user_string (method->klass->image, mono_metadata_token_index (token));
len2 = mono_metadata_decode_blob_size (blob, &blob);
len2 >>= 1;
- s = g_utf16_to_utf8 ((gunichar2*)blob, len2, NULL, NULL, NULL);
+#ifdef NO_UNALIGNED_ACCESS
+ /* The blob might not be 2 byte aligned */
+ blob2 = g_malloc ((len2 * 2) + 1);
+ memcpy (blob2, blob, len2 * 2);
+#else
+ blob2 = (char*)blob;
+#endif
+
+#if G_BYTE_ORDER != G_LITTLE_ENDIAN
+ {
+ guint16 *buf = g_new (guint16, len2 + 1);
+ int i;
- g_string_sprintfa (str, "\"%s\"", s);
+ for (i = 0; i < len2; ++i)
+ buf [i] = GUINT16_FROM_LE (((guint16*)blob2) [i]);
+ s = g_utf16_to_utf8 (buf, len2, NULL, NULL, NULL);
+ g_free (buf);
+ }
+#else
+ s = g_utf16_to_utf8 ((gunichar2*)blob2, len2, NULL, NULL, NULL);
+#endif
+
+ g_string_append_printf (str, "\"%s\"", s);
g_free (s);
+ if (blob != blob2)
+ g_free (blob2);
}
ip += 4;
break;
}
case MonoInlineVar:
- g_string_sprintfa (str, "%d", read16 (ip));
+ g_string_append_printf (str, "%d", read16 (ip));
ip += 2;
break;
case MonoShortInlineVar:
- g_string_sprintfa (str, "%d", (*ip));
+ g_string_append_printf (str, "%d", (*ip));
ip ++;
break;
case MonoInlineBrTarget:
sval = read32 (ip);
ip += 4;
if (dh->label_target)
- g_string_sprintfa (str, dh->label_target, ip + sval - il_code);
+ g_string_append_printf (str, dh->label_target, ip + sval - il_code);
else
- g_string_sprintfa (str, "%d", sval);
+ g_string_append_printf (str, "%d", sval);
break;
case MonoShortInlineBrTarget:
sval = *(const signed char*)ip;
ip ++;
if (dh->label_target)
- g_string_sprintfa (str, dh->label_target, ip + sval - il_code);
+ g_string_append_printf (str, dh->label_target, ip + sval - il_code);
else
- g_string_sprintfa (str, "%d", sval);
+ g_string_append_printf (str, "%d", sval);
break;
case MonoInlineSwitch: {
const unsigned char *end;
g_string_append (str, ", ");
label = read32 (ip);
if (dh->label_target)
- g_string_sprintfa (str, dh->label_target, end + label - il_code);
+ g_string_append_printf (str, dh->label_target, end + label - il_code);
else
- g_string_sprintfa (str, "%d", label);
+ g_string_append_printf (str, "%d", label);
ip += 4;
}
g_string_append_c (str, ')');
case MonoInlineR: {
double r;
readr8 (ip, &r);
- g_string_sprintfa (str, "%g", r);
+ g_string_append_printf (str, "%g", r);
ip += 8;
break;
}
case MonoShortInlineR: {
float r;
readr4 (ip, &r);
- g_string_sprintfa (str, "%g", r);
+ g_string_append_printf (str, "%g", r);
ip += 4;
break;
}
case MonoInlineI:
- g_string_sprintfa (str, "%d", (gint32)read32 (ip));
+ g_string_append_printf (str, "%d", (gint32)read32 (ip));
ip += 4;
break;
case MonoShortInlineI:
- g_string_sprintfa (str, "%d", *(const signed char*)ip);
+ g_string_append_printf (str, "%d", *(const signed char*)ip);
ip ++;
break;
case MonoInlineI8:
if (dh->newline)
g_string_append (str, dh->newline);
+ mono_metadata_free_mh (header);
return ip;
}
{
if (klass->nested_in) {
print_name_space (klass->nested_in);
- g_print (klass->nested_in->name);
+ g_print ("%s", klass->nested_in->name);
return "/";
}
if (klass->name_space [0]) {
- g_print (klass->name_space);
+ g_print ("%s", klass->name_space);
return ".";
}
return "";
MonoArray *array = (MonoArray*)obj;
sep = print_name_space (klass);
g_print ("%s%s", sep, klass->name);
- g_print (" at %p, rank: %d, length: %d\n", obj, klass->rank, mono_array_length (array));
+ g_print (" at %p, rank: %d, length: %d\n", obj, klass->rank, (int)mono_array_length (array));
} else {
sep = print_name_space (klass);
g_print ("%s%s", sep, klass->name);
MonoClassField *field;
MonoClass *p;
const char *field_ptr;
- const char *addr = mono_class_vtable (mono_domain_get (), klass)->data;
- if (!addr)
+ MonoVTable *vtable = mono_class_vtable_full (mono_domain_get (), klass, FALSE);
+ const char *addr;
+
+ if (!vtable)
+ return;
+ if (!(addr = mono_vtable_get_static_field_data (vtable)))
return;
for (p = klass; p != NULL; p = p->parent) {
}
}
}
-
projects / mono.git / blobdiff