mono/metadata/debug-helpers.c

   1
   2 #include <string.h>
   3 #include "mono/metadata/tokentype.h"
   4 #include "mono/metadata/opcodes.h"
   5 #include "mono/metadata/class-internals.h"
   6 #include "mono/metadata/mono-endian.h"
   7 #include "mono/metadata/debug-helpers.h"
   8
   9 struct MonoMethodDesc {
  10         char *namespace;
  11         char *klass;
  12         char *name;
  13         char *args;
  14         guint num_args;
  15         gboolean include_namespace;
  16 };
  17
  18 static const char *wrapper_type_names [] = {
  19         "none",
  20         "delegate-invoke",
  21         "delegate-begin-invoke",
  22         "delegate-end-invoke",
  23         "runtime-invoke",
  24         "native-to-managed",
  25         "managed-to-native",
  26         "remoting-invoke",
  27         "remoting-invoke-with-check",
  28         "ldfld",
  29         "stfld",
  30         "synchronized",
  31         "dynamic-method",
  32         "isinst",
  33         "cancast",
  34         "proxy_isinst",
  35         "stelemref",
  36         "unknown"
  37 };
  38
  39 static void
  40 append_class_name (GString *res, MonoClass *class, gboolean include_namespace)
  41 {
  42         if (!class) {
  43                 g_string_append (res, "Unknown");
  44                 return;
  45         }
  46         if (class->nested_in) {
  47                 append_class_name (res, class->nested_in, include_namespace);
  48                 g_string_append_c (res, '/');
  49         }
  50         if (include_namespace && *(class->name_space))
  51                 g_string_sprintfa (res, "%s.", class->name_space);
  52         g_string_sprintfa (res, "%s", class->name);
  53 }
  54
  55 void
  56 mono_type_get_desc (GString *res, MonoType *type, gboolean include_namespace) {
  57         switch (type->type) {
  58         case MONO_TYPE_VOID:
  59                 g_string_append (res, "void"); break;
  60         case MONO_TYPE_CHAR:
  61                 g_string_append (res, "char"); break;
  62         case MONO_TYPE_BOOLEAN:
  63                 g_string_append (res, "bool"); break;
  64         case MONO_TYPE_U1:
  65                 g_string_append (res, "byte"); break;
  66         case MONO_TYPE_I1:
  67                 g_string_append (res, "sbyte"); break;
  68         case MONO_TYPE_U2:
  69                 g_string_append (res, "uint16"); break;
  70         case MONO_TYPE_I2:
  71                 g_string_append (res, "int16"); break;
  72         case MONO_TYPE_U4:
  73                 g_string_append (res, "uint"); break;
  74         case MONO_TYPE_I4:
  75                 g_string_append (res, "int"); break;
  76         case MONO_TYPE_U8:
  77                 g_string_append (res, "ulong"); break;
  78         case MONO_TYPE_I8:
  79                 g_string_append (res, "long"); break;
  80         case MONO_TYPE_FNPTR: /* who cares for the exact signature? */
  81                 g_string_append (res, "*()"); break;
  82         case MONO_TYPE_U:
  83                 g_string_append (res, "uintptr"); break;
  84         case MONO_TYPE_I:
  85                 g_string_append (res, "intptr"); break;
  86         case MONO_TYPE_R4:
  87                 g_string_append (res, "single"); break;
  88         case MONO_TYPE_R8:
  89                 g_string_append (res, "double"); break;
  90         case MONO_TYPE_STRING:
  91                 g_string_append (res, "string"); break;
  92         case MONO_TYPE_OBJECT:
  93                 g_string_append (res, "object"); break;
  94         case MONO_TYPE_PTR:
  95                 mono_type_get_desc (res, type->data.type, include_namespace);
  96                 g_string_append_c (res, '*');
  97                 break;
  98         case MONO_TYPE_ARRAY:
  99                 append_class_name (res, type->data.array->eklass, include_namespace);
 100                 g_string_sprintfa (res, "[%d]", type->data.array->rank);
 101                 break;
 102         case MONO_TYPE_SZARRAY:
 103                 mono_type_get_desc (res, &type->data.klass->byval_arg, include_namespace);
 104                 g_string_append (res, "[]");
 105                 break;
 106         case MONO_TYPE_CLASS:
 107         case MONO_TYPE_VALUETYPE:
 108                 append_class_name (res, type->data.klass, include_namespace);
 109                 break;
 110         default:
 111                 break;
 112         }
 113         if (type->byref)
 114                 g_string_append_c (res, '&');
 115 }
 116
 117 char*
 118 mono_type_full_name (MonoType *type)
 119 {
 120         GString *str;
 121         char *res;
 122
 123         str = g_string_new ("");
 124         mono_type_get_desc (str, type, TRUE);
 125
 126         res = g_strdup (str->str);
 127         g_string_free (str, TRUE);
 128         return res;
 129 }
 130
 131 char*
 132 mono_signature_get_desc (MonoMethodSignature *sig, gboolean include_namespace)
 133 {
 134         int i;
 135         char *result;
 136         GString *res = g_string_new ("");
 137
 138         for (i = 0; i < sig->param_count; ++i) {
 139                 if (i > 0)
 140                         g_string_append_c (res, ',');
 141                 mono_type_get_desc (res, sig->params [i], include_namespace);
 142         }
 143         result = res->str;
 144         g_string_free (res, FALSE);
 145         return result;
 146 }
 147
 148 /**
 149  * mono_method_desc_new:
 150  *
 151  * Creates a method description for `name', which conforms to the following
 152  * specification:
 153  *
 154  * [namespace.]classname:methodname[(args...)]
 155  *
 156  * in all the loaded assemblies.
 157  *
 158  * Returns a parsed representation of the method description.
 159  */
 160 MonoMethodDesc*
 161 mono_method_desc_new (const char *name, gboolean include_namespace)
 162 {
 163         MonoMethodDesc *result;
 164         char *class_name, *class_nspace, *method_name, *use_args, *end;
 165         int use_namespace;
 166
 167         class_nspace = g_strdup (name);
 168         use_args = strchr (class_nspace, '(');
 169         if (use_args) {
 170                 *use_args++ = 0;
 171                 end = strchr (use_args, ')');
 172                 if (!end) {
 173                         g_free (class_nspace);
 174                         return NULL;
 175                 }
 176                 *end = 0;
 177         }
 178         method_name = strrchr (class_nspace, ':');
 179         if (!method_name) {
 180                 g_free (class_nspace);
 181                 return NULL;
 182         }
 183         *method_name++ = 0;
 184         /* allow two :: to separate the method name */
 185         if (*method_name == ':')
 186                 method_name++;
 187         class_name = strrchr (class_nspace, '.');
 188         if (class_name) {
 189                 *class_name++ = 0;
 190                 use_namespace = 1;
 191         } else {
 192                 class_name = class_nspace;
 193                 use_namespace = 0;
 194         }
 195         result = g_new0 (MonoMethodDesc, 1);
 196         result->include_namespace = include_namespace;
 197         result->name = method_name;
 198         result->klass = class_name;
 199         result->namespace = use_namespace? class_nspace: NULL;
 200         result->args = use_args? use_args: NULL;
 201         if (use_args) {
 202                 end = use_args;
 203                 if (*end)
 204                         result->num_args = 1;
 205                 while (*end) {
 206                         if (*end == ',')
 207                                 result->num_args++;
 208                         ++end;
 209                 }
 210         }
 211
 212         return result;
 213 }
 214
 215 MonoMethodDesc*
 216 mono_method_desc_from_method (MonoMethod *method)
 217 {
 218         MonoMethodDesc *result;
 219
 220         result = g_new0 (MonoMethodDesc, 1);
 221         result->include_namespace = TRUE;
 222         result->name = g_strdup (method->name);
 223         result->klass = g_strdup (method->klass->name);
 224         result->namespace = g_strdup (method->klass->name_space);
 225
 226         return result;
 227 }
 228
 229 /**
 230  * mono_method_desc_free:
 231  *
 232  * Releases the MonoMethodDesc object `desc'.
 233  */
 234 void
 235 mono_method_desc_free (MonoMethodDesc *desc)
 236 {
 237         if (desc->namespace)
 238                 g_free (desc->namespace);
 239         else if (desc->klass)
 240                 g_free (desc->klass);
 241         g_free (desc);
 242 }
 243
 244 /*
 245  * namespace and class are supposed to match already if this function is used.
 246  */
 247 gboolean
 248 mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method)
 249 {
 250         char *sig;
 251         if (strcmp (desc->name, method->name))
 252                 return FALSE;
 253         if (!desc->args)
 254                 return TRUE;
 255         if (desc->num_args != method->signature->param_count)
 256                 return FALSE;
 257         sig = mono_signature_get_desc (method->signature, desc->include_namespace);
 258         if (strcmp (sig, desc->args)) {
 259                 g_free (sig);
 260                 return FALSE;
 261         }
 262         g_free (sig);
 263         return TRUE;
 264 }
 265
 266 gboolean
 267 mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method)
 268 {
 269         if (strcmp (desc->klass, method->klass->name))
 270                 return FALSE;
 271         if (desc->namespace && strcmp (desc->namespace, method->klass->name_space))
 272                 return FALSE;
 273         return mono_method_desc_match (desc, method);
 274 }
 275
 276 MonoMethod*
 277 mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass)
 278 {
 279         int i;
 280
 281         mono_class_init (klass);
 282         for (i = 0; i < klass->method.count; ++i) {
 283                 if (mono_method_desc_match (desc, klass->methods [i]))
 284                         return klass->methods [i];
 285         }
 286         return NULL;
 287 }
 288
 289 MonoMethod*
 290 mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image)
 291 {
 292         MonoClass *klass;
 293         MonoTableInfo *tdef;
 294         MonoTableInfo *methods;
 295         MonoMethod *method;
 296         int i;
 297
 298         if (desc->namespace && desc->klass) {
 299                 klass = mono_class_from_name (image, desc->namespace, desc->klass);
 300                 if (!klass)
 301                         return NULL;
 302                 return mono_method_desc_search_in_class (desc, klass);
 303         }
 304
 305         tdef = mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
 306         methods = mono_image_get_table_info (image, MONO_TABLE_METHOD);
 307         for (i = 0; i < mono_table_info_get_rows (methods); ++i) {
 308                 guint32 token = mono_metadata_decode_row_col (methods, i, MONO_METHOD_NAME);
 309                 const char *n = mono_metadata_string_heap (image, token);
 310
 311                 if (strcmp (n, desc->name))
 312                         continue;
 313                 method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
 314                 if (mono_method_desc_full_match (desc, method))
 315                         return method;
 316         }
 317         return NULL;
 318 }
 319
 320 static const unsigned char*
 321 dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned char *ip, const unsigned char *end)
 322 {
 323         MonoMethodHeader *header = ((MonoMethodNormal*)method)->header;
 324         const MonoOpcode *opcode;
 325         guint32 i, label, token;
 326         gint32 sval;
 327         char *tmp;
 328
 329         label = ip - header->code;
 330         if (dh->indenter) {
 331                 tmp = dh->indenter (dh, method, label);
 332                 g_string_append (str, tmp);
 333                 g_free (tmp);
 334         }
 335         if (dh->label_format)
 336                 g_string_sprintfa (str, dh->label_format, label);
 337
 338         i = mono_opcode_value (&ip, end);
 339         ip++;
 340         opcode = &mono_opcodes [i];
 341         g_string_sprintfa (str, "%-10s", mono_opcode_names [i]);
 342
 343         switch (opcode->argument) {
 344         case MonoInlineNone:
 345                 break;
 346         case MonoInlineType:
 347         case MonoInlineField:
 348         case MonoInlineMethod:
 349         case MonoInlineTok:
 350         case MonoInlineSig:
 351                 token = read32 (ip);
 352                 if (dh->tokener) {
 353                         tmp = dh->tokener (dh, method, token);
 354                         g_string_append (str, tmp);
 355                         g_free (tmp);
 356                 } else {
 357                         g_string_sprintfa (str, "0x%08x", token);
 358                 }
 359                 ip += 4;
 360                 break;
 361         case MonoInlineString:
 362                 /* TODO */
 363                 ip += 4;
 364                 break;
 365         case MonoInlineVar:
 366                 g_string_sprintfa (str, "%d", read16 (ip));
 367                 ip += 2;
 368                 break;
 369         case MonoShortInlineVar:
 370                 g_string_sprintfa (str, "%d", (*ip));
 371                 ip ++;
 372                 break;
 373         case MonoInlineBrTarget:
 374                 sval = read32 (ip);
 375                 ip += 4;
 376                 if (dh->label_target)
 377                         g_string_sprintfa (str, dh->label_target, ip + sval - header->code);
 378                 else
 379                         g_string_sprintfa (str, "%d", sval);
 380                 break;
 381         case MonoShortInlineBrTarget:
 382                 sval = *(const signed char*)ip;
 383                 ip ++;
 384                 if (dh->label_target)
 385                         g_string_sprintfa (str, dh->label_target, ip + sval - header->code);
 386                 else
 387                         g_string_sprintfa (str, "%d", sval);
 388                 break;
 389         case MonoInlineSwitch: {
 390                 const unsigned char *end;
 391                 sval = read32 (ip);
 392                 ip += 4;
 393                 end = ip + sval * 4;
 394                 g_string_append_c (str, '(');
 395                 for (i = 0; i < sval; ++i) {
 396                         if (i > 0)
 397                                 g_string_append (str, ", ");
 398                         label = read32 (ip);
 399                         if (dh->label_target)
 400                                 g_string_sprintfa (str, dh->label_target, end + label - header->code);
 401                         else
 402                                 g_string_sprintfa (str, "%d", label);
 403                         ip += 4;
 404                 }
 405                 g_string_append_c (str, ')');
 406                 break;
 407         }
 408         case MonoInlineR: {
 409                 double r;
 410                 readr8 (ip, &r);
 411                 g_string_sprintfa (str, "%g", r);
 412                 ip += 8;
 413                 break;
 414         }
 415         case MonoShortInlineR: {
 416                 float r;
 417                 readr4 (ip, &r);
 418                 g_string_sprintfa (str, "%g", r);
 419                 ip += 4;
 420                 break;
 421         }
 422         case MonoInlineI:
 423                 g_string_sprintfa (str, "%d", (gint32)read32 (ip));
 424                 ip += 4;
 425                 break;
 426         case MonoShortInlineI:
 427                 g_string_sprintfa (str, "%d", *(const signed char*)ip);
 428                 ip ++;
 429                 break;
 430         case MonoInlineI8:
 431                 ip += 8;
 432                 break;
 433         default:
 434                 g_assert_not_reached ();
 435         }
 436         if (dh->newline)
 437                 g_string_append (str, dh->newline);
 438
 439         return ip;
 440 }
 441
 442 static MonoDisHelper
 443 default_dh = {
 444         "\n",
 445         "IL_%04x: ", /* label_format */
 446         "IL_%04x", /* label_target */
 447         NULL, /* indenter */
 448         NULL, /* tokener */
 449         NULL  /* user data */
 450 };
 451
 452 char*
 453 mono_disasm_code_one (MonoDisHelper *dh, MonoMethod *method, const guchar *ip, const guchar **endp)
 454 {
 455         char *result;
 456         GString *res = g_string_new ("");
 457
 458         if (!dh)
 459                 dh = &default_dh;
 460         /* set ip + 2 as the end: this is just a debugging method */
 461         ip = dis_one (res, dh, method, ip, ip + 2);
 462         if (endp)
 463                 *endp = ip;
 464
 465         result = res->str;
 466         g_string_free (res, FALSE);
 467         return result;
 468 }
 469
 470 char*
 471 mono_disasm_code (MonoDisHelper *dh, MonoMethod *method, const guchar *ip, const guchar* end)
 472 {
 473         char *result;
 474         GString *res = g_string_new ("");
 475
 476         if (!dh)
 477                 dh = &default_dh;
 478         while (ip < end) {
 479                 ip = dis_one (res, dh, method, ip, end);
 480         }
 481
 482         result = res->str;
 483         g_string_free (res, FALSE);
 484         return result;
 485 }
 486
 487 static const char*
 488 wrapper_type_to_str (guint32 wrapper_type)
 489 {
 490         g_assert (wrapper_type < sizeof (wrapper_type_names) / sizeof (char*));
 491
 492         return wrapper_type_names [wrapper_type];
 493 }
 494
 495 char *
 496 mono_method_full_name (MonoMethod *method, gboolean signature)
 497 {
 498         char *res;
 499         char wrapper [64];
 500         char *nspace;
 501
 502         nspace = method->klass->name_space;
 503
 504         if (signature) {
 505                 char *tmpsig = mono_signature_get_desc (method->signature, TRUE);
 506
 507                 if (method->wrapper_type != MONO_WRAPPER_NONE)
 508                         sprintf (wrapper, "(wrapper %s) ", wrapper_type_to_str (method->wrapper_type));
 509                 else
 510                         strcpy (wrapper, "");
 511                 res = g_strdup_printf ("%s%s%s%s:%s (%s)", wrapper,
 512                                                            nspace, *nspace ? "." : "",
 513                                                            method->klass->name, method->name, tmpsig);
 514                 g_free (tmpsig);
 515         } else {
 516
 517                 res = g_strdup_printf ("%02d %s%s%s:%s", method->wrapper_type,
 518                                                            nspace, *nspace ? "." : "",
 519                                                            method->klass->name, method->name);
 520         }
 521
 522         return res;
 523 }
 524
 525