5 * Mono Project (http://www.mono-project.com)
7 * Copyright (C) 2005-2008 Novell, Inc. (http://www.novell.com)
8 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
12 #include "mono/metadata/tokentype.h"
13 #include "mono/metadata/opcodes.h"
14 #include "mono/metadata/metadata-internals.h"
15 #include "mono/metadata/class-internals.h"
16 #include "mono/metadata/object-internals.h"
17 #include "mono/metadata/mono-endian.h"
18 #include "mono/metadata/debug-helpers.h"
19 #include "mono/metadata/tabledefs.h"
20 #include "mono/metadata/appdomain.h"
22 struct MonoMethodDesc {
28 gboolean include_namespace, klass_glob, name_glob;
31 #ifdef HAVE_ARRAY_ELEM_INIT
32 #define MSGSTRFIELD(line) MSGSTRFIELD1(line)
33 #define MSGSTRFIELD1(line) str##line
34 static const struct msgstr_t {
35 #define WRAPPER(a,b) char MSGSTRFIELD(__LINE__) [sizeof (b)];
36 #include "wrapper-types.h"
39 #define WRAPPER(a,b) b,
40 #include "wrapper-types.h"
43 static const gint16 opidx [] = {
44 #define WRAPPER(a,b) [MONO_WRAPPER_ ## a] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
45 #include "wrapper-types.h"
50 wrapper_type_to_str (guint32 wrapper_type)
52 g_assert (wrapper_type < MONO_WRAPPER_NUM);
54 return (const char*)&opstr + opidx [wrapper_type];
58 #define WRAPPER(a,b) b,
59 static const char* const
60 wrapper_type_names [MONO_WRAPPER_NUM + 1] = {
61 #include "wrapper-types.h"
66 wrapper_type_to_str (guint32 wrapper_type)
68 g_assert (wrapper_type < MONO_WRAPPER_NUM);
70 return wrapper_type_names [wrapper_type];
76 append_class_name (GString *res, MonoClass *klass, gboolean include_namespace)
79 g_string_append (res, "Unknown");
82 if (klass->nested_in) {
83 append_class_name (res, klass->nested_in, include_namespace);
84 g_string_append_c (res, '/');
86 if (include_namespace && *(klass->name_space)) {
87 g_string_append (res, klass->name_space);
88 g_string_append_c (res, '.');
90 g_string_append (res, klass->name);
94 find_system_class (const char *name)
96 if (!strcmp (name, "void"))
97 return mono_defaults.void_class;
98 else if (!strcmp (name, "char")) return mono_defaults.char_class;
99 else if (!strcmp (name, "bool")) return mono_defaults.boolean_class;
100 else if (!strcmp (name, "byte")) return mono_defaults.byte_class;
101 else if (!strcmp (name, "sbyte")) return mono_defaults.sbyte_class;
102 else if (!strcmp (name, "uint16")) return mono_defaults.uint16_class;
103 else if (!strcmp (name, "int16")) return mono_defaults.int16_class;
104 else if (!strcmp (name, "uint")) return mono_defaults.uint32_class;
105 else if (!strcmp (name, "int")) return mono_defaults.int32_class;
106 else if (!strcmp (name, "ulong")) return mono_defaults.uint64_class;
107 else if (!strcmp (name, "long")) return mono_defaults.int64_class;
108 else if (!strcmp (name, "uintptr")) return mono_defaults.uint_class;
109 else if (!strcmp (name, "intptr")) return mono_defaults.int_class;
110 else if (!strcmp (name, "single")) return mono_defaults.single_class;
111 else if (!strcmp (name, "double")) return mono_defaults.double_class;
112 else if (!strcmp (name, "string")) return mono_defaults.string_class;
113 else if (!strcmp (name, "object")) return mono_defaults.object_class;
119 mono_type_get_desc (GString *res, MonoType *type, gboolean include_namespace)
123 switch (type->type) {
125 g_string_append (res, "void"); break;
127 g_string_append (res, "char"); break;
128 case MONO_TYPE_BOOLEAN:
129 g_string_append (res, "bool"); break;
131 g_string_append (res, "byte"); break;
133 g_string_append (res, "sbyte"); break;
135 g_string_append (res, "uint16"); break;
137 g_string_append (res, "int16"); break;
139 g_string_append (res, "uint"); break;
141 g_string_append (res, "int"); break;
143 g_string_append (res, "ulong"); break;
145 g_string_append (res, "long"); break;
146 case MONO_TYPE_FNPTR: /* who cares for the exact signature? */
147 g_string_append (res, "*()"); break;
149 g_string_append (res, "uintptr"); break;
151 g_string_append (res, "intptr"); break;
153 g_string_append (res, "single"); break;
155 g_string_append (res, "double"); break;
156 case MONO_TYPE_STRING:
157 g_string_append (res, "string"); break;
158 case MONO_TYPE_OBJECT:
159 g_string_append (res, "object"); break;
161 mono_type_get_desc (res, type->data.type, include_namespace);
162 g_string_append_c (res, '*');
164 case MONO_TYPE_ARRAY:
165 mono_type_get_desc (res, &type->data.array->eklass->byval_arg, include_namespace);
166 g_string_append_c (res, '[');
167 for (i = 1; i < type->data.array->rank; ++i)
168 g_string_append_c (res, ',');
169 g_string_append_c (res, ']');
171 case MONO_TYPE_SZARRAY:
172 mono_type_get_desc (res, &type->data.klass->byval_arg, include_namespace);
173 g_string_append (res, "[]");
175 case MONO_TYPE_CLASS:
176 case MONO_TYPE_VALUETYPE:
177 append_class_name (res, type->data.klass, include_namespace);
179 case MONO_TYPE_GENERICINST: {
180 MonoGenericContext *context;
182 mono_type_get_desc (res, &type->data.generic_class->container_class->byval_arg, include_namespace);
183 g_string_append (res, "<");
184 context = &type->data.generic_class->context;
185 if (context->class_inst) {
186 for (i = 0; i < context->class_inst->type_argc; ++i) {
188 g_string_append (res, ", ");
189 mono_type_get_desc (res, context->class_inst->type_argv [i], include_namespace);
192 if (context->method_inst) {
193 if (context->class_inst)
194 g_string_append (res, "; ");
195 for (i = 0; i < context->method_inst->type_argc; ++i) {
197 g_string_append (res, ", ");
198 mono_type_get_desc (res, context->method_inst->type_argv [i], include_namespace);
201 g_string_append (res, ">");
206 if (type->data.generic_param) {
207 const char *name = mono_generic_param_name (type->data.generic_param);
209 g_string_append (res, name);
211 g_string_append_printf (res, "%s%d", type->type == MONO_TYPE_VAR ? "!" : "!!", mono_generic_param_num (type->data.generic_param));
213 g_string_append (res, "<unknown>");
216 case MONO_TYPE_TYPEDBYREF:
217 g_string_append (res, "typedbyref");
223 g_string_append_c (res, '&');
227 * mono_type_full_name:
230 mono_type_full_name (MonoType *type)
234 str = g_string_new ("");
235 mono_type_get_desc (str, type, TRUE);
236 return g_string_free (str, FALSE);
240 * mono_signature_get_desc:
243 mono_signature_get_desc (MonoMethodSignature *sig, gboolean include_namespace)
250 return g_strdup ("<invalid signature>");
252 res = g_string_new ("");
254 for (i = 0; i < sig->param_count; ++i) {
256 g_string_append_c (res, ',');
257 mono_type_get_desc (res, sig->params [i], include_namespace);
260 g_string_free (res, FALSE);
265 mono_signature_full_name (MonoMethodSignature *sig)
272 return g_strdup ("<invalid signature>");
274 res = g_string_new ("");
276 mono_type_get_desc (res, sig->ret, TRUE);
277 g_string_append_c (res, '(');
278 for (i = 0; i < sig->param_count; ++i) {
280 g_string_append_c (res, ',');
281 mono_type_get_desc (res, sig->params [i], TRUE);
283 g_string_append_c (res, ')');
285 g_string_free (res, FALSE);
290 mono_ginst_get_desc (GString *str, MonoGenericInst *ginst)
294 for (i = 0; i < ginst->type_argc; ++i) {
296 g_string_append (str, ", ");
297 mono_type_get_desc (str, ginst->type_argv [i], TRUE);
302 mono_context_get_desc (MonoGenericContext *context)
307 str = g_string_new ("");
308 g_string_append (str, "<");
310 if (context->class_inst)
311 mono_ginst_get_desc (str, context->class_inst);
312 if (context->method_inst) {
313 if (context->class_inst)
314 g_string_append (str, "; ");
315 mono_ginst_get_desc (str, context->method_inst);
318 g_string_append (str, ">");
319 res = g_strdup (str->str);
320 g_string_free (str, TRUE);
325 * mono_method_desc_new:
326 * \param name the method name.
327 * \param include_namespace whether the name includes a namespace or not.
329 * Creates a method description for \p name, which conforms to the following
332 * <code>[namespace.]classname:methodname[(args...)]</code>
334 * in all the loaded assemblies.
336 * Both classname and methodname can contain <code>*</code> which matches anything.
338 * \returns a parsed representation of the method description.
341 mono_method_desc_new (const char *name, gboolean include_namespace)
343 MonoMethodDesc *result;
344 char *class_name, *class_nspace, *method_name, *use_args, *end;
346 int generic_delim_stack;
348 class_nspace = g_strdup (name);
349 use_args = strchr (class_nspace, '(');
351 /* Allow a ' ' between the method name and the signature */
352 if (use_args > class_nspace && use_args [-1] == ' ')
355 end = strchr (use_args, ')');
357 g_free (class_nspace);
362 method_name = strrchr (class_nspace, ':');
364 g_free (class_nspace);
367 /* allow two :: to separate the method name */
368 if (method_name != class_nspace && method_name [-1] == ':')
369 method_name [-1] = 0;
371 class_name = strrchr (class_nspace, '.');
376 class_name = class_nspace;
379 result = g_new0 (MonoMethodDesc, 1);
380 result->include_namespace = include_namespace;
381 result->name = method_name;
382 result->klass = class_name;
383 result->name_space = use_namespace? class_nspace: NULL;
384 result->args = use_args? use_args: NULL;
385 if (strstr (result->name, "*"))
386 result->name_glob = TRUE;
387 if (strstr (result->klass, "*"))
388 result->klass_glob = TRUE;
392 result->num_args = 1;
393 generic_delim_stack = 0;
396 generic_delim_stack++;
397 else if (*end == '>')
398 generic_delim_stack--;
400 if (*end == ',' && generic_delim_stack == 0)
410 * mono_method_desc_from_method:
413 mono_method_desc_from_method (MonoMethod *method)
415 MonoMethodDesc *result;
417 result = g_new0 (MonoMethodDesc, 1);
418 result->include_namespace = TRUE;
419 result->name = g_strdup (method->name);
420 result->klass = g_strdup (method->klass->name);
421 result->name_space = g_strdup (method->klass->name_space);
427 * mono_method_desc_free:
428 * \param desc method description to be released
429 * Releases the \c MonoMethodDesc object \p desc.
432 mono_method_desc_free (MonoMethodDesc *desc)
434 if (desc->name_space)
435 g_free (desc->name_space);
436 else if (desc->klass)
437 g_free (desc->klass);
442 * mono_method_desc_match:
443 * \param desc \c MonoMethoDescription
444 * \param method \c MonoMethod to test
446 * Determines whether the specified \p method matches the provided \p desc description.
448 * namespace and class are supposed to match already if this function is used.
449 * \returns TRUE if the method matches the description, FALSE otherwise.
452 mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method)
457 name_match = strcmp (desc->name, method->name) == 0;
462 if (desc->num_args != mono_method_signature (method)->param_count)
464 sig = mono_signature_get_desc (mono_method_signature (method), desc->include_namespace);
465 if (strcmp (sig, desc->args)) {
474 my_strrchr (const char *str, char ch, int *len)
478 for (pos = (*len)-1; pos >= 0; pos--) {
490 match_class (MonoMethodDesc *desc, int pos, MonoClass *klass)
494 if (desc->klass_glob && !strcmp (desc->klass, "*"))
497 if (desc->klass_glob && g_pattern_match_simple (desc->klass, klass->name))
500 p = my_strrchr (desc->klass, '/', &pos);
502 if (strncmp (desc->klass, klass->name, pos))
504 if (desc->name_space && strcmp (desc->name_space, klass->name_space))
509 if (strcmp (p+1, klass->name))
511 if (!klass->nested_in)
514 return match_class (desc, pos, klass->nested_in);
518 * mono_method_desc_full_match:
521 mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method)
525 if (!match_class (desc, strlen (desc->klass), method->klass))
528 return mono_method_desc_match (desc, method);
532 * mono_method_desc_search_in_class:
535 mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass)
538 gpointer iter = NULL;
540 while ((m = mono_class_get_methods (klass, &iter)))
541 if (mono_method_desc_match (desc, m))
547 * mono_method_desc_search_in_image:
550 mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image)
553 const MonoTableInfo *methods;
557 /* Handle short names for system classes */
558 if (!desc->name_space && image == mono_defaults.corlib) {
559 klass = find_system_class (desc->klass);
561 return mono_method_desc_search_in_class (desc, klass);
564 if (desc->name_space && desc->klass) {
565 klass = mono_class_try_load_from_name (image, desc->name_space, desc->klass);
568 return mono_method_desc_search_in_class (desc, klass);
571 /* FIXME: Is this call necessary? We don't use its result. */
572 mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
573 methods = mono_image_get_table_info (image, MONO_TABLE_METHOD);
574 for (i = 0; i < mono_table_info_get_rows (methods); ++i) {
576 guint32 token = mono_metadata_decode_row_col (methods, i, MONO_METHOD_NAME);
577 const char *n = mono_metadata_string_heap (image, token);
579 if (strcmp (n, desc->name))
581 method = mono_get_method_checked (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL, NULL, &error);
583 mono_error_cleanup (&error);
586 if (mono_method_desc_full_match (desc, method))
592 static const unsigned char*
593 dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned char *ip, const unsigned char *end)
596 MonoMethodHeader *header = mono_method_get_header_checked (method, &error);
597 const MonoOpcode *opcode;
598 guint32 label, token;
602 const unsigned char* il_code;
605 g_string_append_printf (str, "could not disassemble, bad header due to %s", mono_error_get_message (&error));
606 mono_error_cleanup (&error);
609 il_code = mono_method_header_get_code (header, NULL, NULL);
611 label = ip - il_code;
613 tmp = dh->indenter (dh, method, label);
614 g_string_append (str, tmp);
617 if (dh->label_format)
618 g_string_append_printf (str, dh->label_format, label);
620 i = mono_opcode_value (&ip, end);
622 opcode = &mono_opcodes [i];
623 g_string_append_printf (str, "%-10s", mono_opcode_name (i));
625 switch (opcode->argument) {
629 case MonoInlineField:
630 case MonoInlineMethod:
635 tmp = dh->tokener (dh, method, token);
636 g_string_append (str, tmp);
639 g_string_append_printf (str, "0x%08x", token);
643 case MonoInlineString: {
649 if (!image_is_dynamic (method->klass->image) && !method_is_dynamic (method)) {
651 blob = mono_metadata_user_string (method->klass->image, mono_metadata_token_index (token));
653 len2 = mono_metadata_decode_blob_size (blob, &blob);
656 #ifdef NO_UNALIGNED_ACCESS
657 /* The blob might not be 2 byte aligned */
658 blob2 = g_malloc ((len2 * 2) + 1);
659 memcpy (blob2, blob, len2 * 2);
664 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
666 guint16 *buf = g_new (guint16, len2 + 1);
669 for (i = 0; i < len2; ++i)
670 buf [i] = GUINT16_FROM_LE (((guint16*)blob2) [i]);
671 s = g_utf16_to_utf8 (buf, len2, NULL, NULL, NULL);
675 s = g_utf16_to_utf8 ((gunichar2*)blob2, len2, NULL, NULL, NULL);
678 g_string_append_printf (str, "\"%s\"", s);
687 g_string_append_printf (str, "%d", read16 (ip));
690 case MonoShortInlineVar:
691 g_string_append_printf (str, "%d", (*ip));
694 case MonoInlineBrTarget:
697 if (dh->label_target)
698 g_string_append_printf (str, dh->label_target, ip + sval - il_code);
700 g_string_append_printf (str, "%d", sval);
702 case MonoShortInlineBrTarget:
703 sval = *(const signed char*)ip;
705 if (dh->label_target)
706 g_string_append_printf (str, dh->label_target, ip + sval - il_code);
708 g_string_append_printf (str, "%d", sval);
710 case MonoInlineSwitch: {
711 const unsigned char *end;
715 g_string_append_c (str, '(');
716 for (i = 0; i < sval; ++i) {
718 g_string_append (str, ", ");
720 if (dh->label_target)
721 g_string_append_printf (str, dh->label_target, end + label - il_code);
723 g_string_append_printf (str, "%d", label);
726 g_string_append_c (str, ')');
732 g_string_append_printf (str, "%g", r);
736 case MonoShortInlineR: {
739 g_string_append_printf (str, "%g", r);
744 g_string_append_printf (str, "%d", (gint32)read32 (ip));
747 case MonoShortInlineI:
748 g_string_append_printf (str, "%d", *(const signed char*)ip);
755 g_assert_not_reached ();
758 g_string_append (str, dh->newline);
760 mono_metadata_free_mh (header);
767 "IL_%04x: ", /* label_format */
768 "IL_%04x", /* label_target */
775 * mono_disasm_code_one:
778 mono_disasm_code_one (MonoDisHelper *dh, MonoMethod *method, const guchar *ip, const guchar **endp)
781 GString *res = g_string_new ("");
785 /* set ip + 2 as the end: this is just a debugging method */
786 ip = dis_one (res, dh, method, ip, ip + 2);
791 g_string_free (res, FALSE);
799 mono_disasm_code (MonoDisHelper *dh, MonoMethod *method, const guchar *ip, const guchar* end)
802 GString *res = g_string_new ("");
807 ip = dis_one (res, dh, method, ip, end);
811 g_string_free (res, FALSE);
816 * mono_field_full_name:
817 * \param field field to retrieve information for
818 * \returns the full name for the field, made up of the namespace, type name and the field name.
821 mono_field_full_name (MonoClassField *field)
824 const char *nspace = field->parent->name_space;
826 res = g_strdup_printf ("%s%s%s:%s", nspace, *nspace ? "." : "",
827 field->parent->name, mono_field_get_name (field));
833 mono_method_get_name_full (MonoMethod *method, gboolean signature, gboolean ret, MonoTypeNameFormat format)
838 char *inst_desc = NULL;
841 const char *class_method_separator = ":";
842 const char *method_sig_space = " ";
843 if (format == MONO_TYPE_NAME_FORMAT_REFLECTION) {
844 class_method_separator = ".";
845 method_sig_space = "";
848 if (format == MONO_TYPE_NAME_FORMAT_IL)
849 klass_desc = mono_type_full_name (&method->klass->byval_arg);
851 klass_desc = mono_type_get_name_full (&method->klass->byval_arg, format);
853 if (method->is_inflated && ((MonoMethodInflated*)method)->context.method_inst) {
854 GString *str = g_string_new ("");
855 if (format == MONO_TYPE_NAME_FORMAT_IL)
856 g_string_append (str, "<");
858 g_string_append (str, "[");
859 mono_ginst_get_desc (str, ((MonoMethodInflated*)method)->context.method_inst);
860 if (format == MONO_TYPE_NAME_FORMAT_IL)
861 g_string_append_c (str, '>');
863 g_string_append_c (str, ']');
865 inst_desc = str->str;
866 g_string_free (str, FALSE);
867 } else if (method->is_generic) {
868 MonoGenericContainer *container = mono_method_get_generic_container (method);
870 GString *str = g_string_new ("");
871 if (format == MONO_TYPE_NAME_FORMAT_IL)
872 g_string_append (str, "<");
874 g_string_append (str, "[");
875 mono_ginst_get_desc (str, container->context.method_inst);
876 if (format == MONO_TYPE_NAME_FORMAT_IL)
877 g_string_append_c (str, '>');
879 g_string_append_c (str, ']');
881 inst_desc = str->str;
882 g_string_free (str, FALSE);
885 if (method->wrapper_type != MONO_WRAPPER_NONE)
886 sprintf (wrapper, "(wrapper %s) ", wrapper_type_to_str (method->wrapper_type));
888 strcpy (wrapper, "");
891 MonoMethodSignature *sig = mono_method_signature_checked (method, &error);
894 if (!is_ok (&error)) {
895 tmpsig = g_strdup_printf ("<unable to load signature>");
896 mono_error_cleanup (&error);
898 tmpsig = mono_signature_get_desc (sig, TRUE);
901 if (method->wrapper_type != MONO_WRAPPER_NONE)
902 sprintf (wrapper, "(wrapper %s) ", wrapper_type_to_str (method->wrapper_type));
904 strcpy (wrapper, "");
906 char *ret_str = mono_type_full_name (sig->ret);
907 res = g_strdup_printf ("%s%s %s%s%s%s%s(%s)", wrapper, ret_str, klass_desc,
908 class_method_separator,
909 method->name, inst_desc ? inst_desc : "", method_sig_space, tmpsig);
912 res = g_strdup_printf ("%s%s%s%s%s%s(%s)", wrapper, klass_desc,
913 class_method_separator,
914 method->name, inst_desc ? inst_desc : "", method_sig_space, tmpsig);
918 res = g_strdup_printf ("%s%s%s%s%s", wrapper, klass_desc,
919 class_method_separator,
920 method->name, inst_desc ? inst_desc : "");
930 * mono_method_full_name:
933 mono_method_full_name (MonoMethod *method, gboolean signature)
935 return mono_method_get_name_full (method, signature, FALSE, MONO_TYPE_NAME_FORMAT_IL);
939 mono_method_get_full_name (MonoMethod *method)
941 return mono_method_get_name_full (method, TRUE, TRUE, MONO_TYPE_NAME_FORMAT_IL);
945 * mono_method_get_reflection_name:
947 * Returns the name of the method, including signature, using the same formating as reflection.
950 mono_method_get_reflection_name (MonoMethod *method)
952 return mono_method_get_name_full (method, TRUE, FALSE, MONO_TYPE_NAME_FORMAT_REFLECTION);
956 print_name_space (MonoClass *klass)
958 if (klass->nested_in) {
959 print_name_space (klass->nested_in);
960 g_print ("%s", klass->nested_in->name);
963 if (klass->name_space [0]) {
964 g_print ("%s", klass->name_space);
971 * mono_object_describe:
973 * Prints to stdout a small description of the object \p obj.
974 * For use in a debugger.
977 mono_object_describe (MonoObject *obj)
983 g_print ("(null)\n");
986 klass = mono_object_class (obj);
987 if (klass == mono_defaults.string_class) {
988 char *utf8 = mono_string_to_utf8_checked ((MonoString*)obj, &error);
989 mono_error_cleanup (&error); /* FIXME don't swallow the error */
990 if (utf8 && strlen (utf8) > 60) {
997 g_print ("String at %p, length: %d, '%s'\n", obj, mono_string_length ((MonoString*) obj), utf8);
999 g_print ("String at %p, length: %d, unable to decode UTF16\n", obj, mono_string_length ((MonoString*) obj));
1002 } else if (klass->rank) {
1003 MonoArray *array = (MonoArray*)obj;
1004 sep = print_name_space (klass);
1005 g_print ("%s%s", sep, klass->name);
1006 g_print (" at %p, rank: %d, length: %d\n", obj, klass->rank, (int)mono_array_length (array));
1008 sep = print_name_space (klass);
1009 g_print ("%s%s", sep, klass->name);
1010 g_print (" object at %p (klass: %p)\n", obj, klass);
1016 print_field_value (const char *field_ptr, MonoClassField *field, int type_offset)
1019 g_print ("At %p (ofs: %2d) %s: ", field_ptr, field->offset + type_offset, mono_field_get_name (field));
1020 type = mono_type_get_underlying_type (field->type);
1022 switch (type->type) {
1026 case MONO_TYPE_FNPTR:
1027 g_print ("%p\n", *(const void**)field_ptr);
1029 case MONO_TYPE_STRING:
1030 case MONO_TYPE_SZARRAY:
1031 case MONO_TYPE_CLASS:
1032 case MONO_TYPE_OBJECT:
1033 case MONO_TYPE_ARRAY:
1034 mono_object_describe (*(MonoObject**)field_ptr);
1036 case MONO_TYPE_GENERICINST:
1037 if (!mono_type_generic_inst_is_valuetype (type)) {
1038 mono_object_describe (*(MonoObject**)field_ptr);
1043 case MONO_TYPE_VALUETYPE: {
1044 MonoClass *k = mono_class_from_mono_type (type);
1045 g_print ("%s ValueType (type: %p) at %p\n", k->name, k, field_ptr);
1049 g_print ("%d\n", *(gint8*)field_ptr);
1052 g_print ("%d\n", *(guint8*)field_ptr);
1055 g_print ("%d\n", *(gint16*)field_ptr);
1058 g_print ("%d\n", *(guint16*)field_ptr);
1061 g_print ("%d\n", *(gint32*)field_ptr);
1064 g_print ("%u\n", *(guint32*)field_ptr);
1067 g_print ("%lld\n", (long long int)*(gint64*)field_ptr);
1070 g_print ("%llu\n", (long long unsigned int)*(guint64*)field_ptr);
1073 g_print ("%f\n", *(gfloat*)field_ptr);
1076 g_print ("%f\n", *(gdouble*)field_ptr);
1078 case MONO_TYPE_BOOLEAN:
1079 g_print ("%s (%d)\n", *(guint8*)field_ptr? "True": "False", *(guint8*)field_ptr);
1081 case MONO_TYPE_CHAR:
1082 g_print ("'%c' (%d 0x%04x)\n", *(guint16*)field_ptr, *(guint16*)field_ptr, *(guint16*)field_ptr);
1085 g_assert_not_reached ();
1091 objval_describe (MonoClass *klass, const char *addr)
1093 MonoClassField *field;
1095 const char *field_ptr;
1096 gssize type_offset = 0;
1098 if (klass->valuetype)
1099 type_offset = -sizeof (MonoObject);
1101 for (p = klass; p != NULL; p = p->parent) {
1102 gpointer iter = NULL;
1103 int printed_header = FALSE;
1104 while ((field = mono_class_get_fields (p, &iter))) {
1105 if (field->type->attrs & (FIELD_ATTRIBUTE_STATIC | FIELD_ATTRIBUTE_HAS_FIELD_RVA))
1108 if (p != klass && !printed_header) {
1110 g_print ("In class ");
1111 sep = print_name_space (p);
1112 g_print ("%s%s:\n", sep, p->name);
1113 printed_header = TRUE;
1115 field_ptr = (const char*)addr + field->offset + type_offset;
1117 print_field_value (field_ptr, field, type_offset);
1123 * mono_object_describe_fields:
1125 * Prints to stdout a small description of each field of the object \p obj.
1126 * For use in a debugger.
1129 mono_object_describe_fields (MonoObject *obj)
1131 MonoClass *klass = mono_object_class (obj);
1132 objval_describe (klass, (char*)obj);
1136 * mono_value_describe_fields:
1138 * Prints to stdout a small description of each field of the value type
1139 * stored at \p addr of type \p klass.
1140 * For use in a debugger.
1143 mono_value_describe_fields (MonoClass* klass, const char* addr)
1145 objval_describe (klass, addr);
1149 * mono_class_describe_statics:
1151 * Prints to stdout a small description of each static field of the type \p klass
1152 * in the current application domain.
1153 * For use in a debugger.
1156 mono_class_describe_statics (MonoClass* klass)
1159 MonoClassField *field;
1161 const char *field_ptr;
1162 MonoVTable *vtable = mono_class_vtable_full (mono_domain_get (), klass, &error);
1165 if (!vtable || !is_ok (&error)) {
1166 mono_error_cleanup (&error);
1170 if (!(addr = (const char *)mono_vtable_get_static_field_data (vtable)))
1173 for (p = klass; p != NULL; p = p->parent) {
1174 gpointer iter = NULL;
1175 while ((field = mono_class_get_fields (p, &iter))) {
1176 if (field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
1178 if (!(field->type->attrs & (FIELD_ATTRIBUTE_STATIC | FIELD_ATTRIBUTE_HAS_FIELD_RVA)))
1181 field_ptr = (const char*)addr + field->offset;
1183 print_field_value (field_ptr, field, 0);
1189 * mono_print_method_code
1190 * \param method: a pointer to the method
1192 * This method is used from a debugger to print the code of the method.
1194 * This prints the IL code of the method in the standard output.
1197 mono_method_print_code (MonoMethod *method)
1201 MonoMethodHeader *header = mono_method_get_header_checked (method, &error);
1203 printf ("METHOD HEADER NOT FOUND DUE TO: %s\n", mono_error_get_message (&error));
1204 mono_error_cleanup (&error);
1207 code = mono_disasm_code (0, method, header->code, header->code + header->code_size);
1208 printf ("CODE FOR %s:\n%s\n", mono_method_full_name (method, TRUE), code);