5 * Mono Project (http://www.mono-project.com)
7 * Copyright (C) 2005-2008 Novell, Inc. (http://www.novell.com)
11 #include "mono/metadata/tokentype.h"
12 #include "mono/metadata/opcodes.h"
13 #include "mono/metadata/metadata-internals.h"
14 #include "mono/metadata/class-internals.h"
15 #include "mono/metadata/object-internals.h"
16 #include "mono/metadata/mono-endian.h"
17 #include "mono/metadata/debug-helpers.h"
18 #include "mono/metadata/tabledefs.h"
19 #include "mono/metadata/appdomain.h"
21 struct MonoMethodDesc {
27 gboolean include_namespace, klass_glob, name_glob;
30 #ifdef HAVE_ARRAY_ELEM_INIT
31 #define MSGSTRFIELD(line) MSGSTRFIELD1(line)
32 #define MSGSTRFIELD1(line) str##line
33 static const struct msgstr_t {
34 #define WRAPPER(a,b) char MSGSTRFIELD(__LINE__) [sizeof (b)];
35 #include "wrapper-types.h"
38 #define WRAPPER(a,b) b,
39 #include "wrapper-types.h"
42 static const gint16 opidx [] = {
43 #define WRAPPER(a,b) [MONO_WRAPPER_ ## a] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
44 #include "wrapper-types.h"
49 wrapper_type_to_str (guint32 wrapper_type)
51 g_assert (wrapper_type < MONO_WRAPPER_NUM);
53 return (const char*)&opstr + opidx [wrapper_type];
57 #define WRAPPER(a,b) b,
58 static const char* const
59 wrapper_type_names [MONO_WRAPPER_NUM + 1] = {
60 #include "wrapper-types.h"
65 wrapper_type_to_str (guint32 wrapper_type)
67 g_assert (wrapper_type < MONO_WRAPPER_NUM);
69 return wrapper_type_names [wrapper_type];
75 append_class_name (GString *res, MonoClass *klass, gboolean include_namespace)
78 g_string_append (res, "Unknown");
81 if (klass->nested_in) {
82 append_class_name (res, klass->nested_in, include_namespace);
83 g_string_append_c (res, '/');
85 if (include_namespace && *(klass->name_space)) {
86 g_string_append (res, klass->name_space);
87 g_string_append_c (res, '.');
89 g_string_append (res, klass->name);
93 find_system_class (const char *name)
95 if (!strcmp (name, "void"))
96 return mono_defaults.void_class;
97 else if (!strcmp (name, "char")) return mono_defaults.char_class;
98 else if (!strcmp (name, "bool")) return mono_defaults.boolean_class;
99 else if (!strcmp (name, "byte")) return mono_defaults.byte_class;
100 else if (!strcmp (name, "sbyte")) return mono_defaults.sbyte_class;
101 else if (!strcmp (name, "uint16")) return mono_defaults.uint16_class;
102 else if (!strcmp (name, "int16")) return mono_defaults.int16_class;
103 else if (!strcmp (name, "uint")) return mono_defaults.uint32_class;
104 else if (!strcmp (name, "int")) return mono_defaults.int32_class;
105 else if (!strcmp (name, "ulong")) return mono_defaults.uint64_class;
106 else if (!strcmp (name, "long")) return mono_defaults.int64_class;
107 else if (!strcmp (name, "uintptr")) return mono_defaults.uint_class;
108 else if (!strcmp (name, "intptr")) return mono_defaults.int_class;
109 else if (!strcmp (name, "single")) return mono_defaults.single_class;
110 else if (!strcmp (name, "double")) return mono_defaults.double_class;
111 else if (!strcmp (name, "string")) return mono_defaults.string_class;
112 else if (!strcmp (name, "object")) return mono_defaults.object_class;
118 mono_type_get_desc (GString *res, MonoType *type, gboolean include_namespace)
122 switch (type->type) {
124 g_string_append (res, "void"); break;
126 g_string_append (res, "char"); break;
127 case MONO_TYPE_BOOLEAN:
128 g_string_append (res, "bool"); break;
130 g_string_append (res, "byte"); break;
132 g_string_append (res, "sbyte"); break;
134 g_string_append (res, "uint16"); break;
136 g_string_append (res, "int16"); break;
138 g_string_append (res, "uint"); break;
140 g_string_append (res, "int"); break;
142 g_string_append (res, "ulong"); break;
144 g_string_append (res, "long"); break;
145 case MONO_TYPE_FNPTR: /* who cares for the exact signature? */
146 g_string_append (res, "*()"); break;
148 g_string_append (res, "uintptr"); break;
150 g_string_append (res, "intptr"); break;
152 g_string_append (res, "single"); break;
154 g_string_append (res, "double"); break;
155 case MONO_TYPE_STRING:
156 g_string_append (res, "string"); break;
157 case MONO_TYPE_OBJECT:
158 g_string_append (res, "object"); break;
160 mono_type_get_desc (res, type->data.type, include_namespace);
161 g_string_append_c (res, '*');
163 case MONO_TYPE_ARRAY:
164 mono_type_get_desc (res, &type->data.array->eklass->byval_arg, include_namespace);
165 g_string_append_printf (res, "[%d]", type->data.array->rank);
167 case MONO_TYPE_SZARRAY:
168 mono_type_get_desc (res, &type->data.klass->byval_arg, include_namespace);
169 g_string_append (res, "[]");
171 case MONO_TYPE_CLASS:
172 case MONO_TYPE_VALUETYPE:
173 append_class_name (res, type->data.klass, include_namespace);
175 case MONO_TYPE_GENERICINST: {
176 MonoGenericContext *context;
178 mono_type_get_desc (res, &type->data.generic_class->container_class->byval_arg, include_namespace);
179 g_string_append (res, "<");
180 context = &type->data.generic_class->context;
181 if (context->class_inst) {
182 for (i = 0; i < context->class_inst->type_argc; ++i) {
184 g_string_append (res, ", ");
185 mono_type_get_desc (res, context->class_inst->type_argv [i], include_namespace);
188 if (context->method_inst) {
189 if (context->class_inst)
190 g_string_append (res, "; ");
191 for (i = 0; i < context->method_inst->type_argc; ++i) {
193 g_string_append (res, ", ");
194 mono_type_get_desc (res, context->method_inst->type_argv [i], include_namespace);
197 g_string_append (res, ">");
202 if (type->data.generic_param) {
203 const char *name = mono_generic_param_name (type->data.generic_param);
205 g_string_append (res, name);
207 g_string_append_printf (res, "%s%d", type->type == MONO_TYPE_VAR ? "!" : "!!", mono_generic_param_num (type->data.generic_param));
209 g_string_append (res, "<unknown>");
212 case MONO_TYPE_TYPEDBYREF:
213 g_string_append (res, "typedbyref");
219 g_string_append_c (res, '&');
223 mono_type_full_name (MonoType *type)
227 str = g_string_new ("");
228 mono_type_get_desc (str, type, TRUE);
229 return g_string_free (str, FALSE);
233 mono_signature_get_desc (MonoMethodSignature *sig, gboolean include_namespace)
240 return g_strdup ("<invalid signature>");
242 res = g_string_new ("");
244 for (i = 0; i < sig->param_count; ++i) {
246 g_string_append_c (res, ',');
247 mono_type_get_desc (res, sig->params [i], include_namespace);
250 g_string_free (res, FALSE);
255 ginst_get_desc (GString *str, MonoGenericInst *ginst)
259 for (i = 0; i < ginst->type_argc; ++i) {
261 g_string_append (str, ", ");
262 mono_type_get_desc (str, ginst->type_argv [i], TRUE);
267 mono_context_get_desc (MonoGenericContext *context)
272 str = g_string_new ("");
273 g_string_append (str, "<");
275 if (context->class_inst)
276 ginst_get_desc (str, context->class_inst);
277 if (context->method_inst) {
278 if (context->class_inst)
279 g_string_append (str, "; ");
280 ginst_get_desc (str, context->method_inst);
283 g_string_append (str, ">");
284 res = g_strdup (str->str);
285 g_string_free (str, TRUE);
290 * mono_method_desc_new:
291 * @name: the method name.
292 * @include_namespace: whether the name includes a namespace or not.
294 * Creates a method description for @name, which conforms to the following
297 * [namespace.]classname:methodname[(args...)]
299 * in all the loaded assemblies.
301 * Both classname and methodname can contain '*' which matches anything.
303 * Returns: a parsed representation of the method description.
306 mono_method_desc_new (const char *name, gboolean include_namespace)
308 MonoMethodDesc *result;
309 char *class_name, *class_nspace, *method_name, *use_args, *end;
312 class_nspace = g_strdup (name);
313 use_args = strchr (class_nspace, '(');
315 /* Allow a ' ' between the method name and the signature */
316 if (use_args > class_nspace && use_args [-1] == ' ')
319 end = strchr (use_args, ')');
321 g_free (class_nspace);
326 method_name = strrchr (class_nspace, ':');
328 g_free (class_nspace);
331 /* allow two :: to separate the method name */
332 if (method_name != class_nspace && method_name [-1] == ':')
333 method_name [-1] = 0;
335 class_name = strrchr (class_nspace, '.');
340 class_name = class_nspace;
343 result = g_new0 (MonoMethodDesc, 1);
344 result->include_namespace = include_namespace;
345 result->name = method_name;
346 result->klass = class_name;
347 result->name_space = use_namespace? class_nspace: NULL;
348 result->args = use_args? use_args: NULL;
349 if (strstr (result->name, "*"))
350 result->name_glob = TRUE;
351 if (strstr (result->klass, "*"))
352 result->klass_glob = TRUE;
356 result->num_args = 1;
368 mono_method_desc_from_method (MonoMethod *method)
370 MonoMethodDesc *result;
372 result = g_new0 (MonoMethodDesc, 1);
373 result->include_namespace = TRUE;
374 result->name = g_strdup (method->name);
375 result->klass = g_strdup (method->klass->name);
376 result->name_space = g_strdup (method->klass->name_space);
382 * mono_method_desc_free:
383 * @desc: method description to be released
385 * Releases the MonoMethodDesc object @desc.
388 mono_method_desc_free (MonoMethodDesc *desc)
390 if (desc->name_space)
391 g_free (desc->name_space);
392 else if (desc->klass)
393 g_free (desc->klass);
398 * namespace and class are supposed to match already if this function is used.
401 mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method)
406 name_match = strcmp (desc->name, method->name) == 0;
408 if (!name_match && desc->name_glob)
409 name_match = g_pattern_match_simple (desc->name, method->name);
415 if (desc->num_args != mono_method_signature (method)->param_count)
417 sig = mono_signature_get_desc (mono_method_signature (method), desc->include_namespace);
418 if (strcmp (sig, desc->args)) {
427 my_strrchr (const char *str, char ch, int *len)
431 for (pos = (*len)-1; pos >= 0; pos--) {
443 match_class (MonoMethodDesc *desc, int pos, MonoClass *klass)
447 if (desc->klass_glob && !strcmp (desc->klass, "*"))
450 if (desc->klass_glob && g_pattern_match_simple (desc->klass, klass->name))
453 p = my_strrchr (desc->klass, '/', &pos);
455 if (strncmp (desc->klass, klass->name, pos))
457 if (desc->name_space && strcmp (desc->name_space, klass->name_space))
462 if (strcmp (p+1, klass->name))
464 if (!klass->nested_in)
467 return match_class (desc, pos, klass->nested_in);
471 mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method)
475 if (!match_class (desc, strlen (desc->klass), method->klass))
478 return mono_method_desc_match (desc, method);
482 mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass)
485 gpointer iter = NULL;
487 while ((m = mono_class_get_methods (klass, &iter)))
488 if (mono_method_desc_match (desc, m))
494 mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image)
497 const MonoTableInfo *methods;
501 /* Handle short names for system classes */
502 if (!desc->name_space && image == mono_defaults.corlib) {
503 klass = find_system_class (desc->klass);
505 return mono_method_desc_search_in_class (desc, klass);
508 if (desc->name_space && desc->klass) {
509 klass = mono_class_from_name (image, desc->name_space, desc->klass);
512 return mono_method_desc_search_in_class (desc, klass);
515 /* FIXME: Is this call necessary? We don't use its result. */
516 mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
517 methods = mono_image_get_table_info (image, MONO_TABLE_METHOD);
518 for (i = 0; i < mono_table_info_get_rows (methods); ++i) {
519 guint32 token = mono_metadata_decode_row_col (methods, i, MONO_METHOD_NAME);
520 const char *n = mono_metadata_string_heap (image, token);
522 if (strcmp (n, desc->name))
524 method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
525 if (mono_method_desc_full_match (desc, method))
531 static const unsigned char*
532 dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned char *ip, const unsigned char *end)
534 MonoMethodHeader *header = mono_method_get_header (method);
535 const MonoOpcode *opcode;
536 guint32 label, token;
540 const unsigned char* il_code = mono_method_header_get_code (header, NULL, NULL);
542 label = ip - il_code;
544 tmp = dh->indenter (dh, method, label);
545 g_string_append (str, tmp);
548 if (dh->label_format)
549 g_string_append_printf (str, dh->label_format, label);
551 i = mono_opcode_value (&ip, end);
553 opcode = &mono_opcodes [i];
554 g_string_append_printf (str, "%-10s", mono_opcode_name (i));
556 switch (opcode->argument) {
560 case MonoInlineField:
561 case MonoInlineMethod:
566 tmp = dh->tokener (dh, method, token);
567 g_string_append (str, tmp);
570 g_string_append_printf (str, "0x%08x", token);
574 case MonoInlineString: {
580 if (!image_is_dynamic (method->klass->image) && !method_is_dynamic (method)) {
582 blob = mono_metadata_user_string (method->klass->image, mono_metadata_token_index (token));
584 len2 = mono_metadata_decode_blob_size (blob, &blob);
587 #ifdef NO_UNALIGNED_ACCESS
588 /* The blob might not be 2 byte aligned */
589 blob2 = g_malloc ((len2 * 2) + 1);
590 memcpy (blob2, blob, len2 * 2);
595 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
597 guint16 *buf = g_new (guint16, len2 + 1);
600 for (i = 0; i < len2; ++i)
601 buf [i] = GUINT16_FROM_LE (((guint16*)blob2) [i]);
602 s = g_utf16_to_utf8 (buf, len2, NULL, NULL, NULL);
606 s = g_utf16_to_utf8 ((gunichar2*)blob2, len2, NULL, NULL, NULL);
609 g_string_append_printf (str, "\"%s\"", s);
618 g_string_append_printf (str, "%d", read16 (ip));
621 case MonoShortInlineVar:
622 g_string_append_printf (str, "%d", (*ip));
625 case MonoInlineBrTarget:
628 if (dh->label_target)
629 g_string_append_printf (str, dh->label_target, ip + sval - il_code);
631 g_string_append_printf (str, "%d", sval);
633 case MonoShortInlineBrTarget:
634 sval = *(const signed char*)ip;
636 if (dh->label_target)
637 g_string_append_printf (str, dh->label_target, ip + sval - il_code);
639 g_string_append_printf (str, "%d", sval);
641 case MonoInlineSwitch: {
642 const unsigned char *end;
646 g_string_append_c (str, '(');
647 for (i = 0; i < sval; ++i) {
649 g_string_append (str, ", ");
651 if (dh->label_target)
652 g_string_append_printf (str, dh->label_target, end + label - il_code);
654 g_string_append_printf (str, "%d", label);
657 g_string_append_c (str, ')');
663 g_string_append_printf (str, "%g", r);
667 case MonoShortInlineR: {
670 g_string_append_printf (str, "%g", r);
675 g_string_append_printf (str, "%d", (gint32)read32 (ip));
678 case MonoShortInlineI:
679 g_string_append_printf (str, "%d", *(const signed char*)ip);
686 g_assert_not_reached ();
689 g_string_append (str, dh->newline);
691 mono_metadata_free_mh (header);
698 "IL_%04x: ", /* label_format */
699 "IL_%04x", /* label_target */
706 mono_disasm_code_one (MonoDisHelper *dh, MonoMethod *method, const guchar *ip, const guchar **endp)
709 GString *res = g_string_new ("");
713 /* set ip + 2 as the end: this is just a debugging method */
714 ip = dis_one (res, dh, method, ip, ip + 2);
719 g_string_free (res, FALSE);
724 mono_disasm_code (MonoDisHelper *dh, MonoMethod *method, const guchar *ip, const guchar* end)
727 GString *res = g_string_new ("");
732 ip = dis_one (res, dh, method, ip, end);
736 g_string_free (res, FALSE);
741 mono_field_full_name (MonoClassField *field)
744 const char *nspace = field->parent->name_space;
746 res = g_strdup_printf ("%s%s%s:%s", nspace, *nspace ? "." : "",
747 field->parent->name, mono_field_get_name (field));
753 mono_method_get_name_full (MonoMethod *method, gboolean signature, MonoTypeNameFormat format)
758 char *inst_desc = NULL;
760 if (format == MONO_TYPE_NAME_FORMAT_IL)
761 klass_desc = mono_type_full_name (&method->klass->byval_arg);
763 klass_desc = mono_type_get_name_full (&method->klass->byval_arg, format);
765 if (method->is_inflated && ((MonoMethodInflated*)method)->context.method_inst) {
766 GString *str = g_string_new ("");
767 if (format == MONO_TYPE_NAME_FORMAT_IL)
768 g_string_append (str, "<");
770 g_string_append (str, "[");
771 ginst_get_desc (str, ((MonoMethodInflated*)method)->context.method_inst);
772 if (format == MONO_TYPE_NAME_FORMAT_IL)
773 g_string_append_c (str, '>');
775 g_string_append_c (str, ']');
777 inst_desc = str->str;
778 g_string_free (str, FALSE);
779 } else if (method->is_generic) {
780 MonoGenericContainer *container = mono_method_get_generic_container (method);
782 GString *str = g_string_new ("");
783 if (format == MONO_TYPE_NAME_FORMAT_IL)
784 g_string_append (str, "<");
786 g_string_append (str, "[");
787 ginst_get_desc (str, container->context.method_inst);
788 if (format == MONO_TYPE_NAME_FORMAT_IL)
789 g_string_append_c (str, '>');
791 g_string_append_c (str, ']');
793 inst_desc = str->str;
794 g_string_free (str, FALSE);
797 if (method->wrapper_type != MONO_WRAPPER_NONE)
798 sprintf (wrapper, "(wrapper %s) ", wrapper_type_to_str (method->wrapper_type));
800 strcpy (wrapper, "");
803 char *tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE);
805 if (method->wrapper_type != MONO_WRAPPER_NONE)
806 sprintf (wrapper, "(wrapper %s) ", wrapper_type_to_str (method->wrapper_type));
808 strcpy (wrapper, "");
809 res = g_strdup_printf ("%s%s:%s%s (%s)", wrapper, klass_desc,
810 method->name, inst_desc ? inst_desc : "", tmpsig);
813 res = g_strdup_printf ("%s%s:%s%s", wrapper, klass_desc,
814 method->name, inst_desc ? inst_desc : "");
824 mono_method_full_name (MonoMethod *method, gboolean signature)
826 return mono_method_get_name_full (method, signature, MONO_TYPE_NAME_FORMAT_IL);
830 print_name_space (MonoClass *klass)
832 if (klass->nested_in) {
833 print_name_space (klass->nested_in);
834 g_print ("%s", klass->nested_in->name);
837 if (klass->name_space [0]) {
838 g_print ("%s", klass->name_space);
845 * mono_object_describe:
847 * Prints to stdout a small description of the object @obj.
848 * For use in a debugger.
851 mono_object_describe (MonoObject *obj)
856 g_print ("(null)\n");
859 klass = mono_object_class (obj);
860 if (klass == mono_defaults.string_class) {
861 char *utf8 = mono_string_to_utf8 ((MonoString*)obj);
862 if (strlen (utf8) > 60) {
868 g_print ("String at %p, length: %d, '%s'\n", obj, mono_string_length ((MonoString*) obj), utf8);
870 } else if (klass->rank) {
871 MonoArray *array = (MonoArray*)obj;
872 sep = print_name_space (klass);
873 g_print ("%s%s", sep, klass->name);
874 g_print (" at %p, rank: %d, length: %d\n", obj, klass->rank, (int)mono_array_length (array));
876 sep = print_name_space (klass);
877 g_print ("%s%s", sep, klass->name);
878 g_print (" object at %p (klass: %p)\n", obj, klass);
884 print_field_value (const char *field_ptr, MonoClassField *field, int type_offset)
887 g_print ("At %p (ofs: %2d) %s: ", field_ptr, field->offset + type_offset, mono_field_get_name (field));
888 type = mono_type_get_underlying_type (field->type);
890 switch (type->type) {
894 case MONO_TYPE_FNPTR:
895 g_print ("%p\n", *(const void**)field_ptr);
897 case MONO_TYPE_STRING:
898 case MONO_TYPE_SZARRAY:
899 case MONO_TYPE_CLASS:
900 case MONO_TYPE_OBJECT:
901 case MONO_TYPE_ARRAY:
902 mono_object_describe (*(MonoObject**)field_ptr);
904 case MONO_TYPE_GENERICINST:
905 if (!mono_type_generic_inst_is_valuetype (type)) {
906 mono_object_describe (*(MonoObject**)field_ptr);
911 case MONO_TYPE_VALUETYPE: {
912 MonoClass *k = mono_class_from_mono_type (type);
913 g_print ("%s ValueType (type: %p) at %p\n", k->name, k, field_ptr);
917 g_print ("%d\n", *(gint8*)field_ptr);
920 g_print ("%d\n", *(guint8*)field_ptr);
923 g_print ("%d\n", *(gint16*)field_ptr);
926 g_print ("%d\n", *(guint16*)field_ptr);
929 g_print ("%d\n", *(gint32*)field_ptr);
932 g_print ("%u\n", *(guint32*)field_ptr);
935 g_print ("%lld\n", (long long int)*(gint64*)field_ptr);
938 g_print ("%llu\n", (long long unsigned int)*(guint64*)field_ptr);
941 g_print ("%f\n", *(gfloat*)field_ptr);
944 g_print ("%f\n", *(gdouble*)field_ptr);
946 case MONO_TYPE_BOOLEAN:
947 g_print ("%s (%d)\n", *(guint8*)field_ptr? "True": "False", *(guint8*)field_ptr);
950 g_print ("'%c' (%d 0x%04x)\n", *(guint16*)field_ptr, *(guint16*)field_ptr, *(guint16*)field_ptr);
953 g_assert_not_reached ();
959 objval_describe (MonoClass *klass, const char *addr)
961 MonoClassField *field;
963 const char *field_ptr;
964 gssize type_offset = 0;
966 if (klass->valuetype)
967 type_offset = -sizeof (MonoObject);
969 for (p = klass; p != NULL; p = p->parent) {
970 gpointer iter = NULL;
971 int printed_header = FALSE;
972 while ((field = mono_class_get_fields (p, &iter))) {
973 if (field->type->attrs & (FIELD_ATTRIBUTE_STATIC | FIELD_ATTRIBUTE_HAS_FIELD_RVA))
976 if (p != klass && !printed_header) {
978 g_print ("In class ");
979 sep = print_name_space (p);
980 g_print ("%s%s:\n", sep, p->name);
981 printed_header = TRUE;
983 field_ptr = (const char*)addr + field->offset + type_offset;
985 print_field_value (field_ptr, field, type_offset);
991 * mono_object_describe_fields:
993 * Prints to stdout a small description of each field of the object @obj.
994 * For use in a debugger.
997 mono_object_describe_fields (MonoObject *obj)
999 MonoClass *klass = mono_object_class (obj);
1000 objval_describe (klass, (char*)obj);
1004 * mono_value_describe_fields:
1006 * Prints to stdout a small description of each field of the value type
1007 * stored at @addr of type @klass.
1008 * For use in a debugger.
1011 mono_value_describe_fields (MonoClass* klass, const char* addr)
1013 objval_describe (klass, addr);
1017 * mono_class_describe_statics:
1019 * Prints to stdout a small description of each static field of the type @klass
1020 * in the current application domain.
1021 * For use in a debugger.
1024 mono_class_describe_statics (MonoClass* klass)
1026 MonoClassField *field;
1028 const char *field_ptr;
1029 MonoVTable *vtable = mono_class_vtable_full (mono_domain_get (), klass, FALSE);
1034 if (!(addr = mono_vtable_get_static_field_data (vtable)))
1037 for (p = klass; p != NULL; p = p->parent) {
1038 gpointer iter = NULL;
1039 while ((field = mono_class_get_fields (p, &iter))) {
1040 if (field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
1042 if (!(field->type->attrs & (FIELD_ATTRIBUTE_STATIC | FIELD_ATTRIBUTE_HAS_FIELD_RVA)))
1045 field_ptr = (const char*)addr + field->offset;
1047 print_field_value (field_ptr, field, 0);
1053 * mono_print_method_code
1054 * @MonoMethod: a pointer to the method
1056 * This method is used from a debugger to print the code of the method.
1058 * This prints the IL code of the method in the standard output.
1061 mono_method_print_code (MonoMethod *method)
1064 MonoMethodHeader *header = mono_method_get_header (method);
1066 printf ("METHOD HEADER NOT FOUND\n");
1069 code = mono_disasm_code (0, method, header->code, header->code + header->code_size);
1070 printf ("CODE FOR %s:\n%s\n", mono_method_full_name (method, TRUE), code);