2 * dump.c: Dumping routines for the disassembler.
5 * Miguel de Icaza (miguel@ximian.com)
7 * (C) 2001 Ximian, Inc.
17 #include "mono/metadata/loader.h"
18 #include "mono/metadata/class.h"
21 dump_table_assembly (MonoImage
*m
)
23 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_ASSEMBLY
];
24 guint32 cols
[MONO_ASSEMBLY_SIZE
];
28 fprintf (output
, "Assembly Table\n");
33 mono_metadata_decode_row (t
, 0, cols
, MONO_ASSEMBLY_SIZE
);
35 fprintf (output
, "Name: %s\n", mono_metadata_string_heap (m
, cols
[MONO_ASSEMBLY_NAME
]));
36 fprintf (output
, "Hash Algoritm: 0x%08x\n", cols
[MONO_ASSEMBLY_HASH_ALG
]);
37 fprintf (output
, "Version: %d.%d.%d.%d\n", cols
[MONO_ASSEMBLY_MAJOR_VERSION
],
38 cols
[MONO_ASSEMBLY_MINOR_VERSION
],
39 cols
[MONO_ASSEMBLY_BUILD_NUMBER
],
40 cols
[MONO_ASSEMBLY_REV_NUMBER
]);
41 fprintf (output
, "Flags: 0x%08x\n", cols
[MONO_ASSEMBLY_FLAGS
]);
42 fprintf (output
, "PublicKey: BlobPtr (0x%08x)\n", cols
[MONO_ASSEMBLY_PUBLIC_KEY
]);
44 ptr
= mono_metadata_blob_heap (m
, cols
[MONO_ASSEMBLY_PUBLIC_KEY
]);
45 len
= mono_metadata_decode_value (ptr
, &ptr
);
47 fprintf (output
, "\tDump:");
48 hex_dump (ptr
, 0, len
);
49 fprintf (output
, "\n");
51 fprintf (output
, "\tZero sized public key\n");
53 fprintf (output
, "Culture: %s\n", mono_metadata_string_heap (m
, cols
[MONO_ASSEMBLY_CULTURE
]));
54 fprintf (output
, "\n");
58 dump_table_typeref (MonoImage
*m
)
60 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_TYPEREF
];
63 fprintf (output
, "Typeref Table\n");
65 for (i
= 1; i
<= t
->rows
; i
++){
66 char *s
= get_typeref (m
, i
);
68 fprintf (output
, "%d: %s\n", i
, s
);
71 fprintf (output
, "\n");
75 dump_table_typedef (MonoImage
*m
)
77 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_TYPEDEF
];
80 fprintf (output
, "Typedef Table\n");
82 for (i
= 1; i
<= t
->rows
; i
++){
83 char *s
= get_typedef (m
, i
);
84 guint32 cols
[MONO_TYPEDEF_SIZE
];
86 mono_metadata_decode_row (&m
->tables
[MONO_TABLE_TYPEDEF
], i
- 1, cols
, MONO_TYPEDEF_SIZE
);
88 fprintf (output
, "%d: %s (flist=%d, mlist=%d, flags=0x%x, extends=0x%x)\n", i
, s
,
89 cols
[MONO_TYPEDEF_FIELD_LIST
], cols
[MONO_TYPEDEF_METHOD_LIST
],
90 cols
[MONO_TYPEDEF_FLAGS
], cols
[MONO_TYPEDEF_EXTENDS
]);
93 fprintf (output
, "\n");
97 dump_table_typespec (MonoImage
*m
)
99 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_TYPESPEC
];
102 fprintf (output
, "Typespec Table\n");
104 for (i
= 1; i
<= t
->rows
; i
++){
105 char *typespec
= get_typespec (m
, i
);
107 fprintf (output
, "%d: %s\n", i
, typespec
);
110 fprintf (output
, "\n");
114 dump_table_assemblyref (MonoImage
*m
)
116 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_ASSEMBLYREF
];
119 fprintf (output
, "AssemblyRef Table\n");
121 for (i
= 0; i
< t
->rows
; i
++){
124 guint32 cols
[MONO_ASSEMBLYREF_SIZE
];
126 mono_metadata_decode_row (t
, i
, cols
, MONO_ASSEMBLYREF_SIZE
);
127 fprintf (output
, "%d: Version=%d.%d.%d.%d\n\tName=%s\n", i
+ 1,
128 cols
[MONO_ASSEMBLYREF_MAJOR_VERSION
],
129 cols
[MONO_ASSEMBLYREF_MINOR_VERSION
],
130 cols
[MONO_ASSEMBLYREF_BUILD_NUMBER
],
131 cols
[MONO_ASSEMBLYREF_REV_NUMBER
],
132 mono_metadata_string_heap (m
, cols
[MONO_ASSEMBLYREF_NAME
]));
133 ptr
= mono_metadata_blob_heap (m
, cols
[MONO_ASSEMBLYREF_PUBLIC_KEY
]);
134 len
= mono_metadata_decode_value (ptr
, &ptr
);
136 fprintf (output
, "\tPublic Key:");
137 hex_dump (ptr
, 0, len
);
138 fprintf (output
, "\n");
140 fprintf (output
, "\tZero sized public key\n");
143 fprintf (output
, "\n");
147 dump_table_param (MonoImage
*m
)
149 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_PARAM
];
152 fprintf (output
, "Param Table\n");
154 for (i
= 0; i
< t
->rows
; i
++){
155 guint32 cols
[MONO_PARAM_SIZE
];
157 mono_metadata_decode_row (t
, i
, cols
, MONO_PARAM_SIZE
);
158 fprintf (output
, "%d: 0x%04x %d %s\n",
160 cols
[MONO_PARAM_FLAGS
], cols
[MONO_PARAM_SEQUENCE
],
161 mono_metadata_string_heap (m
, cols
[MONO_PARAM_NAME
]));
163 fprintf (output
, "\n");
167 dump_table_field (MonoImage
*m
)
169 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FIELD
];
170 MonoTableInfo
*td
= &m
->tables
[MONO_TABLE_TYPEDEF
];
171 MonoTableInfo
*fl
= &m
->tables
[MONO_TABLE_FIELDLAYOUT
];
172 MonoTableInfo
*rva
= &m
->tables
[MONO_TABLE_FIELDRVA
];
173 int i
, current_type
, offset_row
, rva_row
;
174 guint32 first_m
, last_m
;
176 fprintf (output
, "Field Table (1..%d)\n", t
->rows
);
178 rva_row
= offset_row
= current_type
= 1;
179 last_m
= first_m
= 1;
180 for (i
= 1; i
<= t
->rows
; i
++){
181 guint32 cols
[MONO_FIELD_SIZE
];
185 * Find the next type.
187 while (current_type
<= td
->rows
&& i
>= (last_m
= mono_metadata_decode_row_col (td
, current_type
- 1, MONO_TYPEDEF_FIELD_LIST
))) {
191 fprintf (output
, "########## %s.%s\n",
192 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAMESPACE
)),
193 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAME
)));
196 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_FIELD_SIZE
);
197 sig
= get_field_signature (m
, cols
[MONO_FIELD_SIGNATURE
]);
198 flags
= field_flags (cols
[MONO_FIELD_FLAGS
]);
199 fprintf (output
, "%d: %s %s: %s\n",
202 mono_metadata_string_heap (m
, cols
[MONO_FIELD_NAME
]),
206 if (offset_row
<= fl
->rows
&& (mono_metadata_decode_row_col (fl
, offset_row
- 1, MONO_FIELD_LAYOUT_FIELD
) == i
)) {
207 fprintf (output
, "\texplicit offset: %d\n", mono_metadata_decode_row_col (fl
, offset_row
- 1, MONO_FIELD_LAYOUT_OFFSET
));
210 if (rva_row
<= rva
->rows
&& (mono_metadata_decode_row_col (rva
, rva_row
- 1, MONO_FIELD_RVA_FIELD
) == i
)) {
211 fprintf (output
, "\trva: %d\n", mono_metadata_decode_row_col (rva
, rva_row
- 1, MONO_FIELD_RVA_RVA
));
215 fprintf (output
, "\n");
219 dump_table_memberref (MonoImage
*m
)
221 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MEMBERREF
];
225 const char *blob
, *ks
= NULL
;
227 fprintf (output
, "MemberRef Table (1..%d)\n", t
->rows
);
229 for (i
= 0; i
< t
->rows
; i
++){
230 guint32 cols
[MONO_MEMBERREF_SIZE
];
232 mono_metadata_decode_row (t
, i
, cols
, MONO_MEMBERREF_SIZE
);
234 kind
= cols
[MONO_MEMBERREF_CLASS
] & 7;
235 idx
= cols
[MONO_MEMBERREF_CLASS
] >> 3;
237 x
= g_strdup ("UNHANDLED CASE");
242 xx
= get_typedef (m
, idx
);
243 x
= g_strconcat (xx
, ".", mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]), NULL
);
248 xx
= get_typeref (m
, idx
);
249 x
= g_strconcat (xx
, ".", mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]), NULL
);
253 ks
= "ModuleRef"; break;
256 x
= get_methoddef (m
, idx
);
260 xx
= get_typespec (m
, idx
);
261 x
= g_strconcat (xx
, ".", mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]), NULL
);
265 g_error ("Unknown tag: %d\n", kind
);
267 blob
= mono_metadata_blob_heap (m
, cols
[MONO_MEMBERREF_SIGNATURE
]);
268 mono_metadata_decode_blob_size (blob
, &blob
);
269 if (*blob
== 0x6) { /* it's a field */
270 sig
= get_field_signature (m
, cols
[MONO_MEMBERREF_SIGNATURE
]);
272 sig
= get_methodref_signature (m
, cols
[MONO_MEMBERREF_SIGNATURE
], NULL
);
274 fprintf (output
, "%d: %s[%d] %s\n\tResolved: %s\n\tSignature: %s\n\t\n",
277 mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]),
288 dump_table_class_layout (MonoImage
*m
)
290 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_CLASSLAYOUT
];
292 fprintf (output
, "ClassLayout Table (1..%d)\n", t
->rows
);
294 for (i
= 0; i
< t
->rows
; i
++){
295 guint32 cols
[MONO_CLASS_LAYOUT_SIZE
];
297 mono_metadata_decode_row (t
, i
, cols
, MONO_CLASS_LAYOUT_SIZE
);
299 fprintf (output
, "%d: PackingSize=%d ClassSize=%d Parent=%s\n",
300 i
+ 1, cols
[MONO_CLASS_LAYOUT_PACKING_SIZE
],
301 cols
[MONO_CLASS_LAYOUT_CLASS_SIZE
],
302 get_typedef (m
, cols
[MONO_CLASS_LAYOUT_PARENT
]));
307 dump_table_constant (MonoImage
*m
)
309 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_CONSTANT
];
311 const char *desc
[] = {
317 fprintf (output
, "Constant Table (1..%d)\n", t
->rows
);
319 for (i
= 0; i
< t
->rows
; i
++){
320 guint32 cols
[MONO_CONSTANT_SIZE
];
322 mono_metadata_decode_row (t
, i
, cols
, MONO_CONSTANT_SIZE
);
323 parent
= desc
[cols
[MONO_CONSTANT_PARENT
] & MONO_HASCONSTANT_MASK
];
325 fprintf (output
, "%d: Parent= %s: %d %s\n",
326 i
+ 1, parent
, cols
[MONO_CONSTANT_PARENT
] >> MONO_HASCONSTANT_BITS
,
327 get_constant (m
, (MonoTypeEnum
) cols
[MONO_CONSTANT_TYPE
], cols
[MONO_CONSTANT_VALUE
]));
333 dump_table_property_map (MonoImage
*m
)
335 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_PROPERTYMAP
];
339 fprintf (output
, "Property Map Table (1..%d)\n", t
->rows
);
341 for (i
= 0; i
< t
->rows
; i
++){
342 guint32 cols
[MONO_PROPERTY_MAP_SIZE
];
344 mono_metadata_decode_row (t
, i
, cols
, MONO_PROPERTY_MAP_SIZE
);
345 s
= get_typedef (m
, cols
[MONO_PROPERTY_MAP_PARENT
]);
346 fprintf (output
, "%d: %s (%d) %d\n", i
+ 1, s
, cols
[MONO_PROPERTY_MAP_PARENT
], cols
[MONO_PROPERTY_MAP_PROPERTY_LIST
]);
352 dump_table_property (MonoImage
*m
)
354 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_PROPERTY
];
359 fprintf (output
, "Property Table (1..%d)\n", t
->rows
);
361 for (i
= 0; i
< t
->rows
; i
++){
362 guint32 cols
[MONO_PROPERTY_SIZE
];
367 mono_metadata_decode_row (t
, i
, cols
, MONO_PROPERTY_SIZE
);
369 prop_flags
= cols
[MONO_PROPERTY_FLAGS
];
370 if (prop_flags
& 0x0200)
371 strcat (flags
, "special ");
372 if (prop_flags
& 0x0400)
373 strcat (flags
, "runtime ");
374 if (prop_flags
& 0x1000)
375 strcat (flags
, "hasdefault ");
377 ptr
= mono_metadata_blob_heap (m
, cols
[MONO_PROPERTY_TYPE
]);
378 bsize
= mono_metadata_decode_blob_size (ptr
, &ptr
);
379 /* ECMA claims 0x08 ... */
380 if (*ptr
!= 0x28 && *ptr
!= 0x08)
381 g_warning("incorrect signature in propert blob: 0x%x", *ptr
);
383 pcount
= mono_metadata_decode_value (ptr
, &ptr
);
384 ptr
= get_type (m
, ptr
, &type
);
385 fprintf (output
, "%d: %s %s (",
386 i
+ 1, type
, mono_metadata_string_heap (m
, cols
[MONO_PROPERTY_NAME
]));
389 for (j
= 0; j
< pcount
; j
++){
390 ptr
= get_param (m
, ptr
, &type
);
391 fprintf (output
, "%s%s", j
> 0? ", " : "",type
);
394 fprintf (output
, ") %s\n", flags
);
399 dump_table_event (MonoImage
*m
)
401 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_EVENT
];
403 fprintf (output
, "Event Table (1..%d)\n", t
->rows
);
405 for (i
= 0; i
< t
->rows
; i
++){
406 guint32 cols
[MONO_EVENT_SIZE
];
410 mono_metadata_decode_row (t
, i
, cols
, MONO_EVENT_SIZE
);
412 name
= mono_metadata_string_heap (m
, cols
[MONO_EVENT_NAME
]);
413 type
= get_typedef_or_ref (m
, cols
[MONO_EVENT_TYPE
]);
414 fprintf (output
, "%d: %s %s %s\n", i
+ 1, type
, name
,
415 cols
[MONO_EVENT_FLAGS
] & 0x200 ? "specialname " : "");
422 dump_table_file (MonoImage
*m
)
424 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FILE
];
426 fprintf (output
, "File Table (1..%d)\n", t
->rows
);
428 for (i
= 0; i
< t
->rows
; i
++){
429 guint32 cols
[MONO_FILE_SIZE
];
430 const char *name
, *hash
;
432 mono_metadata_decode_row (t
, i
, cols
, MONO_FILE_SIZE
);
434 name
= mono_metadata_string_heap (m
, cols
[MONO_FILE_NAME
]);
435 fprintf (output
, "%d: %s %s [", i
+ 1, name
,
436 cols
[MONO_FILE_FLAGS
] & 0x1 ? "nometadata" : "containsmetadata");
437 hash
= mono_metadata_blob_heap (m
, cols
[MONO_FILE_HASH_VALUE
]);
438 len
= mono_metadata_decode_blob_size (hash
, &hash
);
439 for (j
= 0; j
< len
; ++j
)
440 fprintf (output
, "%s%02X", j
? " ": "", hash
[j
] & 0xff);
441 fprintf (output
, "]\n");
447 get_manifest_implementation (MonoImage
*m
, guint32 idx
)
450 const char* table
= "";
452 return g_strdup ("current module");
453 row
= idx
>> MONO_IMPLEMENTATION_BITS
;
454 switch (idx
& MONO_IMPLEMENTATION_MASK
) {
455 case MONO_IMPLEMENTATION_FILE
:
458 case MONO_IMPLEMENTATION_ASSEMBLYREF
:
459 table
= "assemblyref";
461 case MONO_IMPLEMENTATION_EXP_TYPE
:
462 table
= "exportedtype";
465 g_assert_not_reached ();
467 return g_strdup_printf ("%s %d", table
, row
);
471 get_manifest_flags (guint32 mf
)
475 case 1: return "public";
476 case 2: return "private";
483 dump_table_manifest (MonoImage
*m
)
485 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MANIFESTRESOURCE
];
487 fprintf (output
, "Manifestresource Table (1..%d)\n", t
->rows
);
489 for (i
= 0; i
< t
->rows
; i
++){
490 guint32 cols
[MONO_MANIFEST_SIZE
];
491 const char *name
, *mf
;
494 mono_metadata_decode_row (t
, i
, cols
, MONO_MANIFEST_SIZE
);
496 name
= mono_metadata_string_heap (m
, cols
[MONO_MANIFEST_NAME
]);
497 mf
= get_manifest_flags (cols
[MONO_MANIFEST_FLAGS
]);
498 impl
= get_manifest_implementation (m
, cols
[MONO_MANIFEST_IMPLEMENTATION
]);
499 fprintf (output
, "%d: %s '%s' at offset %u in %s\n", i
+ 1, mf
, name
, cols
[MONO_MANIFEST_OFFSET
], impl
);
506 dump_table_moduleref (MonoImage
*m
)
508 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MODULEREF
];
510 fprintf (output
, "ModuleRef Table (1..%d)\n", t
->rows
);
512 for (i
= 0; i
< t
->rows
; i
++){
513 guint32 cols
[MONO_MODULEREF_SIZE
];
516 mono_metadata_decode_row (t
, i
, cols
, MONO_MODULEREF_SIZE
);
518 name
= mono_metadata_string_heap (m
, cols
[MONO_MODULEREF_NAME
]);
519 fprintf (output
, "%d: %s\n", i
+ 1, name
);
525 dump_table_module (MonoImage
*m
)
527 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MODULE
];
529 fprintf (output
, "ModuleRef Table (1..%d)\n", t
->rows
);
531 for (i
= 0; i
< t
->rows
; i
++){
532 guint32 cols
[MONO_MODULE_SIZE
];
536 mono_metadata_decode_row (t
, i
, cols
, MONO_MODULE_SIZE
);
538 name
= mono_metadata_string_heap (m
, cols
[MONO_MODULE_NAME
]);
539 guid
= get_guid (m
, cols
[MONO_MODULE_MVID
]);
540 fprintf (output
, "%d: %s %d %s\n", i
+ 1, name
, cols
[MONO_MODULE_MVID
], guid
);
545 dump_table_method (MonoImage
*m
)
547 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHOD
];
548 MonoTableInfo
*td
= &m
->tables
[MONO_TABLE_TYPEDEF
];
550 guint32 first_m
, last_m
;
551 fprintf (output
, "Method Table (1..%d)\n", t
->rows
);
554 last_m
= first_m
= 1;
555 for (i
= 1; i
<= t
->rows
; i
++){
556 guint32 cols
[MONO_METHOD_SIZE
];
559 MonoMethodSignature
*method
;
562 * Find the next type.
564 while (current_type
<= td
->rows
&& i
>= (last_m
= mono_metadata_decode_row_col (td
, current_type
- 1, MONO_TYPEDEF_METHOD_LIST
))) {
568 fprintf (output
, "########## %s.%s\n",
569 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAMESPACE
)),
570 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAME
)));
573 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHOD_SIZE
);
574 sigblob
= mono_metadata_blob_heap (m
, cols
[MONO_METHOD_SIGNATURE
]);
575 mono_metadata_decode_blob_size (sigblob
, &sigblob
);
576 method
= mono_metadata_parse_method_signature (m
, i
, sigblob
, &sigblob
);
577 sig
= dis_stringify_method_signature (m
, method
, i
, FALSE
);
578 fprintf (output
, "%d: %s (param: %d)\n", i
, sig
, cols
[MONO_METHOD_PARAMLIST
]);
580 mono_metadata_free_method_signature (method
);
586 dump_table_implmap (MonoImage
*m
)
588 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_IMPLMAP
];
589 MonoTableInfo
*td
= &m
->tables
[MONO_TABLE_MODULEREF
];
592 fprintf (output
, "ImplMap Table (1..%d)\n", t
->rows
);
594 for (i
= 1; i
<= t
->rows
; i
++){
595 guint32 cols
[MONO_IMPLMAP_SIZE
];
598 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_IMPLMAP_SIZE
);
600 method
= get_method (m
, MONO_TOKEN_METHOD_DEF
| (cols
[MONO_IMPLMAP_MEMBER
] >> MONO_MEMBERFORWD_BITS
));
602 fprintf (output
, "%d: %s %d (%s %s)\n", i
,
604 cols
[MONO_IMPLMAP_FLAGS
],
605 mono_metadata_string_heap (m
, cols
[MONO_IMPLMAP_NAME
]),
606 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, cols
[MONO_IMPLMAP_SCOPE
] - 1, MONO_MODULEREF_NAME
)));
611 dump_table_methodimpl (MonoImage
*m
)
613 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHODIMPL
];
614 /*MonoTableInfo *td = &m->tables [MONO_TABLE_TYPEDEF];*/
617 fprintf (output
, "MethodImpl Table (1..%d)\n", t
->rows
);
619 for (i
= 1; i
<= t
->rows
; i
++){
620 guint32 cols
[MONO_METHODIMPL_SIZE
];
621 char *class, *impl
, *decl
;
623 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHODIMPL_SIZE
);
624 class = get_typedef (m
, cols
[MONO_METHODIMPL_CLASS
]);
625 impl
= get_method (m
, method_dor_to_token (cols
[MONO_METHODIMPL_BODY
]));
626 decl
= get_method (m
, method_dor_to_token (cols
[MONO_METHODIMPL_DECLARATION
]));
627 fprintf (output
, "%d: %s\n\tdecl: %s\n\timpl: %s\n", i
, class, decl
, impl
);
635 static dis_map_t semantics_map
[] = {
646 dump_table_methodsem (MonoImage
*m
)
648 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHODSEMANTICS
];
649 int i
, is_property
, index
;
650 const char *semantics
;
652 fprintf (output
, "Method Semantics Table (1..%d)\n", t
->rows
);
653 for (i
= 1; i
<= t
->rows
; i
++){
654 guint32 cols
[MONO_METHOD_SEMA_SIZE
];
656 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHOD_SEMA_SIZE
);
657 semantics
= flags (cols
[MONO_METHOD_SEMA_SEMANTICS
], semantics_map
);
658 is_property
= cols
[MONO_METHOD_SEMA_ASSOCIATION
] & MONO_HAS_SEMANTICS_MASK
;
659 index
= cols
[MONO_METHOD_SEMA_ASSOCIATION
] >> MONO_HAS_SEMANTICS_BITS
;
660 fprintf (output
, "%d: [%d] %s method: %d %s %d\n", i
, cols
[MONO_METHOD_SEMA_ASSOCIATION
], semantics
,
661 cols
[MONO_METHOD_SEMA_METHOD
] - 1,
662 is_property
? "property" : "event",
668 dump_table_interfaceimpl (MonoImage
*m
)
670 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_INTERFACEIMPL
];
673 fprintf (output
, "Interface Implementation Table (1..%d)\n", t
->rows
);
674 for (i
= 1; i
<= t
->rows
; i
++) {
675 guint32 cols
[MONO_INTERFACEIMPL_SIZE
];
677 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_INTERFACEIMPL_SIZE
);
678 fprintf (output
, "%d: %s implements %s\n", i
,
679 get_typedef (m
, cols
[MONO_INTERFACEIMPL_CLASS
]),
680 get_typedef_or_ref (m
, cols
[MONO_INTERFACEIMPL_INTERFACE
]));
685 has_cattr_get_table (MonoImage
*m
, guint32 val
)
687 guint32 t
= val
& MONO_CUSTOM_ATTR_MASK
;
688 guint32 index
= val
>> MONO_CUSTOM_ATTR_BITS
;
692 case MONO_CUSTOM_ATTR_METHODDEF
:
695 case MONO_CUSTOM_ATTR_FIELDDEF
:
698 case MONO_CUSTOM_ATTR_TYPEREF
:
701 case MONO_CUSTOM_ATTR_TYPEDEF
:
704 case MONO_CUSTOM_ATTR_PARAMDEF
:
707 case MONO_CUSTOM_ATTR_INTERFACE
:
708 table
= "InterfaceImpl";
710 case MONO_CUSTOM_ATTR_MEMBERREF
:
713 case MONO_CUSTOM_ATTR_MODULE
:
716 case MONO_CUSTOM_ATTR_PERMISSION
:
717 table
= "DeclSecurity?";
719 case MONO_CUSTOM_ATTR_PROPERTY
:
722 case MONO_CUSTOM_ATTR_EVENT
:
725 case MONO_CUSTOM_ATTR_SIGNATURE
:
726 table
= "StandAloneSignature";
728 case MONO_CUSTOM_ATTR_MODULEREF
:
731 case MONO_CUSTOM_ATTR_TYPESPEC
:
734 case MONO_CUSTOM_ATTR_ASSEMBLY
:
737 case MONO_CUSTOM_ATTR_ASSEMBLYREF
:
738 table
= "AssemblyRef";
740 case MONO_CUSTOM_ATTR_FILE
:
743 case MONO_CUSTOM_ATTR_EXP_TYPE
:
744 table
= "ExportedType";
746 case MONO_CUSTOM_ATTR_MANIFEST
:
754 * FIXME: we should decode the index into something more uman-friendly.
756 return g_strdup_printf ("%s: %d", table
, index
);
760 custom_attr_params (MonoImage
*m
, MonoMethodSignature
* sig
, const char* value
)
762 int len
, i
, slen
, type
;
765 const char *p
= value
;
767 len
= mono_metadata_decode_value (p
, &p
);
768 if (len
< 2 || read16 (p
) != 0x0001) /* Prolog */
769 return g_strdup ("");
773 res
= g_string_new ("");
774 for (i
= 0; i
< sig
->param_count
; ++i
) {
776 g_string_append (res
, ", ");
777 type
= sig
->params
[i
]->type
;
781 g_string_sprintfa (res
, "%d", (unsigned int)*p
);
785 g_string_sprintfa (res
, "%d", *p
);
788 case MONO_TYPE_BOOLEAN
:
789 g_string_sprintfa (res
, "%s", *p
?"true":"false");
793 g_string_sprintfa (res
, "'%c'", read16 (p
));
797 g_string_sprintfa (res
, "%d", read16 (p
));
801 g_string_sprintfa (res
, "%d", (gint16
)read16 (p
));
805 g_string_sprintfa (res
, "%d", read32 (p
));
809 g_string_sprintfa (res
, "%d", (gint32
)read32 (p
));
813 g_string_sprintfa (res
, "%lld", read64 (p
));
817 g_string_sprintfa (res
, "%lld", (gint64
)read64 (p
));
823 g_string_sprintfa (res
, "%g", val
);
830 g_string_sprintfa (res
, "%g", val
);
834 case MONO_TYPE_VALUETYPE
:
835 if (mono_class_is_enum (sig
->params
[i
]->data
.klass
)) {
836 type
= mono_class_enum_basetype (sig
->params
[i
]->data
.klass
)->type
;
839 g_warning ("generic valutype not handled in custom attr value decoding");
842 case MONO_TYPE_CLASS
: /* It must be a Type: check? */
843 case MONO_TYPE_STRING
:
844 if (*p
== (char)0xff) {
845 g_string_append (res
, "null");
849 slen
= mono_metadata_decode_value (p
, &p
);
850 g_string_append_c (res
, '"');
851 g_string_append (res
, p
);
852 g_string_append_c (res
, '"');
856 g_warning ("Type %02x not handled in custom attr value decoding", sig
->params
[i
]->type
);
862 g_string_sprintfa (res
, " %d named args: (", slen
);
863 slen
= len
- (p
- value
) + 1;
864 for (i
= 0; i
< slen
; ++i
) {
865 g_string_sprintfa (res
, " %02X", (p
[i
] & 0xff));
867 g_string_append_c (res
, ')');
870 g_string_free (res
, FALSE
);
875 dump_table_customattr (MonoImage
*m
)
877 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_CUSTOMATTRIBUTE
];
880 fprintf (output
, "Custom Attributes Table (1..%d)\n", t
->rows
);
881 for (i
= 1; i
<= t
->rows
; i
++) {
882 guint32 cols
[MONO_CUSTOM_ATTR_SIZE
];
889 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_CUSTOM_ATTR_SIZE
);
890 desc
= has_cattr_get_table (m
, cols
[MONO_CUSTOM_ATTR_PARENT
]);
891 mtoken
= cols
[MONO_CUSTOM_ATTR_TYPE
] >> MONO_CUSTOM_ATTR_TYPE_BITS
;
892 switch (cols
[MONO_CUSTOM_ATTR_TYPE
] & MONO_CUSTOM_ATTR_TYPE_MASK
) {
893 case MONO_CUSTOM_ATTR_TYPE_METHODDEF
:
894 mtoken
|= MONO_TOKEN_METHOD_DEF
;
896 case MONO_CUSTOM_ATTR_TYPE_MEMBERREF
:
897 mtoken
|= MONO_TOKEN_MEMBER_REF
;
900 g_warning ("Unknown table for custom attr type %08x", cols
[MONO_CUSTOM_ATTR_TYPE
]);
903 method
= get_method (m
, mtoken
);
904 meth
= mono_get_method (m
, mtoken
, NULL
);
905 params
= custom_attr_params (m
, mono_method_signature (meth
), mono_metadata_blob_heap (m
, cols
[MONO_CUSTOM_ATTR_VALUE
]));
906 fprintf (output
, "%d: %s: %s [%s]\n", i
, desc
, method
, params
);
914 dump_table_nestedclass (MonoImage
*m
)
916 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_NESTEDCLASS
];
917 guint32 cols
[MONO_NESTED_CLASS_SIZE
];
919 char *nested
, *nesting
;
920 fprintf (output
, "NestedClass Table (1..%d)\n", t
->rows
);
922 for (i
= 1; i
<= t
->rows
; i
++){
923 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_NESTED_CLASS_SIZE
);
924 nested
= get_typedef (m
, cols
[MONO_NESTED_CLASS_NESTED
]);
925 nesting
= get_typedef (m
, cols
[MONO_NESTED_CLASS_ENCLOSING
]);
926 fprintf (output
, "%d: %d %d: %s in %s\n", i
,
927 cols
[MONO_NESTED_CLASS_NESTED
],
928 cols
[MONO_NESTED_CLASS_ENCLOSING
], nested
, nesting
);
936 dump_table_exported (MonoImage
*m
)
938 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_EXPORTEDTYPE
];
939 guint32 cols
[MONO_EXP_TYPE_SIZE
];
941 const char *name
, *nspace
;
944 fprintf (output
, "ExportedType Table (1..%d)\n", t
->rows
);
946 for (i
= 1; i
<= t
->rows
; i
++) {
947 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_EXP_TYPE_SIZE
);
948 name
= mono_metadata_string_heap (m
, cols
[MONO_EXP_TYPE_NAME
]);
949 nspace
= mono_metadata_string_heap (m
, cols
[MONO_EXP_TYPE_NAMESPACE
]);
950 impl
= get_manifest_implementation (m
, cols
[MONO_EXP_TYPE_IMPLEMENTATION
]);
951 index
= cols
[MONO_EXP_TYPE_TYPEDEF
];
952 fprintf (output
, "%d: %s%s%s is in %s, token %x\n", i
, nspace
, *nspace
? "." : "", name
, impl
, index
);
959 dump_table_field_marshal (MonoImage
*m
)
961 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FIELDMARSHAL
];
962 guint32 cols
[MONO_FIELD_MARSHAL_SIZE
];
963 int i
, is_field
, idx
;
967 fprintf (output
, "FieldMarshal Table (1..%d)\n", t
->rows
);
969 for (i
= 1; i
<= t
->rows
; i
++) {
970 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_FIELD_MARSHAL_SIZE
);
971 blob
= mono_metadata_blob_heap (m
, cols
[MONO_FIELD_MARSHAL_NATIVE_TYPE
]);
972 native
= get_marshal_info (m
, blob
);
973 is_field
= (cols
[MONO_FIELD_MARSHAL_PARENT
] & MONO_HAS_FIELD_MARSHAL_MASK
) == MONO_HAS_FIELD_MARSHAL_FIELDSREF
;
974 idx
= cols
[MONO_FIELD_MARSHAL_PARENT
] >> MONO_HAS_FIELD_MARSHAL_BITS
;
975 fprintf (output
, "%d: (0x%04x) %s %d: %s\n", i
, cols
[MONO_FIELD_MARSHAL_PARENT
], is_field
? "Field" : "Param", idx
, native
);
982 get_security_action (int val
) {
983 static char buf
[32];
986 case SECURITY_ACTION_DEMAND
:
988 case SECURITY_ACTION_ASSERT
:
990 case SECURITY_ACTION_DENY
:
992 case SECURITY_ACTION_PERMITONLY
:
994 case SECURITY_ACTION_LINKDEMAND
:
996 case SECURITY_ACTION_INHERITDEMAND
:
997 return "InheritanceDemand";
998 case SECURITY_ACTION_REQMIN
:
999 return "RequestMinimum";
1000 case SECURITY_ACTION_REQOPT
:
1001 return "RequestOptional";
1002 case SECURITY_ACTION_REQREFUSE
:
1003 return "RequestRefuse";
1004 /* Special actions (for non CAS permissions) */
1005 case SECURITY_ACTION_NONCASDEMAND
:
1006 return "NonCasDemand";
1007 case SECURITY_ACTION_NONCASLINKDEMAND
:
1008 return "NonCasLinkDemand";
1009 case SECURITY_ACTION_NONCASINHERITANCE
:
1010 return "NonCasInheritance";
1011 /* Fx 2.0 actions (for both CAS and non-CAS permissions) */
1012 case SECURITY_ACTION_LINKDEMANDCHOICE
:
1013 return "LinkDemandChoice";
1014 case SECURITY_ACTION_INHERITDEMANDCHOICE
:
1015 return "InheritanceDemandChoice";
1016 case SECURITY_ACTION_DEMANDCHOICE
:
1017 return "DemandChoice";
1019 g_snprintf (buf
, sizeof (buf
), "0x%04X", val
);
1025 dump_table_declsec (MonoImage
*m
)
1027 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_DECLSECURITY
];
1028 guint32 cols
[MONO_DECL_SECURITY_SIZE
];
1031 const char *blob
, *action
;
1032 const char* parent
[] = {
1033 "TypeDef", "MethodDef", "Assembly", ""
1036 fprintf (output
, "DeclSecurity Table (1..%d)\n", t
->rows
);
1038 for (i
= 1; i
<= t
->rows
; i
++) {
1039 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_DECL_SECURITY_SIZE
);
1040 blob
= mono_metadata_blob_heap (m
, cols
[MONO_DECL_SECURITY_PERMISSIONSET
]);
1041 len
= mono_metadata_decode_blob_size (blob
, &blob
);
1042 action
= get_security_action (cols
[MONO_DECL_SECURITY_ACTION
]);
1043 idx
= cols
[MONO_DECL_SECURITY_PARENT
];
1044 fprintf (output
, "%d: %s on %s %d%s", i
, action
, parent
[idx
& MONO_HAS_DECL_SECURITY_MASK
], idx
>> MONO_HAS_DECL_SECURITY_BITS
, len
? ":\n\t":"\n");
1047 for (idx
= 0; idx
< len
; ++idx
)
1048 fprintf (output
, "%c", blob
[idx
]);
1049 fprintf (output
, "\n");
1054 dump_table_genericpar (MonoImage
*m
)
1056 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_GENERICPARAM
];
1057 guint32 cols
[MONO_GENERICPARAM_SIZE
];
1060 fprintf (output
, "GenericParameters (1..%d)\n", t
->rows
);
1062 for (i
= 1; i
<= t
->rows
; i
++) {
1064 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_GENERICPARAM_SIZE
);
1066 sig
= get_type_or_methdef (m
, cols
[MONO_GENERICPARAM_OWNER
]);
1067 fprintf (output
, "%d: %d, flags=%d, owner=%s %s\n", i
,
1068 cols
[MONO_GENERICPARAM_NUMBER
],
1069 cols
[MONO_GENERICPARAM_FLAGS
], sig
,
1070 mono_metadata_string_heap (m
, cols
[MONO_GENERICPARAM_NAME
]));
1076 dump_table_methodspec (MonoImage
*m
)
1078 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHODSPEC
];
1079 guint32 cols
[MONO_METHODSPEC_SIZE
];
1082 fprintf (output
, "MethodSpec (1..%d)\n", t
->rows
);
1084 for (i
= 1; i
<= t
->rows
; i
++) {
1089 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHODSPEC_SIZE
);
1091 /* build a methodspec token to get the method */
1092 token
= MONO_TOKEN_METHOD_SPEC
| i
;
1093 method
= get_method (m
, token
);
1095 sig
= get_method_type_param (m
, cols
[MONO_METHODSPEC_SIGNATURE
]);
1096 fprintf (output
, "%d: %s, %s\n", i
, method
, sig
);
1103 dump_table_parconstraint (MonoImage
*m
)
1105 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_GENERICPARAMCONSTRAINT
];
1106 guint32 cols
[MONO_GENPARCONSTRAINT_SIZE
];
1109 fprintf (output
, "Generic Param Constraint (1..%d)\n", t
->rows
);
1111 for (i
= 1; i
<= t
->rows
; i
++) {
1113 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_GENPARCONSTRAINT_SIZE
);
1115 sig
= get_typedef_or_ref (m
, cols
[MONO_GENPARCONSTRAINT_CONSTRAINT
]);
1116 fprintf (output
, "%d: gen-par=%d, Constraint=%s\n", i
,
1117 cols
[MONO_GENPARCONSTRAINT_GENERICPAR
], sig
);
1123 dump_stream_blob (MonoImage
*m
)
1127 fprintf (output
, "Blob heap contents\n");
1129 for (i
= 0; i
< m
->heap_blob
.size
; i
++) {
1132 fprintf (output
, "\n");
1133 else if ((i
% 8) == 0)
1134 fprintf (output
, "- ");
1136 fprintf (output
, "%02x ", m
->heap_blob
.data
[i
] & 0xff);
1139 fprintf (output
, "\n");
1143 dump_table_standalonesig (MonoImage
*m
)
1145 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_STANDALONESIG
];
1146 guint32 cols
[MONO_STAND_ALONE_SIGNATURE_SIZE
];
1149 fprintf (output
, "Stand alone signature (1..%d)\n", t
->rows
);
1151 for (i
= 1; i
<= t
->rows
; i
++) {
1152 const char *locals_ptr
;
1155 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_STAND_ALONE_SIGNATURE_SIZE
);
1157 locals_ptr
= mono_metadata_blob_heap (m
, cols
[MONO_STAND_ALONE_SIGNATURE
]);
1158 bsize
= mono_metadata_decode_blob_size (locals_ptr
, &locals_ptr
);
1160 fprintf (output
, "%d: blob[0x%x] = ", i
, cols
[MONO_STAND_ALONE_SIGNATURE
]);
1162 for (j
= 0; j
< bsize
; j
++) {
1163 fprintf (output
, "%02x ", locals_ptr
[j
]);
1165 fprintf (output
, "\n");