mono/dis/get.c

   1 /*
   2  * get.c: Functions to get stringified values from the metadata tables.
   3  *
   4  * Author:
   5  *   Miguel de Icaza (miguel@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9 #include <config.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <ctype.h>
  14 #include <glib.h>
  15 #include "meta.h"
  16 #include "util.h"
  17 #include "get.h"
  18 #include <mono/metadata/class.h>
  19
  20 extern gboolean substitute_with_mscorlib_p;
  21
  22 char *
  23 get_typedef (MonoImage *m, int idx)
  24 {
  25         guint32 cols [MONO_TYPEDEF_SIZE];
  26         const char *ns;
  27
  28         mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPEDEF], idx - 1, cols, MONO_TYPEDEF_SIZE);
  29
  30         ns = mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAMESPACE]);
  31         return g_strdup_printf (
  32                 "%s%s%s", ns, *ns?".":"",
  33                 mono_metadata_string_heap (m, cols [MONO_TYPEDEF_NAME]));
  34 }
  35
  36 char *
  37 get_module (MonoImage *m, int idx)
  38 {
  39         guint32 cols [MONO_MODULE_SIZE];
  40
  41         /*
  42          * There MUST BE only one module in the Module table
  43          */
  44         g_assert (idx == 1);
  45
  46         mono_metadata_decode_row (&m->tables [MONO_TABLE_MODULE], idx - 1, cols, MONO_MODULE_SIZE);
  47
  48         return g_strdup (mono_metadata_string_heap (m, cols [MONO_MODULE_NAME]));
  49 }
  50
  51 char *
  52 get_assemblyref (MonoImage *m, int idx)
  53 {
  54         guint32 cols [MONO_ASSEMBLYREF_SIZE];
  55
  56         mono_metadata_decode_row (&m->tables [MONO_TABLE_ASSEMBLYREF], idx - 1, cols, MONO_ASSEMBLYREF_SIZE);
  57
  58         return g_strdup (mono_metadata_string_heap (m, cols [MONO_ASSEMBLYREF_NAME]));
  59 }
  60
  61 /*
  62  *
  63  * Returns a string representing the ArrayShape (22.2.16).
  64  */
  65 static const char *
  66 get_array_shape (MonoImage *m, const char *ptr, char **result)
  67 {
  68         GString *res = g_string_new ("[");
  69         guint32 rank, num_sizes, num_lo_bounds;
  70         guint32 *sizes = NULL, *lo_bounds = NULL;
  71         int i, r;
  72         char buffer [80];
  73
  74         rank = mono_metadata_decode_value (ptr, &ptr);
  75         num_sizes = mono_metadata_decode_value (ptr, &ptr);
  76
  77         if (num_sizes > 0)
  78                 sizes = g_new (guint32, num_sizes);
  79
  80         for (i = 0; i < num_sizes; i++)
  81                 sizes [i] = mono_metadata_decode_value (ptr, &ptr);
  82
  83         num_lo_bounds = mono_metadata_decode_value (ptr, &ptr);
  84         if (num_lo_bounds > 0)
  85                 lo_bounds = g_new (guint32, num_lo_bounds);
  86
  87         for (i = 0; i < num_lo_bounds; i++)
  88                 lo_bounds [i] = mono_metadata_decode_value (ptr, &ptr);
  89
  90         for (r = 0; r < rank; r++){
  91                 if (r < num_sizes){
  92                         if (r < num_lo_bounds){
  93                                 sprintf (buffer, "%d..%d", lo_bounds [r], lo_bounds [r] + sizes [r] - 1);
  94                         } else {
  95                                 sprintf (buffer, "0..%d", sizes [r] - 1);
  96                         }
  97                 } else
  98                         buffer [0] = 0;
  99
 100                 g_string_append (res, buffer);
 101                 if ((r + 1) != rank)
 102                         g_string_append (res, ", ");
 103         }
 104         g_string_append (res, "]");
 105
 106         if (sizes)
 107                 g_free (sizes);
 108
 109         if (lo_bounds)
 110                 g_free (lo_bounds);
 111
 112         *result = res->str;
 113         g_string_free (res, FALSE);
 114
 115         return ptr;
 116 }
 117
 118 /**
 119  * get_typespec:
 120  * @m: metadata context
 121  * @blob_idx: index into the blob heap
 122  *
 123  * Returns the stringified representation of a TypeSpec signature (22.2.17)
 124  */
 125 char *
 126 get_typespec (MonoImage *m, guint32 idx)
 127 {
 128         guint32 cols [MONO_TYPESPEC_SIZE];
 129         const char *ptr;
 130         char *s, *result;
 131         GString *res = g_string_new ("");
 132         int len;
 133
 134         mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPESPEC], idx-1, cols, MONO_TYPESPEC_SIZE);
 135         ptr = mono_metadata_blob_heap (m, cols [MONO_TYPESPEC_SIGNATURE]);
 136         len = mono_metadata_decode_value (ptr, &ptr);
 137
 138         switch (*ptr++){
 139         case MONO_TYPE_PTR:
 140                 ptr = get_custom_mod (m, ptr, &s);
 141                 if (s){
 142                         g_string_append (res, s);
 143                         g_string_append_c (res, ' ');
 144                         g_free (s);
 145                 }
 146
 147                 if (*ptr == MONO_TYPE_VOID)
 148                         g_string_append (res, "void");
 149                 else {
 150                         ptr = get_type (m, ptr, &s);
 151                         if (s)
 152                                 g_string_append (res, s);
 153                 }
 154                 break;
 155
 156         case MONO_TYPE_FNPTR:
 157                 g_string_append (res, "FNPTR ");
 158                 /*
 159                  * we assume MethodRefSig, as we do not know
 160                  * whether it is a MethodDefSig or a MethodRefSig.
 161                  */
 162                 printf ("\n FNPTR:\n");
 163
 164                 hex_dump (ptr, 0, 40);
 165                 break;
 166
 167         case MONO_TYPE_ARRAY:
 168                 ptr = get_type (m, ptr, &s);
 169                 g_string_append (res, s);
 170                 g_free (s);
 171                 g_string_append_c (res, ' ');
 172                 ptr = get_array_shape (m, ptr, &s);
 173                 g_string_append (res, s);
 174                 g_free (s);
 175                 break;
 176
 177         case MONO_TYPE_SZARRAY:
 178                 ptr = get_custom_mod (m, ptr, &s);
 179                 if (s){
 180                         g_string_append (res, s);
 181                         g_string_append_c (res, ' ');
 182                         g_free (s);
 183                 }
 184                 ptr = get_type (m, ptr, &s);
 185                 g_string_append (res, s);
 186                 g_string_append (res, "[]");
 187                 g_free (s);
 188         }
 189
 190         result = res->str;
 191         g_string_free (res, FALSE);
 192
 193         return result;
 194 }
 195
 196 char *
 197 get_typeref (MonoImage *m, int idx)
 198 {
 199         guint32 cols [MONO_TYPEREF_SIZE];
 200         const char *s, *t;
 201         char *x, *ret;
 202         guint32 rs_idx, table;
 203
 204         mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPEREF], idx - 1, cols, MONO_TYPEREF_SIZE);
 205
 206         t = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAME]);
 207         s = mono_metadata_string_heap (m, cols [MONO_TYPEREF_NAMESPACE]);
 208
 209         rs_idx = cols [MONO_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
 210         table = cols [MONO_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK;
 211
 212         switch (table){
 213         case RESOLTION_SCOPE_MODULE: /* Module */
 214                 x = get_module (m, rs_idx);
 215                 ret = g_strdup_printf ("[%s] %s%s%s", x, s, *s?".":"", t);
 216                 g_free (x);
 217                 break;
 218
 219         case RESOLTION_SCOPE_MODULEREF: /* ModuleRef */
 220                 ret = g_strdup_printf ("TODO:TypeRef-ModuleRef (%s.%s)", s, t);
 221                 break;
 222
 223         case RESOLTION_SCOPE_ASSEMBLYREF: /*
 224                  * AssemblyRef (ECMA docs claim it is 3, but it looks to
 225                  * me like it is 2 (tokens are prefixed with 0x23)
 226                  */
 227                 x = get_assemblyref (m, rs_idx);
 228                 ret = g_strdup_printf ("[%s]%s%s%s", x, s, *s?".":"", t);
 229                 g_free (x);
 230                 break;
 231
 232         case RESOLTION_SCOPE_TYPEREF: /* TypeRef */
 233                 x = get_typeref (m, rs_idx);
 234                 ret =  g_strdup_printf ("%s/%s", x, t);
 235                 g_free (x);
 236                 break;
 237
 238         default:
 239                 ret = g_strdup_printf ("Unknown table in TypeRef %d", table);
 240         }
 241
 242         return ret;
 243 }
 244
 245 /**
 246  * get_typedef_or_ref:
 247  * @m: metadata context
 248  * @dor_token: def or ref encoded index
 249  *
 250  * Low two bits contain table to lookup from
 251  * high bits contain the index into the def or ref table
 252  *
 253  * Returns: a stringified version of the MethodDef or MethodRef
 254  * at (dor_token >> 2)
 255  */
 256 char *
 257 get_typedef_or_ref (MonoImage *m, guint32 dor_token)
 258 {
 259         char *temp = NULL, *s;
 260         int table, idx;
 261
 262         /*
 263          * low 2 bits contain encoding
 264          */
 265         table = dor_token & 0x03;
 266         idx = dor_token >> 2;
 267
 268         switch (table){
 269         case 0: /* TypeDef */
 270                 temp = get_typedef (m, idx);
 271                 s = g_strdup_printf ("%s", temp);
 272                 break;
 273
 274         case 1: /* TypeRef */
 275                 temp = get_typeref (m, idx);
 276                 s = g_strdup_printf ("%s", temp);
 277                 break;
 278
 279         case 2: /* TypeSpec */
 280                 s = get_typespec (m, idx);
 281                 break;
 282
 283         default:
 284                 g_error ("Unhandled encoding for typedef-or-ref coded index");
 285
 286         }
 287
 288         if (temp)
 289                 g_free (temp);
 290
 291         return s;
 292 }
 293
 294 /**
 295  * get_encoded_typedef_or_ref:
 296  * @m: metadata context
 297  * @ptr: location to decode from.
 298  * @result: pointer to string where resulting decoded string is stored
 299  *
 300  * result will point to a g_malloc()ed string.
 301  *
 302  * Returns: the new ptr to continue decoding
 303  */
 304 const char *
 305 get_encoded_typedef_or_ref (MonoImage *m, const char *ptr, char **result)
 306 {
 307         guint32 token;
 308
 309         token = mono_metadata_decode_value (ptr, &ptr);
 310
 311         *result = get_typedef_or_ref (m, token);
 312
 313         return ptr;
 314 }
 315
 316 /**
 317  * get_custom_mod:
 318  *
 319  * Decodes a CustomMod (22.2.7)
 320  *
 321  * Returns: updated pointer location
 322  */
 323 const char *
 324 get_custom_mod (MonoImage *m, const char *ptr, char **return_value)
 325 {
 326         char *s;
 327
 328         if ((*ptr == MONO_TYPE_CMOD_OPT) ||
 329             (*ptr == MONO_TYPE_CMOD_REQD)){
 330                 ptr++;
 331                 ptr = get_encoded_typedef_or_ref (m, ptr, &s);
 332
 333                 *return_value = g_strconcat ("CMOD ", s, NULL);
 334                 g_free (s);
 335         } else
 336                 *return_value = NULL;
 337         return ptr;
 338 }
 339
 340
 341 static map_t element_type_map [] = {
 342         { MONO_TYPE_END        , "end" },
 343         { MONO_TYPE_VOID       , "void" },
 344         { MONO_TYPE_BOOLEAN    , "bool" },
 345         { MONO_TYPE_CHAR       , "char" },
 346         { MONO_TYPE_I1         , "int8" },
 347         { MONO_TYPE_U1         , "unsigned int8" },
 348         { MONO_TYPE_I2         , "int16" },
 349         { MONO_TYPE_U2         , "uint16" },
 350         { MONO_TYPE_I4         , "int32" },
 351         { MONO_TYPE_U4         , "uint32" },
 352         { MONO_TYPE_I8         , "int64" },
 353         { MONO_TYPE_U8         , "uint64" },
 354         { MONO_TYPE_R4         , "float32" },
 355         { MONO_TYPE_R8         , "float64" },
 356         { MONO_TYPE_STRING     , "string" },
 357         { MONO_TYPE_TYPEDBYREF , "TypedByRef" },
 358         { MONO_TYPE_I          , "native int" },
 359         { MONO_TYPE_U          , "native unsigned int" },
 360         { MONO_TYPE_OBJECT     , "object" },
 361         { 0, NULL }
 362 };
 363
 364 static map_t call_conv_type_map [] = {
 365         { MONO_CALL_DEFAULT     , "default" },
 366         { MONO_CALL_C           , "c" },
 367         { MONO_CALL_STDCALL     , "stdcall" },
 368         { MONO_CALL_THISCALL    , "thiscall" },
 369         { MONO_CALL_FASTCALL    , "fastcall" },
 370         { MONO_CALL_VARARG      , "vararg" },
 371         { 0, NULL }
 372 };
 373
 374 char*
 375 dis_stringify_token (MonoImage *m, guint32 token)
 376 {
 377         guint idx = token & 0xffffff;
 378         switch (token >> 24) {
 379         case MONO_TABLE_TYPEDEF: return get_typedef (m, idx);
 380         case MONO_TABLE_TYPEREF: return get_typeref (m, idx);
 381         case MONO_TABLE_TYPESPEC: return get_typespec (m, idx);
 382         default:
 383                  break;
 384         }
 385         return g_strdup_printf("0x%08x", token);
 386 }
 387
 388 char*
 389 dis_stringify_array (MonoImage *m, MonoArrayType *array)
 390 {
 391         char *type;
 392         GString *s = g_string_new("");
 393         int i;
 394
 395         type = dis_stringify_type (m, array->type);
 396         g_string_append (s, type);
 397         g_free (type);
 398         g_string_append_c (s, '[');
 399         for (i = 0; i < array->rank; ++i) {
 400                 if (i)
 401                         g_string_append_c (s, ',');
 402                 if (i < array->numsizes) {
 403                         if (i < array->numlobounds && array->lobounds[i] != 0)
 404                                 g_string_sprintfa (s, "%d..%d", array->lobounds[i], array->sizes[i]);
 405                         else
 406                                 g_string_sprintfa (s, "%d", array->sizes[i]);
 407                 }
 408         }
 409         g_string_append_c (s, ']');
 410         type = s->str;
 411         g_string_free (s, FALSE);
 412         return type;
 413 }
 414
 415 char*
 416 dis_stringify_modifiers (MonoImage *m, int n, MonoCustomMod *mod)
 417 {
 418         GString *s = g_string_new("");
 419         char *result;
 420         int i;
 421         for (i = 0; i < n; ++i) {
 422                 char *tok = dis_stringify_token (m, mod[i].token);
 423                 g_string_sprintfa (s, "%s %s", mod[i].required ? "opt": "reqd", tok);
 424                 g_free (tok);
 425         }
 426         g_string_append_c (s, ' ');
 427         result = s->str;
 428         g_string_free (s, FALSE);
 429         return result;
 430 }
 431
 432 char*
 433 dis_stringify_param (MonoImage *m, MonoType *param)
 434 {
 435         char *t;
 436         char *result;
 437         const char *out = param->attrs & 2 ? "[out] ": "";
 438         t = dis_stringify_type (m, param);
 439         result = g_strconcat (out, t, NULL);
 440         g_free (t);
 441         return result;
 442 }
 443
 444 char*
 445 dis_stringify_method_signature (MonoImage *m, MonoMethodSignature *method, int methoddef_row)
 446 {
 447         guint32 cols [MONO_METHOD_SIZE];
 448         guint32 pcols [MONO_PARAM_SIZE];
 449         guint32 param_index = 0;
 450         const char *name = "";
 451         int free_method = 0;
 452         char *retval;
 453         GString *result = g_string_new ("");
 454         int i;
 455
 456         g_assert (method || methoddef_row);
 457
 458         if (methoddef_row) {
 459                 mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD], methoddef_row -1, cols, MONO_METHOD_SIZE);
 460                 name = mono_metadata_string_heap (m, cols [MONO_METHOD_NAME]);
 461                 param_index = cols [MONO_METHOD_PARAMLIST];
 462                 if (!method) {
 463                         const char *sig = mono_metadata_blob_heap (m, cols [MONO_METHOD_SIGNATURE]);
 464                         mono_metadata_decode_blob_size (sig, &sig);
 465                         method = mono_metadata_parse_method_signature (m, 1, sig, &sig);
 466                         free_method = 1;
 467                 }
 468         }
 469
 470         retval = dis_stringify_param (m, method->ret);
 471         if (method->hasthis)
 472                 g_string_append (result, "instance ");
 473         g_string_append (result, map (method->call_convention, call_conv_type_map));
 474         g_string_sprintfa (result, " %s %s(", retval, name);
 475         g_free (retval);
 476         for (i = 0; i < method->param_count; ++i) {
 477                 if (param_index && param_index <= m->tables [MONO_TABLE_PARAM].rows) {
 478                         mono_metadata_decode_row (&m->tables [MONO_TABLE_PARAM], param_index - 1, pcols, MONO_PARAM_SIZE);
 479                         name = mono_metadata_string_heap (m, pcols [MONO_PARAM_NAME]);
 480                         method->params [i]->attrs = pcols [MONO_PARAM_FLAGS];
 481                         param_index++;
 482                 } else {
 483                         name = "";
 484                 }
 485                 if (i)
 486                         g_string_append (result, ", ");
 487                 retval = dis_stringify_param (m, method->params [i]);
 488                 g_string_sprintfa (result, "%s %s", retval, name);
 489                 g_free (retval);
 490         }
 491         g_string_append (result, ") ");
 492
 493         if (free_method)
 494                 mono_metadata_free_method_signature (method);
 495         retval = result->str;
 496         g_string_free (result, FALSE);
 497
 498         return retval;
 499 }
 500
 501 static char *
 502 dis_stringify_object (MonoImage *m, MonoType *type)
 503 {
 504         const char *otype = type->type == MONO_TYPE_CLASS? "class" : "valuetype";
 505         char *assemblyref = NULL, *result;
 506         MonoClass *c = type->data.klass;
 507         if (!c)
 508                 return g_strdup ("Unknown");
 509         if (m != c->image) {
 510                 /* we cheat */
 511                 if (substitute_with_mscorlib_p && !strcmp ("corlib", c->image->assembly_name))
 512                         assemblyref = g_strdup_printf ("[%s]", "mscorlib");
 513                 else
 514                         assemblyref = g_strdup_printf ("[%s]", c->image->assembly_name);
 515         }
 516         result = g_strdup_printf ("%s %s%s%s%s", otype, assemblyref?assemblyref:"", c->name_space,
 517                                 *c->name_space?".":"", c->name);
 518         g_free (assemblyref);
 519         return result;
 520 }
 521
 522 char*
 523 dis_stringify_type (MonoImage *m, MonoType *type)
 524 {
 525         const char *pinned = "", *byref = "";
 526         char *bare = NULL, *mods = NULL;
 527         char *result;
 528
 529         if (type->num_mods)
 530                 mods = dis_stringify_modifiers (m, type->num_mods, type->modifiers);
 531
 532         switch (type->type){
 533         case MONO_TYPE_BOOLEAN:
 534         case MONO_TYPE_CHAR:
 535         case MONO_TYPE_I1:
 536         case MONO_TYPE_U1:
 537         case MONO_TYPE_I2:
 538         case MONO_TYPE_U2:
 539         case MONO_TYPE_I4:
 540         case MONO_TYPE_U4:
 541         case MONO_TYPE_I8:
 542         case MONO_TYPE_U8:
 543         case MONO_TYPE_R4:
 544         case MONO_TYPE_R8:
 545         case MONO_TYPE_I:
 546         case MONO_TYPE_U:
 547         case MONO_TYPE_STRING:
 548         case MONO_TYPE_OBJECT:
 549         case MONO_TYPE_TYPEDBYREF:
 550                 bare = g_strdup (map (type->type, element_type_map));
 551                 break;
 552
 553         case MONO_TYPE_VALUETYPE:
 554         case MONO_TYPE_CLASS:
 555                 bare = dis_stringify_object (m, type);
 556                 break;
 557
 558         case MONO_TYPE_FNPTR:
 559                 bare = dis_stringify_method_signature (m, type->data.method, 0);
 560                 break;
 561         case MONO_TYPE_PTR:
 562         case MONO_TYPE_SZARRAY: {
 563                 char *child_type;
 564                 child_type = dis_stringify_type (m, type->data.type);
 565
 566                 bare = g_strdup_printf (type->type == MONO_TYPE_PTR ? "%s*" : "%s[]", child_type);
 567                 g_free (child_type);
 568                 break;
 569         }
 570         case MONO_TYPE_ARRAY:
 571                 bare = dis_stringify_array (m, type->data.array);
 572                 break;
 573         case MONO_TYPE_VOID:
 574                 bare = g_strdup ("void");
 575                 break;
 576         default:
 577                 g_error ("Do not know how to stringify type 0x%x", type->type);
 578         }
 579
 580         if (type->pinned)
 581                 pinned = " pinned";
 582
 583         if (type->byref)
 584                 byref = "&";
 585
 586         result = g_strconcat (mods ? mods : "", bare, byref, pinned, NULL);
 587
 588         g_free (bare);
 589
 590         return result;
 591 }
 592
 593 /**
 594  * get_type:
 595  * @m: metadata context
 596  * @ptr: location to decode from.
 597  * @result: pointer to string where resulting decoded string is stored
 598  *
 599  * This routine returs in @result the stringified type pointed by @ptr.
 600  * (22.2.12)
 601  *
 602  * Returns: the new ptr to continue decoding
 603  */
 604 const char *
 605 get_type (MonoImage *m, const char *ptr, char **result)
 606 {
 607         MonoType *type = mono_metadata_parse_type (m, MONO_PARSE_TYPE, 0, ptr, &ptr);
 608         *result = dis_stringify_type (m, type);
 609         mono_metadata_free_type (type);
 610         return ptr;
 611 }
 612
 613 /**
 614  *
 615  * Returns a stringified representation of a FieldSig (22.2.4)
 616  */
 617 char *
 618 get_field_signature (MonoImage *m, guint32 blob_signature)
 619 {
 620         char *allocated_modifier_string, *allocated_type_string;
 621         const char *ptr = mono_metadata_blob_heap (m, blob_signature);
 622         const char *base;
 623         char *res;
 624         int len;
 625
 626         len = mono_metadata_decode_value (ptr, &ptr);
 627         base = ptr;
 628         /* FIELD is 0x06 */
 629         g_assert (*ptr == 0x06);
 630 /*      hex_dump (ptr, 0, len); */
 631         ptr++; len--;
 632
 633         ptr = get_custom_mod (m, ptr, &allocated_modifier_string);
 634         ptr = get_type (m, ptr, &allocated_type_string);
 635
 636         res = g_strdup_printf (
 637                 "%s %s",
 638                 allocated_modifier_string ? allocated_modifier_string : "",
 639                 allocated_type_string);
 640
 641         if (allocated_modifier_string)
 642                 g_free (allocated_modifier_string);
 643         if (allocated_type_string)
 644                 g_free (allocated_modifier_string);
 645
 646         return res;
 647 }
 648
 649 MonoTypeEnum
 650 get_field_literal_type (MonoImage *m, guint32 blob_signature)
 651 {
 652         const char *ptr = mono_metadata_blob_heap (m, blob_signature);
 653         int len;
 654         char *allocated_modifier_string;
 655
 656         len = mono_metadata_decode_value (ptr, &ptr);
 657
 658         /* FIELD is 0x06 */
 659         g_assert (*ptr == 0x06);
 660         ptr++; len--;
 661
 662         ptr = get_custom_mod (m, ptr, &allocated_modifier_string);
 663         if (allocated_modifier_string)
 664                 g_free (allocated_modifier_string);
 665
 666         return (MonoTypeEnum) *ptr;
 667
 668 }
 669
 670 /**
 671  * decode_literal:
 672  * @m: metadata context
 673  * @token: token to decode
 674  *
 675  * decodes the literal indexed by @token.
 676  */
 677 char *
 678 decode_literal (MonoImage *m, guint32 token)
 679 {
 680         return g_strdup ("LITERAL_VALUE");
 681 }
 682
 683 /**
 684  * get_ret_type:
 685  * @m: metadata context
 686  * @ptr: location to decode from.
 687  * @result: pointer to string where resulting decoded string is stored
 688  *
 689  * This routine returns in @result the stringified RetType (22.2.11)
 690  *
 691  * Returns: the new ptr to continue decoding.
 692  */
 693 const char *
 694 get_ret_type (MonoImage *m, const char *ptr, char **ret_type)
 695 {
 696         GString *str = g_string_new ("");
 697         char *mod = NULL;
 698         char *allocated_type_string;
 699
 700         ptr = get_custom_mod (m, ptr, &mod);
 701         if (mod){
 702                 g_string_append (str, mod);
 703                 g_string_append_c (str, ' ');
 704                 g_free (mod);
 705         }
 706
 707         if (*ptr == MONO_TYPE_TYPEDBYREF){
 708                 /* TODO: what does `typedbyref' mean? */
 709                 g_string_append (str, "/* FIXME: What does this mean? */ typedbyref ");
 710                 ptr++;
 711         } else if (*ptr == MONO_TYPE_VOID){
 712                  g_string_append (str, "void");
 713                  ptr++;
 714         } else {
 715                 if (*ptr == MONO_TYPE_BYREF){
 716                         g_string_append (str, "[out] ");
 717                         ptr++;
 718                 }
 719
 720                 ptr = get_type (m, ptr, &allocated_type_string);
 721                 g_string_append (str, allocated_type_string);
 722                 g_free (allocated_type_string);
 723         }
 724
 725         *ret_type = str->str;
 726         g_string_free (str, FALSE);
 727
 728         return ptr;
 729 }
 730
 731 /**
 732  * get_param:
 733  * @m: metadata context
 734  * @ptr: location to decode from.
 735  * @result: pointer to string where resulting decoded string is stored
 736  *
 737  * This routine returns in @result the stringified Param (22.2.10)
 738  *
 739  * Returns: the new ptr to continue decoding.
 740  */
 741 const char *
 742 get_param (MonoImage *m, const char *ptr, char **retval)
 743 {
 744         GString *str = g_string_new ("");
 745         char *allocated_mod_string, *allocated_type_string;
 746
 747         ptr = get_custom_mod (m, ptr, &allocated_mod_string);
 748         if (allocated_mod_string){
 749                 g_string_append (str, allocated_mod_string);
 750                 g_string_append_c (str, ' ');
 751                 g_free (allocated_mod_string);
 752         }
 753
 754         if (*ptr == MONO_TYPE_TYPEDBYREF){
 755                 g_string_append (str, "/*FIXME: what does typedbyref mean? */ typedbyref ");
 756                 ptr++;
 757         } else {
 758                 if (*ptr == MONO_TYPE_BYREF){
 759                         g_string_append (str, "[out] ");
 760                         ptr++;
 761                 }
 762                 ptr = get_type (m, ptr, &allocated_type_string);
 763                 g_string_append (str, allocated_type_string);
 764                 g_free (allocated_type_string);
 765         }
 766
 767         *retval = str->str;
 768         g_string_free (str, FALSE);
 769         return ptr;
 770 }
 771
 772 static map_t param_map [] = {
 773         { PARAM_ATTRIBUTE_IN,                "[in] " },
 774         { PARAM_ATTRIBUTE_OUT,               "[out] " },
 775         { PARAM_ATTRIBUTE_OPTIONAL,          "optional " },
 776         { PARAM_ATTRIBUTE_HAS_DEFAULT,       "hasdefault " },
 777         { PARAM_ATTRIBUTE_HAS_FIELD_MARSHAL, "fieldmarshal " },
 778         { 0, NULL }
 779 };
 780
 781 char *
 782 param_flags (guint32 f)
 783 {
 784         return g_strdup (flags (f, param_map));
 785 }
 786
 787 static map_t field_access_map [] = {
 788         { FIELD_ATTRIBUTE_COMPILER_CONTROLLED, "compilercontrolled " },
 789         { FIELD_ATTRIBUTE_PRIVATE,             "private " },
 790         { FIELD_ATTRIBUTE_FAM_AND_ASSEM,       "famandassem " },
 791         { FIELD_ATTRIBUTE_ASSEMBLY,            "assembly " },
 792         { FIELD_ATTRIBUTE_FAMILY,              "family " },
 793         { FIELD_ATTRIBUTE_FAM_OR_ASSEM,        "famorassem " },
 794         { FIELD_ATTRIBUTE_PUBLIC,              "public " },
 795         { 0, NULL }
 796 };
 797
 798 static map_t field_flags_map [] = {
 799         { FIELD_ATTRIBUTE_STATIC,              "static " },
 800         { FIELD_ATTRIBUTE_INIT_ONLY,           "initonly " },
 801         { FIELD_ATTRIBUTE_LITERAL,             "literal " },
 802         { FIELD_ATTRIBUTE_NOT_SERIALIZED,      "notserialized " },
 803         { FIELD_ATTRIBUTE_SPECIAL_NAME,        "specialname " },
 804         { FIELD_ATTRIBUTE_PINVOKE_IMPL,        "FIXME:pinvokeimpl " },
 805         { FIELD_ATTRIBUTE_RT_SPECIAL_NAME,        "rtspecialname " },
 806         { FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL,        "hasfieldmarshal " },
 807         { FIELD_ATTRIBUTE_HAS_DEFAULT,        "hasdefault " },
 808         { FIELD_ATTRIBUTE_HAS_FIELD_RVA,        "hasfieldrva " },
 809         { 0, NULL }
 810 };
 811
 812 /**
 813  * field_flags:
 814  *
 815  * Returns a stringified version of a Field's flags
 816  */
 817 char *
 818 field_flags (guint32 f)
 819 {
 820         char buffer [1024];
 821         int access = f & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK;
 822
 823         buffer [0] = 0;
 824
 825         strcat (buffer, map (access, field_access_map));
 826         strcat (buffer, flags (f, field_flags_map));
 827         return g_strdup (buffer);
 828 }
 829
 830 /**
 831  * Returns a stringifed representation of a MethodRefSig (22.2.2)
 832  */
 833 char *
 834 get_methodref_signature (MonoImage *m, guint32 blob_signature, const char *fancy_name)
 835 {
 836         GString *res = g_string_new ("");
 837         const char *ptr = mono_metadata_blob_heap (m, blob_signature);
 838         char *allocated_ret_type, *s;
 839         gboolean seen_vararg = 0;
 840         int param_count, signature_len;
 841         int i;
 842
 843         signature_len = mono_metadata_decode_value (ptr, &ptr);
 844
 845         if (*ptr & 0x20){
 846                 if (*ptr & 0x40)
 847                         g_string_append (res, "explicit-this ");
 848                 else
 849                         g_string_append (res, "instance "); /* has-this */
 850         }
 851
 852         if (*ptr & 0x05)
 853                 seen_vararg = 1;
 854
 855         ptr++;
 856         param_count = mono_metadata_decode_value (ptr, &ptr);
 857         ptr = get_ret_type (m, ptr, &allocated_ret_type);
 858
 859         g_string_append (res, allocated_ret_type);
 860
 861         if (fancy_name){
 862                 g_string_append_c (res, ' ');
 863                 g_string_append (res, fancy_name);
 864         }
 865
 866         g_string_append (res, "(");
 867
 868         /*
 869          * param_count describes parameters *before* and *after*
 870          * the vararg sentinel
 871          */
 872         for (i = 0; i < param_count; i++){
 873                 char *param = NULL;
 874
 875                 /*
 876                  * If ptr is a SENTINEL
 877                  */
 878                 if (*ptr == 0x41){
 879                         g_string_append (res, " varargs ");
 880                         continue;
 881                 }
 882
 883                 ptr = get_param (m, ptr, &param);
 884                 g_string_append (res, param);
 885                 if (i+1 != param_count)
 886                         g_string_append (res, ", ");
 887                 g_free (param);
 888         }
 889         g_string_append (res, ")");
 890
 891         /*
 892          * cleanup and return
 893          */
 894         g_free (allocated_ret_type);
 895         s = res->str;
 896         g_string_free (res, FALSE);
 897         return s;
 898 }
 899
 900 /**
 901  * get_field:
 902  * @m: metadata context
 903  * @token: a FIELD_DEF token
 904  *
 905  * This routine has to locate the TypeDef that "owns" this Field.
 906  * Since there is no backpointer in the Field table, we have to scan
 907  * the TypeDef table and locate the actual "owner" of the field
 908  */
 909 char *
 910 get_field (MonoImage *m, guint32 token)
 911 {
 912         int idx = mono_metadata_token_index (token);
 913         guint32 cols [MONO_FIELD_SIZE];
 914         char *sig, *res, *type;
 915         guint32 type_idx;
 916
 917         /*
 918          * We can get here also with a MenberRef token (for a field
 919          * defined in another module/assembly, just like in get_method ()
 920          */
 921         if (mono_metadata_token_code (token) == MONO_TOKEN_MEMBER_REF) {
 922                 return g_strdup_printf ("fieldref-0x%08x", token);
 923         }
 924         g_assert (mono_metadata_token_code (token) == MONO_TOKEN_FIELD_DEF);
 925
 926         mono_metadata_decode_row (&m->tables [MONO_TABLE_FIELD], idx - 1, cols, MONO_FIELD_SIZE);
 927         sig = get_field_signature (m, cols [MONO_FIELD_SIGNATURE]);
 928
 929         /*
 930          * To locate the actual "container" for this field, we have to scan
 931          * the TypeDef table.  LAME!
 932          */
 933         type_idx = mono_metadata_typedef_from_field (m, idx);
 934
 935         type = get_typedef (m, type_idx);
 936         res = g_strdup_printf ("%s %s::%s",
 937                                sig, type,
 938                                mono_metadata_string_heap (m, cols [MONO_FIELD_NAME]));
 939         g_free (type);
 940         g_free (sig);
 941
 942         return res;
 943 }
 944
 945 static char *
 946 get_memberref_parent (MonoImage *m, guint32 mrp_token)
 947 {
 948         /*
 949          * mrp_index is a MemberRefParent coded index
 950          */
 951         guint32 table = mrp_token & 7;
 952         guint32 idx = mrp_token >> 3;
 953
 954         switch (table){
 955         case 0: /* TypeDef */
 956                 return get_typedef (m, idx);
 957
 958         case 1: /* TypeRef */
 959                 return get_typeref (m, idx);
 960
 961         case 2: /* ModuleRef */
 962                 return g_strdup_printf ("TODO:MemberRefParent-ModuleRef");
 963
 964         case 3: /* MethodDef */
 965                 return g_strdup ("TODO:MethodDef");
 966
 967         case 4: /* TypeSpec */
 968                 return get_typespec (m, idx);
 969         }
 970         g_assert_not_reached ();
 971         return NULL;
 972 }
 973
 974 /**
 975  * get_method:
 976  * @m: metadata context
 977  * @token: a METHOD_DEF or MEMBER_REF token
 978  *
 979  * This routine has to locate the TypeDef that "owns" this Field.
 980  * Since there is no backpointer in the Field table, we have to scan
 981  * the TypeDef table and locate the actual "owner" of the field
 982  */
 983 char *
 984 get_method (MonoImage *m, guint32 token)
 985 {
 986         int idx = mono_metadata_token_index (token);
 987         guint32 member_cols [MONO_MEMBERREF_SIZE], method_cols [MONO_METHOD_SIZE];
 988         char *sig;
 989         const char *name;
 990
 991         MonoMethod *mh;
 992
 993         mh = mono_get_method (m, token, NULL);
 994         if (mh)
 995                 name = g_strdup_printf ("%s%s%s::%s", mh->klass->name_space, *(mh->klass->name_space)?".":"",
 996                                 mh->klass->name, mh->name);
 997         else
 998                 name = NULL;
 999
1000         switch (mono_metadata_token_code (token)){
1001         case MONO_TOKEN_METHOD_DEF:
1002                 mono_metadata_decode_row (&m->tables [MONO_TABLE_METHOD],
1003                                           idx - 1, method_cols, MONO_METHOD_SIZE);
1004
1005                 sig = get_methodref_signature (m, method_cols [MONO_METHOD_SIGNATURE], name);
1006                 return sig;
1007
1008         case MONO_TOKEN_MEMBER_REF: {
1009
1010                 mono_metadata_decode_row (&m->tables [MONO_TABLE_MEMBERREF],
1011                                           idx - 1, member_cols, MONO_MEMBERREF_SIZE);
1012                 if (!name)
1013                         name = g_strdup_printf ("%s::%s",
1014                                         get_memberref_parent (m, member_cols [MONO_MEMBERREF_CLASS]),
1015                                         mono_metadata_string_heap (m, member_cols [MONO_MEMBERREF_NAME]));
1016                 sig = get_methodref_signature (
1017                         m, member_cols [MONO_MEMBERREF_SIGNATURE], name);
1018                 return sig;
1019         }
1020
1021         default:
1022                 g_assert_not_reached ();
1023         }
1024         g_assert_not_reached ();
1025         return NULL;
1026 }
1027
1028 /**
1029  * get_constant:
1030  * @m: metadata context
1031  * @blob_index: index into the blob where the constant is stored
1032  *
1033  * Returns: An allocated value representing a stringified version of the
1034  * constant.
1035  */
1036 char *
1037 get_constant (MonoImage *m, MonoTypeEnum t, guint32 blob_index)
1038 {
1039         const char *ptr = mono_metadata_blob_heap (m, blob_index);
1040         int len;
1041
1042         len = mono_metadata_decode_value (ptr, &ptr);
1043
1044         switch (t){
1045         case MONO_TYPE_BOOLEAN:
1046                 return g_strdup_printf ("%s", *ptr ? "true" : "false");
1047
1048         case MONO_TYPE_CHAR:
1049                 return g_strdup_printf ("%c", *ptr); /* FIXME: unicode char */
1050
1051         case MONO_TYPE_U1:
1052         case MONO_TYPE_I1:
1053                 return g_strdup_printf ("int8(0x%02x)", (int) (*ptr));
1054                 break;
1055
1056         case MONO_TYPE_U2:
1057         case MONO_TYPE_I2:
1058                 return g_strdup_printf ("int16(0x%08x)", (int) read16 (ptr));
1059
1060         case MONO_TYPE_U4:
1061         case MONO_TYPE_I4:
1062                 return g_strdup_printf ("int32(%d)", read32 (ptr));
1063
1064         case MONO_TYPE_I8: {
1065                 guint32 low, high;
1066                 low = read32 (ptr);
1067                 high = read32 (ptr + 4);
1068                 return g_strdup_printf ("0x%08x%08x", high, low);
1069         }
1070         case MONO_TYPE_U8: {
1071                 guint32 low, high;
1072                 low = read32 (ptr);
1073                 high = read32 (ptr + 4);
1074                 return g_strdup_printf ("0x%08x%08x", high, low);
1075         }
1076         case MONO_TYPE_R4: {
1077                 float r;
1078                 readr4 (ptr, &r);
1079                 return g_strdup_printf ("%g", (double) r);
1080         }
1081         case MONO_TYPE_R8: {
1082                 double r;
1083                 readr8 (ptr, &r);
1084                 return g_strdup_printf ("%g", r);
1085         }
1086         case MONO_TYPE_STRING: {
1087                 int i, j, e;
1088                 char *res;
1089                 e = len = 0;
1090                 for (i = 0; !ptr [i+1]; i += 2){
1091                         len++;
1092                         switch (ptr [i]) {
1093                         case '"':
1094                         case '\\':
1095                         case '\n': /* add more */
1096                                 e++;
1097                         }
1098                 }
1099                 res = g_malloc (len + e + 3);
1100                 j = 1;
1101                 res [0] = '"';
1102
1103                 for (i = 0; i < len; i += 2){
1104                         switch(ptr[i]) {
1105                         case '"':
1106                                 res[j++] = '\\';
1107                                 res[j++] = '"';
1108                         case '\\':
1109                                 res[j++] = '\\';
1110                                 res[j++] = '\\';
1111                         case '\n':
1112                                 res[j++] = '\\';
1113                                 res[j++] = 'n';
1114                                 break;
1115                         default:
1116                                 res[j++] = isprint (ptr [i]) ? ptr [i] : '.';
1117                                 break;
1118                         }
1119                 }
1120                 res[j++] = '"';
1121                 res[j] = 0;
1122                 return res;
1123         }
1124
1125         case MONO_TYPE_CLASS:
1126                 return g_strdup ("CLASS CONSTANT.  MUST BE ZERO");
1127
1128         default:
1129                 g_error ("Unknown MONO_TYPE (%d) on constant at Blob index (0x%08x)\n",
1130                          (int) *ptr, blob_index);
1131                 return g_strdup_printf ("Unknown");
1132         }
1133
1134 }
1135
1136 /**
1137  * get_token:
1138  * @m: metadata context
1139  * @token: token that we want to decode.
1140  *
1141  * Returns: An allocated value representing a stringified version of the
1142  * constant.
1143  */
1144 char *
1145 get_token (MonoImage *m, guint32 token)
1146 {
1147         guint32 idx = mono_metadata_token_index (token);
1148
1149         switch (mono_metadata_token_code (token)){
1150         case MONO_TOKEN_FIELD_DEF:
1151                 return (get_field (m, token));
1152         case MONO_TOKEN_TYPE_DEF:
1153                 return get_typedef (m, idx);
1154         case MONO_TOKEN_TYPE_REF:
1155                 return get_typeref (m, idx);
1156         case MONO_TOKEN_TYPE_SPEC:
1157                 return get_typespec (m, idx);
1158         default:
1159                 g_error ("Do not know how to decode tokens of type 0x%08x", token);
1160         }
1161
1162         g_assert_not_reached ();
1163         return g_strdup ("ERROR");
1164 }
1165
1166 /**
1167  * get_token_type:
1168  * @m: metadata context
1169  * @token: the token can belong to any of the following tables:
1170  * MONO_TOKEN_TYPE_REF, MONO_TOKEN_TYPE_DEF, MONO_TOKEN_TYPE_SPEC
1171  *
1172  * Returns: a stringified version of the MethodDef or MethodRef or TypeSpecn
1173  * at (token & 0xffffff)
1174  */
1175 char *
1176 get_token_type (MonoImage *m, guint32 token)
1177 {
1178         char *temp = NULL, *s;
1179         int idx;
1180
1181         idx = mono_metadata_token_index (token);
1182
1183         switch (mono_metadata_token_code (token)){
1184         case MONO_TOKEN_TYPE_DEF:
1185                 temp = get_typedef (m, idx);
1186                 s = g_strdup_printf ("%s", temp);
1187                 break;
1188
1189         case MONO_TOKEN_TYPE_REF:
1190                 temp = get_typeref (m, idx);
1191                 s = g_strdup_printf ("%s", temp);
1192                 break;
1193
1194         case MONO_TOKEN_TYPE_SPEC:
1195                 s = get_typespec (m, idx);
1196                 break;
1197
1198         default:
1199                 g_error ("Unhandled encoding for typedef-or-ref coded index");
1200
1201         }
1202
1203         if (temp)
1204                 g_free (temp);
1205
1206         return s;
1207 }
1208
1209 char *
1210 get_guid (MonoImage *m, guint32 guid_index)
1211 {
1212         const unsigned char *guid;
1213         char *result;
1214
1215         guid = mono_metadata_guid_heap (m, guid_index);
1216
1217         result = g_strdup_printf ("{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
1218                         guid [3], guid [2], guid [1], guid [0], guid [5], guid [4], guid [7], guid [6],
1219                         guid [8], guid [9], guid [10], guid [11], guid [12], guid [13], guid [14], guid [15]);
1220         return result;
1221 }
1222
1223 GList *
1224 dis_get_custom_attrs (MonoImage *m, guint32 token)
1225 {
1226         GList *list = NULL;
1227         guint32 idx, i, j, len, mtoken;
1228         guint32 cols [MONO_CUSTOM_ATTR_SIZE];
1229         MonoTableInfo *ca;
1230         char *method;
1231         GString *attr;
1232         const char *val;
1233
1234         idx = mono_metadata_token_index (token);
1235         idx <<= CUSTOM_ATTR_BITS;
1236
1237         switch (mono_metadata_token_table (token)) {
1238         case MONO_TABLE_TYPEDEF:
1239                 idx |= CUSTOM_ATTR_TYPEDEF;
1240                 break;
1241         case MONO_TABLE_ASSEMBLY:
1242                 idx |= CUSTOM_ATTR_ASSEMBLY;
1243                 break;
1244         case MONO_TABLE_PROPERTY:
1245                 idx |= CUSTOM_ATTR_PROPERTY;
1246                 break;
1247         case MONO_TABLE_EVENT:
1248                 idx |= CUSTOM_ATTR_EVENT;
1249                 break;
1250         case MONO_TABLE_FIELD:
1251                 idx |= CUSTOM_ATTR_FIELDDEF;
1252                 break;
1253         case MONO_TABLE_METHOD:
1254                 idx |= CUSTOM_ATTR_METHODDEF;
1255                 break;
1256         case MONO_TABLE_PARAM:
1257                 idx |= CUSTOM_ATTR_PARAMDEF;
1258                 break;
1259         default:
1260                 g_print ("Missing custom attr get support for token 0x%08x\n", token);
1261                 return NULL;
1262         }
1263
1264         ca = &m->tables [MONO_TABLE_CUSTOMATTRIBUTE];
1265         /* the table is not sorted */
1266         for (i = 0; i < ca->rows; ++i) {
1267                 mono_metadata_decode_row (ca, i, cols, MONO_CUSTOM_ATTR_SIZE);
1268                 if (cols [MONO_CUSTOM_ATTR_PARENT] != idx)
1269                         continue;
1270                 mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> CUSTOM_ATTR_TYPE_BITS;
1271                 switch (cols [MONO_CUSTOM_ATTR_TYPE] & CUSTOM_ATTR_TYPE_MASK) {
1272                 case CUSTOM_ATTR_TYPE_METHODDEF:
1273                         mtoken |= MONO_TOKEN_METHOD_DEF;
1274                         break;
1275                 case CUSTOM_ATTR_TYPE_MEMBERREF:
1276                         mtoken |= MONO_TOKEN_MEMBER_REF;
1277                         break;
1278                 default:
1279                         g_error ("Unknown table for custom attr type %08x", cols [MONO_CUSTOM_ATTR_TYPE]);
1280                         break;
1281                 }
1282                 method = get_method (m, mtoken);
1283                 val = mono_metadata_blob_heap (m, cols [MONO_CUSTOM_ATTR_VALUE]);
1284                 len = mono_metadata_decode_value (val, &val);
1285                 attr = g_string_new (".custom ");
1286                 g_string_sprintfa (attr, "%s = (", method);
1287                 for (j = 0; j < len; ++j) {
1288                         if (len > 4 && !(j % 16))
1289                                 g_string_append (attr, "\n\t\t");
1290                         g_string_sprintfa (attr, " %02X", (val [j] & 0xff));
1291                 }
1292                 g_string_append_c (attr, ')');
1293                 list = g_list_append (list, attr->str);
1294                 g_string_free (attr, FALSE);
1295                 g_free (method);
1296         }
1297         return list;
1298 }
1299