2 * dump.c: Dumping routines for the disassembler.
5 * Miguel de Icaza (miguel@ximian.com)
7 * (C) 2001 Ximian, Inc.
19 #include "mono/metadata/loader.h"
20 #include "mono/metadata/class.h"
21 #include "mono/metadata/class-internals.h"
22 #include "mono/utils/mono-compiler.h"
24 #if defined(__native_client__) && defined(__GLIBC__)
25 volatile int __nacl_thread_suspension_needed
= 0;
26 void __nacl_suspend_thread_if_needed() {}
30 dump_table_assembly (MonoImage
*m
)
32 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_ASSEMBLY
];
33 guint32 cols
[MONO_ASSEMBLY_SIZE
];
37 fprintf (output
, "Assembly Table\n");
42 mono_metadata_decode_row (t
, 0, cols
, MONO_ASSEMBLY_SIZE
);
44 fprintf (output
, "Name: %s\n", mono_metadata_string_heap (m
, cols
[MONO_ASSEMBLY_NAME
]));
45 fprintf (output
, "Hash Algoritm: 0x%08x\n", cols
[MONO_ASSEMBLY_HASH_ALG
]);
46 fprintf (output
, "Version: %d.%d.%d.%d\n", cols
[MONO_ASSEMBLY_MAJOR_VERSION
],
47 cols
[MONO_ASSEMBLY_MINOR_VERSION
],
48 cols
[MONO_ASSEMBLY_BUILD_NUMBER
],
49 cols
[MONO_ASSEMBLY_REV_NUMBER
]);
50 fprintf (output
, "Flags: 0x%08x\n", cols
[MONO_ASSEMBLY_FLAGS
]);
51 fprintf (output
, "PublicKey: BlobPtr (0x%08x)\n", cols
[MONO_ASSEMBLY_PUBLIC_KEY
]);
53 ptr
= mono_metadata_blob_heap (m
, cols
[MONO_ASSEMBLY_PUBLIC_KEY
]);
54 len
= mono_metadata_decode_value (ptr
, &ptr
);
56 fprintf (output
, "\tDump:");
57 hex_dump (ptr
, 0, len
);
58 fprintf (output
, "\n");
60 fprintf (output
, "\tZero sized public key\n");
62 fprintf (output
, "Culture: %s\n", mono_metadata_string_heap (m
, cols
[MONO_ASSEMBLY_CULTURE
]));
63 fprintf (output
, "\n");
67 dump_table_typeref (MonoImage
*m
)
69 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_TYPEREF
];
72 fprintf (output
, "Typeref Table\n");
74 for (i
= 1; i
<= t
->rows
; i
++){
75 char *s
= get_typeref (m
, i
);
77 fprintf (output
, "%d: %s\n", i
, s
);
80 fprintf (output
, "\n");
84 dump_table_typedef (MonoImage
*m
)
86 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_TYPEDEF
];
89 fprintf (output
, "Typedef Table\n");
91 for (i
= 1; i
<= t
->rows
; i
++){
92 char *s
= get_typedef (m
, i
);
93 guint32 cols
[MONO_TYPEDEF_SIZE
];
95 mono_metadata_decode_row (&m
->tables
[MONO_TABLE_TYPEDEF
], i
- 1, cols
, MONO_TYPEDEF_SIZE
);
97 fprintf (output
, "%d: %s (flist=%d, mlist=%d, flags=0x%x, extends=0x%x)\n", i
, s
,
98 cols
[MONO_TYPEDEF_FIELD_LIST
], cols
[MONO_TYPEDEF_METHOD_LIST
],
99 cols
[MONO_TYPEDEF_FLAGS
], cols
[MONO_TYPEDEF_EXTENDS
]);
102 fprintf (output
, "\n");
106 dump_table_typespec (MonoImage
*m
)
108 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_TYPESPEC
];
111 fprintf (output
, "Typespec Table\n");
113 for (i
= 1; i
<= t
->rows
; i
++){
114 char *typespec
= get_typespec (m
, i
, TRUE
, NULL
);
116 fprintf (output
, "%d: %s\n", i
, typespec
);
119 fprintf (output
, "\n");
123 dump_table_assemblyref (MonoImage
*m
)
125 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_ASSEMBLYREF
];
128 fprintf (output
, "AssemblyRef Table\n");
130 for (i
= 0; i
< t
->rows
; i
++){
133 guint32 cols
[MONO_ASSEMBLYREF_SIZE
];
135 mono_metadata_decode_row (t
, i
, cols
, MONO_ASSEMBLYREF_SIZE
);
136 fprintf (output
, "%d: Version=%d.%d.%d.%d\n\tName=%s\n", i
+ 1,
137 cols
[MONO_ASSEMBLYREF_MAJOR_VERSION
],
138 cols
[MONO_ASSEMBLYREF_MINOR_VERSION
],
139 cols
[MONO_ASSEMBLYREF_BUILD_NUMBER
],
140 cols
[MONO_ASSEMBLYREF_REV_NUMBER
],
141 mono_metadata_string_heap (m
, cols
[MONO_ASSEMBLYREF_NAME
]));
142 fprintf (output
, "\tFlags=0x%08x\n", cols
[MONO_ASSEMBLYREF_FLAGS
]);
143 ptr
= mono_metadata_blob_heap (m
, cols
[MONO_ASSEMBLYREF_PUBLIC_KEY
]);
144 len
= mono_metadata_decode_value (ptr
, &ptr
);
146 fprintf (output
, "\tPublic Key:");
147 hex_dump (ptr
, 0, len
);
148 fprintf (output
, "\n");
150 fprintf (output
, "\tZero sized public key\n");
153 fprintf (output
, "\n");
157 dump_table_param (MonoImage
*m
)
159 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_PARAM
];
162 fprintf (output
, "Param Table\n");
164 for (i
= 0; i
< t
->rows
; i
++){
165 guint32 cols
[MONO_PARAM_SIZE
];
167 mono_metadata_decode_row (t
, i
, cols
, MONO_PARAM_SIZE
);
168 fprintf (output
, "%d: 0x%04x %d %s\n",
170 cols
[MONO_PARAM_FLAGS
], cols
[MONO_PARAM_SEQUENCE
],
171 mono_metadata_string_heap (m
, cols
[MONO_PARAM_NAME
]));
173 fprintf (output
, "\n");
177 dump_table_field (MonoImage
*m
)
179 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FIELD
];
180 MonoTableInfo
*td
= &m
->tables
[MONO_TABLE_TYPEDEF
];
181 MonoTableInfo
*fl
= &m
->tables
[MONO_TABLE_FIELDLAYOUT
];
182 MonoTableInfo
*rva
= &m
->tables
[MONO_TABLE_FIELDRVA
];
183 int i
, current_type
, offset_row
, rva_row
;
184 guint32 first_m
, last_m
;
186 fprintf (output
, "Field Table (1..%d)\n", t
->rows
);
188 rva_row
= offset_row
= current_type
= 1;
189 last_m
= first_m
= 1;
190 for (i
= 1; i
<= t
->rows
; i
++){
191 guint32 cols
[MONO_FIELD_SIZE
];
195 * Find the next type.
197 while (current_type
<= td
->rows
&& i
>= (last_m
= mono_metadata_decode_row_col (td
, current_type
- 1, MONO_TYPEDEF_FIELD_LIST
))) {
201 fprintf (output
, "########## %s.%s\n",
202 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAMESPACE
)),
203 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAME
)));
206 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_FIELD_SIZE
);
207 sig
= get_field_signature (m
, cols
[MONO_FIELD_SIGNATURE
], NULL
);
208 flags
= field_flags (cols
[MONO_FIELD_FLAGS
]);
209 fprintf (output
, "%d: %s %s: %s\n",
212 mono_metadata_string_heap (m
, cols
[MONO_FIELD_NAME
]),
216 if (offset_row
<= fl
->rows
&& (mono_metadata_decode_row_col (fl
, offset_row
- 1, MONO_FIELD_LAYOUT_FIELD
) == i
)) {
217 fprintf (output
, "\texplicit offset: %d\n", mono_metadata_decode_row_col (fl
, offset_row
- 1, MONO_FIELD_LAYOUT_OFFSET
));
220 if (rva_row
<= rva
->rows
&& (mono_metadata_decode_row_col (rva
, rva_row
- 1, MONO_FIELD_RVA_FIELD
) == i
)) {
221 fprintf (output
, "\trva: %d\n", mono_metadata_decode_row_col (rva
, rva_row
- 1, MONO_FIELD_RVA_RVA
));
225 fprintf (output
, "\n");
229 dump_table_memberref (MonoImage
*m
)
231 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MEMBERREF
];
235 const char *blob
, *ks
= NULL
;
237 fprintf (output
, "MemberRef Table (1..%d)\n", t
->rows
);
239 for (i
= 0; i
< t
->rows
; i
++){
240 guint32 cols
[MONO_MEMBERREF_SIZE
];
242 mono_metadata_decode_row (t
, i
, cols
, MONO_MEMBERREF_SIZE
);
244 kind
= cols
[MONO_MEMBERREF_CLASS
] & 7;
245 idx
= cols
[MONO_MEMBERREF_CLASS
] >> 3;
247 x
= g_strdup ("UNHANDLED CASE");
252 xx
= get_typedef (m
, idx
);
253 x
= g_strconcat (xx
, ".", mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]), NULL
);
258 xx
= get_typeref (m
, idx
);
259 x
= g_strconcat (xx
, ".", mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]), NULL
);
263 ks
= "ModuleRef"; break;
266 x
= get_methoddef (m
, idx
);
270 xx
= get_typespec (m
, idx
, FALSE
, NULL
);
271 x
= g_strconcat (xx
, ".", mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]), NULL
);
275 g_error ("Unknown tag: %d\n", kind
);
277 blob
= mono_metadata_blob_heap (m
, cols
[MONO_MEMBERREF_SIGNATURE
]);
278 mono_metadata_decode_blob_size (blob
, &blob
);
279 if (*blob
== 0x6) { /* it's a field */
280 sig
= get_field_signature (m
, cols
[MONO_MEMBERREF_SIGNATURE
], NULL
);
282 sig
= get_methodref_signature (m
, cols
[MONO_MEMBERREF_SIGNATURE
], NULL
);
284 fprintf (output
, "%d: %s[%d] %s\n\tResolved: %s\n\tSignature: %s\n\t\n",
287 mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]),
298 dump_table_class_layout (MonoImage
*m
)
300 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_CLASSLAYOUT
];
302 fprintf (output
, "ClassLayout Table (1..%d)\n", t
->rows
);
304 for (i
= 0; i
< t
->rows
; i
++){
305 guint32 cols
[MONO_CLASS_LAYOUT_SIZE
];
307 mono_metadata_decode_row (t
, i
, cols
, MONO_CLASS_LAYOUT_SIZE
);
309 fprintf (output
, "%d: PackingSize=%d ClassSize=%d Parent=%s\n",
310 i
+ 1, cols
[MONO_CLASS_LAYOUT_PACKING_SIZE
],
311 cols
[MONO_CLASS_LAYOUT_CLASS_SIZE
],
312 get_typedef (m
, cols
[MONO_CLASS_LAYOUT_PARENT
]));
317 dump_table_constant (MonoImage
*m
)
319 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_CONSTANT
];
321 const char *desc
[] = {
327 fprintf (output
, "Constant Table (1..%d)\n", t
->rows
);
329 for (i
= 0; i
< t
->rows
; i
++){
330 guint32 cols
[MONO_CONSTANT_SIZE
];
332 mono_metadata_decode_row (t
, i
, cols
, MONO_CONSTANT_SIZE
);
333 parent
= desc
[cols
[MONO_CONSTANT_PARENT
] & MONO_HASCONSTANT_MASK
];
335 fprintf (output
, "%d: Parent= %s: %d %s\n",
336 i
+ 1, parent
, cols
[MONO_CONSTANT_PARENT
] >> MONO_HASCONSTANT_BITS
,
337 get_constant (m
, (MonoTypeEnum
) cols
[MONO_CONSTANT_TYPE
], cols
[MONO_CONSTANT_VALUE
]));
343 dump_table_property_map (MonoImage
*m
)
345 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_PROPERTYMAP
];
349 fprintf (output
, "Property Map Table (1..%d)\n", t
->rows
);
351 for (i
= 0; i
< t
->rows
; i
++){
352 guint32 cols
[MONO_PROPERTY_MAP_SIZE
];
354 mono_metadata_decode_row (t
, i
, cols
, MONO_PROPERTY_MAP_SIZE
);
355 s
= get_typedef (m
, cols
[MONO_PROPERTY_MAP_PARENT
]);
356 fprintf (output
, "%d: %s (%d) %d\n", i
+ 1, s
, cols
[MONO_PROPERTY_MAP_PARENT
], cols
[MONO_PROPERTY_MAP_PROPERTY_LIST
]);
362 dump_table_property (MonoImage
*m
)
364 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_PROPERTY
];
369 fprintf (output
, "Property Table (1..%d)\n", t
->rows
);
371 for (i
= 0; i
< t
->rows
; i
++){
372 guint32 cols
[MONO_PROPERTY_SIZE
];
376 mono_metadata_decode_row (t
, i
, cols
, MONO_PROPERTY_SIZE
);
378 prop_flags
= cols
[MONO_PROPERTY_FLAGS
];
379 if (prop_flags
& 0x0200)
380 strcat (flags
, "special ");
381 if (prop_flags
& 0x0400)
382 strcat (flags
, "runtime ");
383 if (prop_flags
& 0x1000)
384 strcat (flags
, "hasdefault ");
386 ptr
= mono_metadata_blob_heap (m
, cols
[MONO_PROPERTY_TYPE
]);
387 /* bsize = */ mono_metadata_decode_blob_size (ptr
, &ptr
);
388 /* ECMA claims 0x08 ... */
389 if (*ptr
!= 0x28 && *ptr
!= 0x08)
390 g_warning("incorrect signature in propert blob: 0x%x", *ptr
);
392 pcount
= mono_metadata_decode_value (ptr
, &ptr
);
393 ptr
= get_type (m
, ptr
, &type
, FALSE
, NULL
);
394 fprintf (output
, "%d: %s %s (",
395 i
+ 1, type
, mono_metadata_string_heap (m
, cols
[MONO_PROPERTY_NAME
]));
398 for (j
= 0; j
< pcount
; j
++){
399 ptr
= get_param (m
, ptr
, &type
, NULL
);
400 fprintf (output
, "%s%s", j
> 0? ", " : "",type
);
403 fprintf (output
, ") %s\n", flags
);
408 dump_table_event (MonoImage
*m
)
410 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_EVENT
];
412 fprintf (output
, "Event Table (1..%d)\n", t
->rows
);
414 for (i
= 0; i
< t
->rows
; i
++){
415 guint32 cols
[MONO_EVENT_SIZE
];
419 mono_metadata_decode_row (t
, i
, cols
, MONO_EVENT_SIZE
);
421 name
= mono_metadata_string_heap (m
, cols
[MONO_EVENT_NAME
]);
422 type
= get_typedef_or_ref (m
, cols
[MONO_EVENT_TYPE
], NULL
);
423 fprintf (output
, "%d: %s %s %s\n", i
+ 1, type
, name
,
424 cols
[MONO_EVENT_FLAGS
] & 0x200 ? "specialname " : "");
431 dump_table_file (MonoImage
*m
)
433 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FILE
];
435 fprintf (output
, "File Table (1..%d)\n", t
->rows
);
437 for (i
= 0; i
< t
->rows
; i
++){
438 guint32 cols
[MONO_FILE_SIZE
];
439 const char *name
, *hash
;
441 mono_metadata_decode_row (t
, i
, cols
, MONO_FILE_SIZE
);
443 name
= mono_metadata_string_heap (m
, cols
[MONO_FILE_NAME
]);
444 fprintf (output
, "%d: %s %s [", i
+ 1, name
,
445 cols
[MONO_FILE_FLAGS
] & 0x1 ? "nometadata" : "containsmetadata");
446 hash
= mono_metadata_blob_heap (m
, cols
[MONO_FILE_HASH_VALUE
]);
447 len
= mono_metadata_decode_blob_size (hash
, &hash
);
448 for (j
= 0; j
< len
; ++j
)
449 fprintf (output
, "%s%02X", j
? " ": "", hash
[j
] & 0xff);
450 fprintf (output
, "]\n");
456 get_manifest_implementation (MonoImage
*m
, guint32 idx
)
459 const char* table
= "";
461 return g_strdup ("current module");
462 row
= idx
>> MONO_IMPLEMENTATION_BITS
;
463 switch (idx
& MONO_IMPLEMENTATION_MASK
) {
464 case MONO_IMPLEMENTATION_FILE
:
467 case MONO_IMPLEMENTATION_ASSEMBLYREF
:
468 table
= "assemblyref";
470 case MONO_IMPLEMENTATION_EXP_TYPE
:
471 table
= "exportedtype";
474 g_assert_not_reached ();
476 return g_strdup_printf ("%s %d", table
, row
);
480 get_manifest_flags (guint32 mf
)
484 case 1: return "public";
485 case 2: return "private";
492 dump_table_manifest (MonoImage
*m
)
494 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MANIFESTRESOURCE
];
496 fprintf (output
, "Manifestresource Table (1..%d)\n", t
->rows
);
498 for (i
= 0; i
< t
->rows
; i
++){
499 guint32 cols
[MONO_MANIFEST_SIZE
];
500 const char *name
, *mf
;
503 mono_metadata_decode_row (t
, i
, cols
, MONO_MANIFEST_SIZE
);
505 name
= mono_metadata_string_heap (m
, cols
[MONO_MANIFEST_NAME
]);
506 mf
= get_manifest_flags (cols
[MONO_MANIFEST_FLAGS
]);
507 impl
= get_manifest_implementation (m
, cols
[MONO_MANIFEST_IMPLEMENTATION
]);
508 fprintf (output
, "%d: %s '%s' at offset %u in %s\n", i
+ 1, mf
, name
, cols
[MONO_MANIFEST_OFFSET
], impl
);
515 dump_table_moduleref (MonoImage
*m
)
517 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MODULEREF
];
519 fprintf (output
, "ModuleRef Table (1..%d)\n", t
->rows
);
521 for (i
= 0; i
< t
->rows
; i
++){
522 guint32 cols
[MONO_MODULEREF_SIZE
];
525 mono_metadata_decode_row (t
, i
, cols
, MONO_MODULEREF_SIZE
);
527 name
= mono_metadata_string_heap (m
, cols
[MONO_MODULEREF_NAME
]);
528 fprintf (output
, "%d: %s\n", i
+ 1, name
);
534 dump_table_module (MonoImage
*m
)
536 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MODULE
];
538 fprintf (output
, "Module Table (1..%d)\n", t
->rows
);
540 for (i
= 0; i
< t
->rows
; i
++){
541 guint32 cols
[MONO_MODULE_SIZE
];
545 mono_metadata_decode_row (t
, i
, cols
, MONO_MODULE_SIZE
);
547 name
= mono_metadata_string_heap (m
, cols
[MONO_MODULE_NAME
]);
548 guid
= get_guid (m
, cols
[MONO_MODULE_MVID
]);
549 fprintf (output
, "%d: %s %d %s\n", i
+ 1, name
, cols
[MONO_MODULE_MVID
], guid
);
554 dump_table_method (MonoImage
*m
)
556 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHOD
];
557 MonoTableInfo
*td
= &m
->tables
[MONO_TABLE_TYPEDEF
];
559 guint32 first_m
, last_m
;
560 /* Generic container for Type & method */
561 MonoGenericContainer
*type_container
= NULL
, *method_container
= NULL
;
563 fprintf (output
, "Method Table (1..%d)\n", t
->rows
);
566 last_m
= first_m
= 1;
567 for (i
= 1; i
<= t
->rows
; i
++){
569 guint32 cols
[MONO_METHOD_SIZE
];
570 char *sig
, *impl_flags
;
572 MonoMethodSignature
*method
;
575 * Find the next type.
577 while (current_type
<= td
->rows
&& i
>= (last_m
= mono_metadata_decode_row_col (td
, current_type
- 1, MONO_TYPEDEF_METHOD_LIST
))) {
581 fprintf (output
, "########## %s.%s\n",
582 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAMESPACE
)),
583 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAME
)));
585 type_container
= mono_metadata_load_generic_params (m
, MONO_TOKEN_TYPE_DEF
| (current_type
- 1), NULL
);
586 if (type_container
) {
587 mono_metadata_load_generic_param_constraints_checked (m
, MONO_TOKEN_TYPE_DEF
| (current_type
- 1), type_container
, &error
);
588 g_assert (mono_error_ok (&error
)); /*FIXME don't swallow the error message*/
592 method_container
= mono_metadata_load_generic_params (m
, MONO_TOKEN_METHOD_DEF
| i
, type_container
);
593 if (method_container
) {
594 mono_metadata_load_generic_param_constraints_checked (m
, MONO_TOKEN_METHOD_DEF
| i
, method_container
, &error
);
595 g_assert (mono_error_ok (&error
)); /*FIXME don't swallow the error message*/
597 mono_metadata_decode_table_row (m
, MONO_TABLE_METHOD
, i
- 1, cols
, MONO_METHOD_SIZE
);
598 sigblob
= mono_metadata_blob_heap (m
, cols
[MONO_METHOD_SIGNATURE
]);
599 mono_metadata_decode_blob_size (sigblob
, &sigblob
);
600 method
= mono_metadata_parse_method_signature_full (m
, method_container
? method_container
: type_container
, i
, sigblob
, &sigblob
, &error
);
601 if (!mono_error_ok (&error
)) {
602 fprintf (output
,"%d: failed to parse due to %s\n", i
, mono_error_get_message (&error
));
603 mono_error_cleanup (&error
);
607 g_assert (mono_error_ok (&error
)); /*FIXME don't swallow the error message*/
608 sig
= dis_stringify_method_signature (m
, method
, i
, method_container
? method_container
: type_container
, FALSE
);
609 impl_flags
= get_method_impl_flags (cols
[MONO_METHOD_IMPLFLAGS
]);
610 fprintf (output
, "%d: %s (param: %d impl_flags: %s)\n", i
, sig
, cols
[MONO_METHOD_PARAMLIST
], impl_flags
);
613 mono_metadata_free_method_signature (method
);
619 dump_table_implmap (MonoImage
*m
)
621 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_IMPLMAP
];
622 MonoTableInfo
*td
= &m
->tables
[MONO_TABLE_MODULEREF
];
625 fprintf (output
, "ImplMap Table (1..%d)\n", t
->rows
);
627 for (i
= 1; i
<= t
->rows
; i
++){
628 guint32 cols
[MONO_IMPLMAP_SIZE
];
631 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_IMPLMAP_SIZE
);
633 method
= get_method (m
, MONO_TOKEN_METHOD_DEF
| (cols
[MONO_IMPLMAP_MEMBER
] >> MONO_MEMBERFORWD_BITS
), NULL
);
635 fprintf (output
, "%d: %s %d (%s %s)\n", i
,
637 cols
[MONO_IMPLMAP_FLAGS
],
638 mono_metadata_string_heap (m
, cols
[MONO_IMPLMAP_NAME
]),
639 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, cols
[MONO_IMPLMAP_SCOPE
] - 1, MONO_MODULEREF_NAME
)));
644 dump_table_fieldrva (MonoImage
*m
)
646 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FIELDRVA
];
649 fprintf (output
, "FieldRVA Table (1..%d)\n", t
->rows
);
651 for (i
= 1; i
<= t
->rows
; i
++){
652 guint32 cols
[MONO_FIELD_RVA_SIZE
];
654 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_FIELD_RVA_SIZE
);
655 fprintf (output
, "%d: Field %d: %x\n", i
, cols
[MONO_FIELD_RVA_FIELD
], cols
[MONO_FIELD_RVA_RVA
]);
660 dump_table_methodimpl (MonoImage
*m
)
662 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHODIMPL
];
663 /*MonoTableInfo *td = &m->tables [MONO_TABLE_TYPEDEF];*/
666 fprintf (output
, "MethodImpl Table (1..%d)\n", t
->rows
);
668 for (i
= 1; i
<= t
->rows
; i
++){
669 guint32 cols
[MONO_METHODIMPL_SIZE
];
670 char *klass
, *impl
, *decl
;
672 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHODIMPL_SIZE
);
673 klass
= get_typedef (m
, cols
[MONO_METHODIMPL_CLASS
]);
674 impl
= get_method (m
, method_dor_to_token (cols
[MONO_METHODIMPL_BODY
]), NULL
);
675 decl
= get_method (m
, method_dor_to_token (cols
[MONO_METHODIMPL_DECLARATION
]), NULL
);
676 fprintf (output
, "%d: %s\n\tdecl: %s\n\timpl: %s\n", i
, klass
, decl
, impl
);
684 static dis_map_t semantics_map
[] = {
695 dump_table_methodsem (MonoImage
*m
)
697 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHODSEMANTICS
];
698 int i
, is_property
, index
;
699 const char *semantics
;
701 fprintf (output
, "Method Semantics Table (1..%d)\n", t
->rows
);
702 for (i
= 1; i
<= t
->rows
; i
++){
703 guint32 cols
[MONO_METHOD_SEMA_SIZE
];
705 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHOD_SEMA_SIZE
);
706 semantics
= flags (cols
[MONO_METHOD_SEMA_SEMANTICS
], semantics_map
);
707 is_property
= cols
[MONO_METHOD_SEMA_ASSOCIATION
] & MONO_HAS_SEMANTICS_MASK
;
708 index
= cols
[MONO_METHOD_SEMA_ASSOCIATION
] >> MONO_HAS_SEMANTICS_BITS
;
709 fprintf (output
, "%d: [%d] %s method: %d %s %d\n", i
, cols
[MONO_METHOD_SEMA_ASSOCIATION
], semantics
,
710 cols
[MONO_METHOD_SEMA_METHOD
] - 1,
711 is_property
? "property" : "event",
717 dump_table_interfaceimpl (MonoImage
*m
)
719 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_INTERFACEIMPL
];
722 fprintf (output
, "Interface Implementation Table (1..%d)\n", t
->rows
);
723 for (i
= 1; i
<= t
->rows
; i
++) {
724 guint32 cols
[MONO_INTERFACEIMPL_SIZE
];
726 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_INTERFACEIMPL_SIZE
);
727 fprintf (output
, "%d: %s implements %s\n", i
,
728 get_typedef (m
, cols
[MONO_INTERFACEIMPL_CLASS
]),
729 get_typedef_or_ref (m
, cols
[MONO_INTERFACEIMPL_INTERFACE
], NULL
));
734 has_cattr_get_table (MonoImage
*m
, guint32 val
)
736 guint32 t
= val
& MONO_CUSTOM_ATTR_MASK
;
737 guint32 index
= val
>> MONO_CUSTOM_ATTR_BITS
;
741 case MONO_CUSTOM_ATTR_METHODDEF
:
744 case MONO_CUSTOM_ATTR_FIELDDEF
:
747 case MONO_CUSTOM_ATTR_TYPEREF
:
750 case MONO_CUSTOM_ATTR_TYPEDEF
:
753 case MONO_CUSTOM_ATTR_PARAMDEF
:
756 case MONO_CUSTOM_ATTR_INTERFACE
:
757 table
= "InterfaceImpl";
759 case MONO_CUSTOM_ATTR_MEMBERREF
:
762 case MONO_CUSTOM_ATTR_MODULE
:
765 case MONO_CUSTOM_ATTR_PERMISSION
:
766 table
= "DeclSecurity?";
768 case MONO_CUSTOM_ATTR_PROPERTY
:
771 case MONO_CUSTOM_ATTR_EVENT
:
774 case MONO_CUSTOM_ATTR_SIGNATURE
:
775 table
= "StandAloneSignature";
777 case MONO_CUSTOM_ATTR_MODULEREF
:
780 case MONO_CUSTOM_ATTR_TYPESPEC
:
783 case MONO_CUSTOM_ATTR_ASSEMBLY
:
786 case MONO_CUSTOM_ATTR_ASSEMBLYREF
:
787 table
= "AssemblyRef";
789 case MONO_CUSTOM_ATTR_FILE
:
792 case MONO_CUSTOM_ATTR_EXP_TYPE
:
793 table
= "ExportedType";
795 case MONO_CUSTOM_ATTR_MANIFEST
:
798 case MONO_CUSTOM_ATTR_GENERICPAR
:
799 table
= "GenericParam";
806 * FIXME: we should decode the index into something more uman-friendly.
808 return g_strdup_printf ("%s: %d", table
, index
);
812 custom_attr_params (MonoImage
*m
, MonoMethodSignature
* sig
, const char* value
)
814 int len
, i
, slen
, type
;
817 const char *p
= value
;
819 len
= mono_metadata_decode_value (p
, &p
);
820 if (len
< 2 || read16 (p
) != 0x0001) /* Prolog */
821 return g_strdup ("");
825 res
= g_string_new ("");
826 for (i
= 0; i
< sig
->param_count
; ++i
) {
828 g_string_append (res
, ", ");
829 type
= sig
->params
[i
]->type
;
833 g_string_append_printf (res
, "%d", (unsigned int)*p
);
837 g_string_append_printf (res
, "%d", *p
);
840 case MONO_TYPE_BOOLEAN
:
841 g_string_append_printf (res
, "%s", *p
?"true":"false");
845 g_string_append_printf (res
, "'%c'", read16 (p
));
849 g_string_append_printf (res
, "%d", read16 (p
));
853 g_string_append_printf (res
, "%d", (gint16
)read16 (p
));
857 g_string_append_printf (res
, "%d", read32 (p
));
861 g_string_append_printf (res
, "%d", (gint32
)read32 (p
));
865 g_string_append_printf (res
, "%lld", (long long)read64 (p
));
869 g_string_append_printf (res
, "%lld", (long long)read64 (p
));
876 inf
= dis_isinf (val
);
878 g_string_append_printf (res
, "(00 00 80 ff)"); /* negative infinity */
880 g_string_append_printf (res
, "(00 00 80 7f)"); /* positive infinity */
881 else if (dis_isnan (val
))
882 g_string_append_printf (res
, "(00 00 c0 ff)"); /* NaN */
884 g_string_append_printf (res
, "%g", val
);
893 inf
= dis_isinf (val
);
895 g_string_append_printf (res
, "(00 00 00 00 00 00 f0 ff)"); /* negative infinity */
897 g_string_append_printf (res
, "(00 00 00 00 00 00 f0 7f)"); /* positive infinity */
898 else if (isnan (val
))
899 g_string_append_printf (res
, "(00 00 00 00 00 00 f8 ff)"); /* NaN */
901 g_string_append_printf (res
, "%g", val
);
905 case MONO_TYPE_VALUETYPE
:
906 if (mono_class_is_enum (sig
->params
[i
]->data
.klass
)) {
907 type
= mono_class_enum_basetype (sig
->params
[i
]->data
.klass
)->type
;
910 g_warning ("generic valutype not handled in custom attr value decoding");
913 case MONO_TYPE_CLASS
: /* It must be a Type: check? */
914 case MONO_TYPE_STRING
:
915 if (*p
== (char)0xff) {
916 g_string_append (res
, "null");
920 slen
= mono_metadata_decode_value (p
, &p
);
921 g_string_append_c (res
, '"');
922 g_string_append (res
, p
);
923 g_string_append_c (res
, '"');
927 g_warning ("Type %02x not handled in custom attr value decoding", sig
->params
[i
]->type
);
933 g_string_append_printf (res
, " %d named args: (", slen
);
934 slen
= len
- (p
- value
) + 1;
935 for (i
= 0; i
< slen
; ++i
) {
936 g_string_append_printf (res
, " %02X", (p
[i
] & 0xff));
938 g_string_append_c (res
, ')');
941 g_string_free (res
, FALSE
);
946 dump_table_customattr (MonoImage
*m
)
948 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_CUSTOMATTRIBUTE
];
951 fprintf (output
, "Custom Attributes Table (1..%d)\n", t
->rows
);
952 for (i
= 1; i
<= t
->rows
; i
++) {
954 guint32 cols
[MONO_CUSTOM_ATTR_SIZE
];
961 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_CUSTOM_ATTR_SIZE
);
962 desc
= has_cattr_get_table (m
, cols
[MONO_CUSTOM_ATTR_PARENT
]);
963 mtoken
= cols
[MONO_CUSTOM_ATTR_TYPE
] >> MONO_CUSTOM_ATTR_TYPE_BITS
;
964 switch (cols
[MONO_CUSTOM_ATTR_TYPE
] & MONO_CUSTOM_ATTR_TYPE_MASK
) {
965 case MONO_CUSTOM_ATTR_TYPE_METHODDEF
:
966 mtoken
|= MONO_TOKEN_METHOD_DEF
;
968 case MONO_CUSTOM_ATTR_TYPE_MEMBERREF
:
969 mtoken
|= MONO_TOKEN_MEMBER_REF
;
972 g_warning ("Unknown table for custom attr type %08x", cols
[MONO_CUSTOM_ATTR_TYPE
]);
975 method
= get_method (m
, mtoken
, NULL
);
976 meth
= mono_get_method_checked (m
, mtoken
, NULL
, NULL
, &error
);
978 params
= custom_attr_params (m
, mono_method_signature (meth
), mono_metadata_blob_heap (m
, cols
[MONO_CUSTOM_ATTR_VALUE
]));
979 fprintf (output
, "%d: %s: %s [%s]\n", i
, desc
, method
, params
);
982 fprintf (output
, "Could not decode method due to %s", mono_error_get_message (&error
));
983 mono_error_cleanup (&error
);
992 dump_table_nestedclass (MonoImage
*m
)
994 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_NESTEDCLASS
];
995 guint32 cols
[MONO_NESTED_CLASS_SIZE
];
997 char *nested
, *nesting
;
998 fprintf (output
, "NestedClass Table (1..%d)\n", t
->rows
);
1000 for (i
= 1; i
<= t
->rows
; i
++){
1001 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_NESTED_CLASS_SIZE
);
1002 nested
= get_typedef (m
, cols
[MONO_NESTED_CLASS_NESTED
]);
1003 nesting
= get_typedef (m
, cols
[MONO_NESTED_CLASS_ENCLOSING
]);
1004 fprintf (output
, "%d: %d %d: %s in %s\n", i
,
1005 cols
[MONO_NESTED_CLASS_NESTED
],
1006 cols
[MONO_NESTED_CLASS_ENCLOSING
], nested
, nesting
);
1014 dump_table_exported (MonoImage
*m
)
1016 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_EXPORTEDTYPE
];
1017 guint32 cols
[MONO_EXP_TYPE_SIZE
];
1019 const char *name
, *nspace
;
1021 guint32 index
, flags
;
1022 fprintf (output
, "ExportedType Table (1..%d)\n", t
->rows
);
1024 for (i
= 1; i
<= t
->rows
; i
++) {
1025 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_EXP_TYPE_SIZE
);
1026 name
= mono_metadata_string_heap (m
, cols
[MONO_EXP_TYPE_NAME
]);
1027 nspace
= mono_metadata_string_heap (m
, cols
[MONO_EXP_TYPE_NAMESPACE
]);
1028 impl
= get_manifest_implementation (m
, cols
[MONO_EXP_TYPE_IMPLEMENTATION
]);
1029 index
= cols
[MONO_EXP_TYPE_TYPEDEF
];
1030 flags
= cols
[MONO_EXP_TYPE_FLAGS
];
1031 fprintf (output
, "%d: %s%s%s is in %s, index=%x, flags=0x%x\n", i
, nspace
, *nspace
? "." : "", name
, impl
, index
, flags
);
1038 dump_blob (MonoImage
*m
, const char* blob
)
1042 bsize
= mono_metadata_decode_blob_size (blob
, &blob
);
1044 for (j
= 0; j
< bsize
; j
++) {
1045 fprintf (output
, "%02x ", blob
[j
] & 0xff);
1050 dump_table_field_marshal (MonoImage
*m
)
1052 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FIELDMARSHAL
];
1053 guint32 cols
[MONO_FIELD_MARSHAL_SIZE
];
1054 int i
, is_field
, idx
;
1058 fprintf (output
, "FieldMarshal Table (1..%d)\n", t
->rows
);
1060 for (i
= 1; i
<= t
->rows
; i
++) {
1061 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_FIELD_MARSHAL_SIZE
);
1062 blob
= mono_metadata_blob_heap (m
, cols
[MONO_FIELD_MARSHAL_NATIVE_TYPE
]);
1063 native
= get_marshal_info (m
, blob
);
1064 is_field
= (cols
[MONO_FIELD_MARSHAL_PARENT
] & MONO_HAS_FIELD_MARSHAL_MASK
) == MONO_HAS_FIELD_MARSHAL_FIELDSREF
;
1065 idx
= cols
[MONO_FIELD_MARSHAL_PARENT
] >> MONO_HAS_FIELD_MARSHAL_BITS
;
1066 fprintf (output
, "%d: (0x%04x) %s %d: %s\n", i
, cols
[MONO_FIELD_MARSHAL_PARENT
], is_field
? "Field" : "Param", idx
, native
);
1067 fprintf (output
, "\tblob encoding: ");
1068 dump_blob (m
, blob
);
1069 fprintf (output
, "\n");
1076 get_security_action (int val
) {
1077 static char buf
[32];
1080 case SECURITY_ACTION_DEMAND
:
1082 case SECURITY_ACTION_ASSERT
:
1084 case SECURITY_ACTION_DENY
:
1086 case SECURITY_ACTION_PERMITONLY
:
1087 return "PermitOnly";
1088 case SECURITY_ACTION_LINKDEMAND
:
1089 return "LinkDemand";
1090 case SECURITY_ACTION_INHERITDEMAND
:
1091 return "InheritanceDemand";
1092 case SECURITY_ACTION_REQMIN
:
1093 return "RequestMinimum";
1094 case SECURITY_ACTION_REQOPT
:
1095 return "RequestOptional";
1096 case SECURITY_ACTION_REQREFUSE
:
1097 return "RequestRefuse";
1098 /* Special actions (for non CAS permissions) */
1099 case SECURITY_ACTION_NONCASDEMAND
:
1100 return "NonCasDemand";
1101 case SECURITY_ACTION_NONCASLINKDEMAND
:
1102 return "NonCasLinkDemand";
1103 case SECURITY_ACTION_NONCASINHERITANCE
:
1104 return "NonCasInheritance";
1105 /* Fx 2.0 actions (for both CAS and non-CAS permissions) */
1106 case SECURITY_ACTION_LINKDEMANDCHOICE
:
1107 return "LinkDemandChoice";
1108 case SECURITY_ACTION_INHERITDEMANDCHOICE
:
1109 return "InheritanceDemandChoice";
1110 case SECURITY_ACTION_DEMANDCHOICE
:
1111 return "DemandChoice";
1113 g_snprintf (buf
, sizeof (buf
), "0x%04X", val
);
1119 dump_table_declsec (MonoImage
*m
)
1121 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_DECLSECURITY
];
1122 guint32 cols
[MONO_DECL_SECURITY_SIZE
];
1125 const char *blob
, *action
;
1126 const char* parent
[] = {
1127 "TypeDef", "MethodDef", "Assembly", ""
1130 fprintf (output
, "DeclSecurity Table (1..%d)\n", t
->rows
);
1132 for (i
= 1; i
<= t
->rows
; i
++) {
1133 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_DECL_SECURITY_SIZE
);
1134 blob
= mono_metadata_blob_heap (m
, cols
[MONO_DECL_SECURITY_PERMISSIONSET
]);
1135 len
= mono_metadata_decode_blob_size (blob
, &blob
);
1136 action
= get_security_action (cols
[MONO_DECL_SECURITY_ACTION
]);
1137 idx
= cols
[MONO_DECL_SECURITY_PARENT
];
1138 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");
1141 if (blob
[0] == MONO_DECLSEC_FORMAT_20
) {
1142 /* 2.0 declarative security format */
1143 char *declsec
= dump_declsec_entry20 (m
, blob
, "\t");
1144 fprintf (output
, "%s", declsec
);
1147 /* 1.0 declarative security format - Unicode XML */
1148 for (idx
= 0; idx
< len
; ++idx
)
1149 fprintf (output
, "%c", blob
[idx
]);
1151 fprintf (output
, "\n");
1156 dump_table_genericpar (MonoImage
*m
)
1158 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_GENERICPARAM
];
1159 guint32 cols
[MONO_GENERICPARAM_SIZE
];
1162 fprintf (output
, "GenericParameters (1..%d)\n", t
->rows
);
1164 for (i
= 1; i
<= t
->rows
; i
++) {
1166 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_GENERICPARAM_SIZE
);
1168 // sig = get_type_or_methdef (m, cols [MONO_GENERICPARAM_OWNER]);
1169 sig
= g_strdup_printf ("%x", cols
[MONO_GENERICPARAM_OWNER
]);
1170 fprintf (output
, "%d: %d, flags=%d, owner=%s %s\n", i
,
1171 cols
[MONO_GENERICPARAM_NUMBER
],
1172 cols
[MONO_GENERICPARAM_FLAGS
], sig
,
1173 mono_metadata_string_heap (m
, cols
[MONO_GENERICPARAM_NAME
]));
1179 dump_table_methodspec (MonoImage
*m
)
1181 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHODSPEC
];
1182 guint32 cols
[MONO_METHODSPEC_SIZE
];
1185 fprintf (output
, "MethodSpec (1..%d)\n", t
->rows
);
1187 for (i
= 1; i
<= t
->rows
; i
++) {
1192 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHODSPEC_SIZE
);
1194 /* build a methodspec token to get the method */
1195 token
= MONO_TOKEN_METHOD_SPEC
| i
;
1196 method
= get_method (m
, token
, NULL
);
1198 sig
= get_method_type_param (m
, cols
[MONO_METHODSPEC_SIGNATURE
], NULL
);
1199 fprintf (output
, "%d: %s, %s\n", i
, method
, sig
);
1206 dump_table_parconstraint (MonoImage
*m
)
1208 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_GENERICPARAMCONSTRAINT
];
1209 guint32 cols
[MONO_GENPARCONSTRAINT_SIZE
];
1212 fprintf (output
, "Generic Param Constraint (1..%d)\n", t
->rows
);
1214 for (i
= 1; i
<= t
->rows
; i
++) {
1216 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_GENPARCONSTRAINT_SIZE
);
1218 // sig = get_typedef_or_ref (m, cols [MONO_GENPARCONSTRAINT_CONSTRAINT], NULL);
1219 sig
= g_strdup_printf ("%x", cols
[MONO_GENPARCONSTRAINT_CONSTRAINT
]);
1220 fprintf (output
, "%d: gen-par=%d, Constraint=%s\n", i
,
1221 cols
[MONO_GENPARCONSTRAINT_GENERICPAR
], sig
);
1227 dump_stream_blob (MonoImage
*m
)
1231 fprintf (output
, "Blob heap contents\n");
1233 for (i
= 0; i
< m
->heap_blob
.size
; i
++) {
1236 fprintf (output
, "\n");
1237 else if ((i
% 8) == 0)
1238 fprintf (output
, "- ");
1240 fprintf (output
, "%02x ", m
->heap_blob
.data
[i
] & 0xff);
1243 fprintf (output
, "\n");
1247 dump_stream_strings (MonoImage
*m
)
1251 fprintf (output
, "Strings heap contents\n");
1253 for (i
= 0; i
< m
->heap_strings
.size
; ) {
1254 const char *str
= mono_metadata_string_heap (m
, i
);
1255 fprintf (output
, "%02x: \"%s\"\n", i
, str
);
1256 i
+= strlen (str
) + 1;
1261 dump_stream_us (MonoImage
*m
)
1265 fprintf (output
, "User Strings heap contents\n");
1267 for (i
= 0; i
< m
->heap_us
.size
; ) {
1268 const char *us_ptr
= mono_metadata_user_string (m
, i
);
1269 int len
= mono_metadata_decode_blob_size (us_ptr
, (const char**)&us_ptr
);
1271 char *str
= get_encoded_user_string_or_bytearray ((const guchar
*)us_ptr
, len
);
1272 fprintf (output
, "%02x: %s\n", i
, str
);
1279 dump_table_standalonesig (MonoImage
*m
)
1281 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_STANDALONESIG
];
1282 guint32 cols
[MONO_STAND_ALONE_SIGNATURE_SIZE
];
1285 fprintf (output
, "Stand alone signature (1..%d)\n", t
->rows
);
1287 for (i
= 1; i
<= t
->rows
; i
++) {
1288 const char *locals_ptr
;
1291 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_STAND_ALONE_SIGNATURE_SIZE
);
1293 locals_ptr
= mono_metadata_blob_heap (m
, cols
[MONO_STAND_ALONE_SIGNATURE
]);
1294 bsize
= mono_metadata_decode_blob_size (locals_ptr
, &locals_ptr
);
1296 fprintf (output
, "%d: blob[0x%x] = ", i
, cols
[MONO_STAND_ALONE_SIGNATURE
]);
1298 for (j
= 0; j
< bsize
; j
++) {
1299 fprintf (output
, "%02x ", locals_ptr
[j
] & 0xff);
1301 fprintf (output
, "\n");
1306 dump_table_ptr (MonoImage
*m
, int table
, const char *name
)
1308 MonoTableInfo
*t
= &m
->tables
[table
];
1312 fprintf (output
, "%s (1..%d)\n", name
, t
->rows
);
1314 for (i
= 1; i
<= t
->rows
; i
++) {
1315 mono_metadata_decode_row (t
, i
- 1, cols
, 1);
1317 fprintf (output
, "%d: %d\n", i
, cols
[0]);
1322 dump_table_methodptr (MonoImage
*m
)
1324 dump_table_ptr (m
, MONO_TABLE_METHOD_POINTER
, "Method Ptr");
1328 dump_table_fieldptr (MonoImage
*m
)
1330 dump_table_ptr (m
, MONO_TABLE_FIELD_POINTER
, "Field Ptr");
1334 dump_table_paramptr (MonoImage
*m
)
1336 dump_table_ptr (m
, MONO_TABLE_PARAM_POINTER
, "Param Ptr");
1340 dump_table_eventptr (MonoImage
*m
)
1342 dump_table_ptr (m
, MONO_TABLE_EVENT_POINTER
, "Event Ptr");
1346 dump_table_propertyptr (MonoImage
*m
)
1348 dump_table_ptr (m
, MONO_TABLE_PROPERTY_POINTER
, "Property Ptr");