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"
27 extern int isinf (double);
33 dump_table_assembly (MonoImage
*m
)
35 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_ASSEMBLY
];
36 guint32 cols
[MONO_ASSEMBLY_SIZE
];
40 fprintf (output
, "Assembly Table\n");
45 mono_metadata_decode_row (t
, 0, cols
, MONO_ASSEMBLY_SIZE
);
47 fprintf (output
, "Name: %s\n", mono_metadata_string_heap (m
, cols
[MONO_ASSEMBLY_NAME
]));
48 fprintf (output
, "Hash Algoritm: 0x%08x\n", cols
[MONO_ASSEMBLY_HASH_ALG
]);
49 fprintf (output
, "Version: %d.%d.%d.%d\n", cols
[MONO_ASSEMBLY_MAJOR_VERSION
],
50 cols
[MONO_ASSEMBLY_MINOR_VERSION
],
51 cols
[MONO_ASSEMBLY_BUILD_NUMBER
],
52 cols
[MONO_ASSEMBLY_REV_NUMBER
]);
53 fprintf (output
, "Flags: 0x%08x\n", cols
[MONO_ASSEMBLY_FLAGS
]);
54 fprintf (output
, "PublicKey: BlobPtr (0x%08x)\n", cols
[MONO_ASSEMBLY_PUBLIC_KEY
]);
56 ptr
= mono_metadata_blob_heap (m
, cols
[MONO_ASSEMBLY_PUBLIC_KEY
]);
57 len
= mono_metadata_decode_value (ptr
, &ptr
);
59 fprintf (output
, "\tDump:");
60 hex_dump (ptr
, 0, len
);
61 fprintf (output
, "\n");
63 fprintf (output
, "\tZero sized public key\n");
65 fprintf (output
, "Culture: %s\n", mono_metadata_string_heap (m
, cols
[MONO_ASSEMBLY_CULTURE
]));
66 fprintf (output
, "\n");
70 dump_table_typeref (MonoImage
*m
)
72 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_TYPEREF
];
75 fprintf (output
, "Typeref Table\n");
77 for (i
= 1; i
<= t
->rows
; i
++){
78 char *s
= get_typeref (m
, i
);
80 fprintf (output
, "%d: %s\n", i
, s
);
83 fprintf (output
, "\n");
87 dump_table_typedef (MonoImage
*m
)
89 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_TYPEDEF
];
92 fprintf (output
, "Typedef Table\n");
94 for (i
= 1; i
<= t
->rows
; i
++){
95 char *s
= get_typedef (m
, i
);
96 guint32 cols
[MONO_TYPEDEF_SIZE
];
98 mono_metadata_decode_row (&m
->tables
[MONO_TABLE_TYPEDEF
], i
- 1, cols
, MONO_TYPEDEF_SIZE
);
100 fprintf (output
, "%d: %s (flist=%d, mlist=%d, flags=0x%x, extends=0x%x)\n", i
, s
,
101 cols
[MONO_TYPEDEF_FIELD_LIST
], cols
[MONO_TYPEDEF_METHOD_LIST
],
102 cols
[MONO_TYPEDEF_FLAGS
], cols
[MONO_TYPEDEF_EXTENDS
]);
105 fprintf (output
, "\n");
109 dump_table_typespec (MonoImage
*m
)
111 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_TYPESPEC
];
114 fprintf (output
, "Typespec Table\n");
116 for (i
= 1; i
<= t
->rows
; i
++){
117 char *typespec
= get_typespec (m
, i
, TRUE
, NULL
);
119 fprintf (output
, "%d: %s\n", i
, typespec
);
122 fprintf (output
, "\n");
126 dump_table_assemblyref (MonoImage
*m
)
128 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_ASSEMBLYREF
];
131 fprintf (output
, "AssemblyRef Table\n");
133 for (i
= 0; i
< t
->rows
; i
++){
136 guint32 cols
[MONO_ASSEMBLYREF_SIZE
];
138 mono_metadata_decode_row (t
, i
, cols
, MONO_ASSEMBLYREF_SIZE
);
139 fprintf (output
, "%d: Version=%d.%d.%d.%d\n\tName=%s\n", i
+ 1,
140 cols
[MONO_ASSEMBLYREF_MAJOR_VERSION
],
141 cols
[MONO_ASSEMBLYREF_MINOR_VERSION
],
142 cols
[MONO_ASSEMBLYREF_BUILD_NUMBER
],
143 cols
[MONO_ASSEMBLYREF_REV_NUMBER
],
144 mono_metadata_string_heap (m
, cols
[MONO_ASSEMBLYREF_NAME
]));
145 fprintf (output
, "\tFlags=0x%08x\n", cols
[MONO_ASSEMBLYREF_FLAGS
]);
146 ptr
= mono_metadata_blob_heap (m
, cols
[MONO_ASSEMBLYREF_PUBLIC_KEY
]);
147 len
= mono_metadata_decode_value (ptr
, &ptr
);
149 fprintf (output
, "\tPublic Key:");
150 hex_dump (ptr
, 0, len
);
151 fprintf (output
, "\n");
153 fprintf (output
, "\tZero sized public key\n");
156 fprintf (output
, "\n");
160 dump_table_param (MonoImage
*m
)
162 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_PARAM
];
165 fprintf (output
, "Param Table\n");
167 for (i
= 0; i
< t
->rows
; i
++){
168 guint32 cols
[MONO_PARAM_SIZE
];
170 mono_metadata_decode_row (t
, i
, cols
, MONO_PARAM_SIZE
);
171 fprintf (output
, "%d: 0x%04x %d %s\n",
173 cols
[MONO_PARAM_FLAGS
], cols
[MONO_PARAM_SEQUENCE
],
174 mono_metadata_string_heap (m
, cols
[MONO_PARAM_NAME
]));
176 fprintf (output
, "\n");
180 dump_table_field (MonoImage
*m
)
182 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FIELD
];
183 MonoTableInfo
*td
= &m
->tables
[MONO_TABLE_TYPEDEF
];
184 MonoTableInfo
*fl
= &m
->tables
[MONO_TABLE_FIELDLAYOUT
];
185 MonoTableInfo
*rva
= &m
->tables
[MONO_TABLE_FIELDRVA
];
186 int i
, current_type
, offset_row
, rva_row
;
187 guint32 first_m
, last_m
;
189 fprintf (output
, "Field Table (1..%d)\n", t
->rows
);
191 rva_row
= offset_row
= current_type
= 1;
192 last_m
= first_m
= 1;
193 for (i
= 1; i
<= t
->rows
; i
++){
194 guint32 cols
[MONO_FIELD_SIZE
];
198 * Find the next type.
200 while (current_type
<= td
->rows
&& i
>= (last_m
= mono_metadata_decode_row_col (td
, current_type
- 1, MONO_TYPEDEF_FIELD_LIST
))) {
204 fprintf (output
, "########## %s.%s\n",
205 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAMESPACE
)),
206 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAME
)));
209 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_FIELD_SIZE
);
210 sig
= get_field_signature (m
, cols
[MONO_FIELD_SIGNATURE
], NULL
);
211 flags
= field_flags (cols
[MONO_FIELD_FLAGS
]);
212 fprintf (output
, "%d: %s %s: %s\n",
215 mono_metadata_string_heap (m
, cols
[MONO_FIELD_NAME
]),
219 if (offset_row
<= fl
->rows
&& (mono_metadata_decode_row_col (fl
, offset_row
- 1, MONO_FIELD_LAYOUT_FIELD
) == i
)) {
220 fprintf (output
, "\texplicit offset: %d\n", mono_metadata_decode_row_col (fl
, offset_row
- 1, MONO_FIELD_LAYOUT_OFFSET
));
223 if (rva_row
<= rva
->rows
&& (mono_metadata_decode_row_col (rva
, rva_row
- 1, MONO_FIELD_RVA_FIELD
) == i
)) {
224 fprintf (output
, "\trva: %d\n", mono_metadata_decode_row_col (rva
, rva_row
- 1, MONO_FIELD_RVA_RVA
));
228 fprintf (output
, "\n");
232 dump_table_memberref (MonoImage
*m
)
234 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MEMBERREF
];
238 const char *blob
, *ks
= NULL
;
240 fprintf (output
, "MemberRef Table (1..%d)\n", t
->rows
);
242 for (i
= 0; i
< t
->rows
; i
++){
243 guint32 cols
[MONO_MEMBERREF_SIZE
];
245 mono_metadata_decode_row (t
, i
, cols
, MONO_MEMBERREF_SIZE
);
247 kind
= cols
[MONO_MEMBERREF_CLASS
] & 7;
248 idx
= cols
[MONO_MEMBERREF_CLASS
] >> 3;
250 x
= g_strdup ("UNHANDLED CASE");
255 xx
= get_typedef (m
, idx
);
256 x
= g_strconcat (xx
, ".", mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]), NULL
);
261 xx
= get_typeref (m
, idx
);
262 x
= g_strconcat (xx
, ".", mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]), NULL
);
266 ks
= "ModuleRef"; break;
269 x
= get_methoddef (m
, idx
);
273 xx
= get_typespec (m
, idx
, FALSE
, NULL
);
274 x
= g_strconcat (xx
, ".", mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]), NULL
);
278 g_error ("Unknown tag: %d\n", kind
);
280 blob
= mono_metadata_blob_heap (m
, cols
[MONO_MEMBERREF_SIGNATURE
]);
281 mono_metadata_decode_blob_size (blob
, &blob
);
282 if (*blob
== 0x6) { /* it's a field */
283 sig
= get_field_signature (m
, cols
[MONO_MEMBERREF_SIGNATURE
], NULL
);
285 sig
= get_methodref_signature (m
, cols
[MONO_MEMBERREF_SIGNATURE
], NULL
);
287 fprintf (output
, "%d: %s[%d] %s\n\tResolved: %s\n\tSignature: %s\n\t\n",
290 mono_metadata_string_heap (m
, cols
[MONO_MEMBERREF_NAME
]),
301 dump_table_class_layout (MonoImage
*m
)
303 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_CLASSLAYOUT
];
305 fprintf (output
, "ClassLayout Table (1..%d)\n", t
->rows
);
307 for (i
= 0; i
< t
->rows
; i
++){
308 guint32 cols
[MONO_CLASS_LAYOUT_SIZE
];
310 mono_metadata_decode_row (t
, i
, cols
, MONO_CLASS_LAYOUT_SIZE
);
312 fprintf (output
, "%d: PackingSize=%d ClassSize=%d Parent=%s\n",
313 i
+ 1, cols
[MONO_CLASS_LAYOUT_PACKING_SIZE
],
314 cols
[MONO_CLASS_LAYOUT_CLASS_SIZE
],
315 get_typedef (m
, cols
[MONO_CLASS_LAYOUT_PARENT
]));
320 dump_table_constant (MonoImage
*m
)
322 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_CONSTANT
];
324 const char *desc
[] = {
330 fprintf (output
, "Constant Table (1..%d)\n", t
->rows
);
332 for (i
= 0; i
< t
->rows
; i
++){
333 guint32 cols
[MONO_CONSTANT_SIZE
];
335 mono_metadata_decode_row (t
, i
, cols
, MONO_CONSTANT_SIZE
);
336 parent
= desc
[cols
[MONO_CONSTANT_PARENT
] & MONO_HASCONSTANT_MASK
];
338 fprintf (output
, "%d: Parent= %s: %d %s\n",
339 i
+ 1, parent
, cols
[MONO_CONSTANT_PARENT
] >> MONO_HASCONSTANT_BITS
,
340 get_constant (m
, (MonoTypeEnum
) cols
[MONO_CONSTANT_TYPE
], cols
[MONO_CONSTANT_VALUE
]));
346 dump_table_property_map (MonoImage
*m
)
348 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_PROPERTYMAP
];
352 fprintf (output
, "Property Map Table (1..%d)\n", t
->rows
);
354 for (i
= 0; i
< t
->rows
; i
++){
355 guint32 cols
[MONO_PROPERTY_MAP_SIZE
];
357 mono_metadata_decode_row (t
, i
, cols
, MONO_PROPERTY_MAP_SIZE
);
358 s
= get_typedef (m
, cols
[MONO_PROPERTY_MAP_PARENT
]);
359 fprintf (output
, "%d: %s (%d) %d\n", i
+ 1, s
, cols
[MONO_PROPERTY_MAP_PARENT
], cols
[MONO_PROPERTY_MAP_PROPERTY_LIST
]);
365 dump_table_property (MonoImage
*m
)
367 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_PROPERTY
];
372 fprintf (output
, "Property Table (1..%d)\n", t
->rows
);
374 for (i
= 0; i
< t
->rows
; i
++){
375 guint32 cols
[MONO_PROPERTY_SIZE
];
380 mono_metadata_decode_row (t
, i
, cols
, MONO_PROPERTY_SIZE
);
382 prop_flags
= cols
[MONO_PROPERTY_FLAGS
];
383 if (prop_flags
& 0x0200)
384 strcat (flags
, "special ");
385 if (prop_flags
& 0x0400)
386 strcat (flags
, "runtime ");
387 if (prop_flags
& 0x1000)
388 strcat (flags
, "hasdefault ");
390 ptr
= mono_metadata_blob_heap (m
, cols
[MONO_PROPERTY_TYPE
]);
391 bsize
= mono_metadata_decode_blob_size (ptr
, &ptr
);
392 /* ECMA claims 0x08 ... */
393 if (*ptr
!= 0x28 && *ptr
!= 0x08)
394 g_warning("incorrect signature in propert blob: 0x%x", *ptr
);
396 pcount
= mono_metadata_decode_value (ptr
, &ptr
);
397 ptr
= get_type (m
, ptr
, &type
, FALSE
, NULL
);
398 fprintf (output
, "%d: %s %s (",
399 i
+ 1, type
, mono_metadata_string_heap (m
, cols
[MONO_PROPERTY_NAME
]));
402 for (j
= 0; j
< pcount
; j
++){
403 ptr
= get_param (m
, ptr
, &type
, NULL
);
404 fprintf (output
, "%s%s", j
> 0? ", " : "",type
);
407 fprintf (output
, ") %s\n", flags
);
412 dump_table_event (MonoImage
*m
)
414 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_EVENT
];
416 fprintf (output
, "Event Table (1..%d)\n", t
->rows
);
418 for (i
= 0; i
< t
->rows
; i
++){
419 guint32 cols
[MONO_EVENT_SIZE
];
423 mono_metadata_decode_row (t
, i
, cols
, MONO_EVENT_SIZE
);
425 name
= mono_metadata_string_heap (m
, cols
[MONO_EVENT_NAME
]);
426 type
= get_typedef_or_ref (m
, cols
[MONO_EVENT_TYPE
], NULL
);
427 fprintf (output
, "%d: %s %s %s\n", i
+ 1, type
, name
,
428 cols
[MONO_EVENT_FLAGS
] & 0x200 ? "specialname " : "");
435 dump_table_file (MonoImage
*m
)
437 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FILE
];
439 fprintf (output
, "File Table (1..%d)\n", t
->rows
);
441 for (i
= 0; i
< t
->rows
; i
++){
442 guint32 cols
[MONO_FILE_SIZE
];
443 const char *name
, *hash
;
445 mono_metadata_decode_row (t
, i
, cols
, MONO_FILE_SIZE
);
447 name
= mono_metadata_string_heap (m
, cols
[MONO_FILE_NAME
]);
448 fprintf (output
, "%d: %s %s [", i
+ 1, name
,
449 cols
[MONO_FILE_FLAGS
] & 0x1 ? "nometadata" : "containsmetadata");
450 hash
= mono_metadata_blob_heap (m
, cols
[MONO_FILE_HASH_VALUE
]);
451 len
= mono_metadata_decode_blob_size (hash
, &hash
);
452 for (j
= 0; j
< len
; ++j
)
453 fprintf (output
, "%s%02X", j
? " ": "", hash
[j
] & 0xff);
454 fprintf (output
, "]\n");
460 get_manifest_implementation (MonoImage
*m
, guint32 idx
)
463 const char* table
= "";
465 return g_strdup ("current module");
466 row
= idx
>> MONO_IMPLEMENTATION_BITS
;
467 switch (idx
& MONO_IMPLEMENTATION_MASK
) {
468 case MONO_IMPLEMENTATION_FILE
:
471 case MONO_IMPLEMENTATION_ASSEMBLYREF
:
472 table
= "assemblyref";
474 case MONO_IMPLEMENTATION_EXP_TYPE
:
475 table
= "exportedtype";
478 g_assert_not_reached ();
480 return g_strdup_printf ("%s %d", table
, row
);
484 get_manifest_flags (guint32 mf
)
488 case 1: return "public";
489 case 2: return "private";
496 dump_table_manifest (MonoImage
*m
)
498 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MANIFESTRESOURCE
];
500 fprintf (output
, "Manifestresource Table (1..%d)\n", t
->rows
);
502 for (i
= 0; i
< t
->rows
; i
++){
503 guint32 cols
[MONO_MANIFEST_SIZE
];
504 const char *name
, *mf
;
507 mono_metadata_decode_row (t
, i
, cols
, MONO_MANIFEST_SIZE
);
509 name
= mono_metadata_string_heap (m
, cols
[MONO_MANIFEST_NAME
]);
510 mf
= get_manifest_flags (cols
[MONO_MANIFEST_FLAGS
]);
511 impl
= get_manifest_implementation (m
, cols
[MONO_MANIFEST_IMPLEMENTATION
]);
512 fprintf (output
, "%d: %s '%s' at offset %u in %s\n", i
+ 1, mf
, name
, cols
[MONO_MANIFEST_OFFSET
], impl
);
519 dump_table_moduleref (MonoImage
*m
)
521 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MODULEREF
];
523 fprintf (output
, "ModuleRef Table (1..%d)\n", t
->rows
);
525 for (i
= 0; i
< t
->rows
; i
++){
526 guint32 cols
[MONO_MODULEREF_SIZE
];
529 mono_metadata_decode_row (t
, i
, cols
, MONO_MODULEREF_SIZE
);
531 name
= mono_metadata_string_heap (m
, cols
[MONO_MODULEREF_NAME
]);
532 fprintf (output
, "%d: %s\n", i
+ 1, name
);
538 dump_table_module (MonoImage
*m
)
540 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_MODULE
];
542 fprintf (output
, "Module Table (1..%d)\n", t
->rows
);
544 for (i
= 0; i
< t
->rows
; i
++){
545 guint32 cols
[MONO_MODULE_SIZE
];
549 mono_metadata_decode_row (t
, i
, cols
, MONO_MODULE_SIZE
);
551 name
= mono_metadata_string_heap (m
, cols
[MONO_MODULE_NAME
]);
552 guid
= get_guid (m
, cols
[MONO_MODULE_MVID
]);
553 fprintf (output
, "%d: %s %d %s\n", i
+ 1, name
, cols
[MONO_MODULE_MVID
], guid
);
558 dump_table_method (MonoImage
*m
)
560 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHOD
];
561 MonoTableInfo
*td
= &m
->tables
[MONO_TABLE_TYPEDEF
];
563 guint32 first_m
, last_m
;
564 /* Generic container for Type & method */
565 MonoGenericContainer
*type_container
= NULL
, *method_container
= NULL
;
567 fprintf (output
, "Method Table (1..%d)\n", t
->rows
);
570 last_m
= first_m
= 1;
571 for (i
= 1; i
<= t
->rows
; i
++){
572 guint32 cols
[MONO_METHOD_SIZE
];
573 char *sig
, *impl_flags
;
575 MonoMethodSignature
*method
;
578 * Find the next type.
580 while (current_type
<= td
->rows
&& i
>= (last_m
= mono_metadata_decode_row_col (td
, current_type
- 1, MONO_TYPEDEF_METHOD_LIST
))) {
584 fprintf (output
, "########## %s.%s\n",
585 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAMESPACE
)),
586 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, current_type
- 2, MONO_TYPEDEF_NAME
)));
588 type_container
= mono_metadata_load_generic_params (m
, MONO_TOKEN_TYPE_DEF
| (current_type
- 1), NULL
);
590 mono_metadata_load_generic_param_constraints (m
, MONO_TOKEN_TYPE_DEF
| (current_type
- 1), type_container
);
593 method_container
= mono_metadata_load_generic_params (m
, MONO_TOKEN_METHOD_DEF
| i
, type_container
);
594 if (method_container
)
595 mono_metadata_load_generic_param_constraints (m
, MONO_TOKEN_METHOD_DEF
| i
, method_container
);
596 mono_metadata_decode_table_row (m
, MONO_TABLE_METHOD
, i
- 1, cols
, MONO_METHOD_SIZE
);
597 sigblob
= mono_metadata_blob_heap (m
, cols
[MONO_METHOD_SIGNATURE
]);
598 mono_metadata_decode_blob_size (sigblob
, &sigblob
);
599 method
= mono_metadata_parse_method_signature_full (m
, method_container
? method_container
: type_container
, i
, sigblob
, &sigblob
);
600 sig
= dis_stringify_method_signature (m
, method
, i
, method_container
? method_container
: type_container
, FALSE
);
601 impl_flags
= get_method_impl_flags (cols
[MONO_METHOD_IMPLFLAGS
]);
602 fprintf (output
, "%d: %s (param: %d impl_flags: %s)\n", i
, sig
, cols
[MONO_METHOD_PARAMLIST
], impl_flags
);
605 mono_metadata_free_method_signature (method
);
611 dump_table_implmap (MonoImage
*m
)
613 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_IMPLMAP
];
614 MonoTableInfo
*td
= &m
->tables
[MONO_TABLE_MODULEREF
];
617 fprintf (output
, "ImplMap Table (1..%d)\n", t
->rows
);
619 for (i
= 1; i
<= t
->rows
; i
++){
620 guint32 cols
[MONO_IMPLMAP_SIZE
];
623 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_IMPLMAP_SIZE
);
625 method
= get_method (m
, MONO_TOKEN_METHOD_DEF
| (cols
[MONO_IMPLMAP_MEMBER
] >> MONO_MEMBERFORWD_BITS
), NULL
);
627 fprintf (output
, "%d: %s %d (%s %s)\n", i
,
629 cols
[MONO_IMPLMAP_FLAGS
],
630 mono_metadata_string_heap (m
, cols
[MONO_IMPLMAP_NAME
]),
631 mono_metadata_string_heap (m
, mono_metadata_decode_row_col (td
, cols
[MONO_IMPLMAP_SCOPE
] - 1, MONO_MODULEREF_NAME
)));
636 dump_table_fieldrva (MonoImage
*m
)
638 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FIELDRVA
];
641 fprintf (output
, "FieldRVA Table (1..%d)\n", t
->rows
);
643 for (i
= 1; i
<= t
->rows
; i
++){
644 guint32 cols
[MONO_FIELD_RVA_SIZE
];
646 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_FIELD_RVA_SIZE
);
647 fprintf (output
, "%d: Field %d: %x\n", i
, cols
[MONO_FIELD_RVA_FIELD
], cols
[MONO_FIELD_RVA_RVA
]);
652 dump_table_methodimpl (MonoImage
*m
)
654 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHODIMPL
];
655 /*MonoTableInfo *td = &m->tables [MONO_TABLE_TYPEDEF];*/
658 fprintf (output
, "MethodImpl Table (1..%d)\n", t
->rows
);
660 for (i
= 1; i
<= t
->rows
; i
++){
661 guint32 cols
[MONO_METHODIMPL_SIZE
];
662 char *class, *impl
, *decl
;
664 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHODIMPL_SIZE
);
665 class = get_typedef (m
, cols
[MONO_METHODIMPL_CLASS
]);
666 impl
= get_method (m
, method_dor_to_token (cols
[MONO_METHODIMPL_BODY
]), NULL
);
667 decl
= get_method (m
, method_dor_to_token (cols
[MONO_METHODIMPL_DECLARATION
]), NULL
);
668 fprintf (output
, "%d: %s\n\tdecl: %s\n\timpl: %s\n", i
, class, decl
, impl
);
676 static dis_map_t semantics_map
[] = {
687 dump_table_methodsem (MonoImage
*m
)
689 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHODSEMANTICS
];
690 int i
, is_property
, index
;
691 const char *semantics
;
693 fprintf (output
, "Method Semantics Table (1..%d)\n", t
->rows
);
694 for (i
= 1; i
<= t
->rows
; i
++){
695 guint32 cols
[MONO_METHOD_SEMA_SIZE
];
697 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHOD_SEMA_SIZE
);
698 semantics
= flags (cols
[MONO_METHOD_SEMA_SEMANTICS
], semantics_map
);
699 is_property
= cols
[MONO_METHOD_SEMA_ASSOCIATION
] & MONO_HAS_SEMANTICS_MASK
;
700 index
= cols
[MONO_METHOD_SEMA_ASSOCIATION
] >> MONO_HAS_SEMANTICS_BITS
;
701 fprintf (output
, "%d: [%d] %s method: %d %s %d\n", i
, cols
[MONO_METHOD_SEMA_ASSOCIATION
], semantics
,
702 cols
[MONO_METHOD_SEMA_METHOD
] - 1,
703 is_property
? "property" : "event",
709 dump_table_interfaceimpl (MonoImage
*m
)
711 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_INTERFACEIMPL
];
714 fprintf (output
, "Interface Implementation Table (1..%d)\n", t
->rows
);
715 for (i
= 1; i
<= t
->rows
; i
++) {
716 guint32 cols
[MONO_INTERFACEIMPL_SIZE
];
718 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_INTERFACEIMPL_SIZE
);
719 fprintf (output
, "%d: %s implements %s\n", i
,
720 get_typedef (m
, cols
[MONO_INTERFACEIMPL_CLASS
]),
721 get_typedef_or_ref (m
, cols
[MONO_INTERFACEIMPL_INTERFACE
], NULL
));
726 has_cattr_get_table (MonoImage
*m
, guint32 val
)
728 guint32 t
= val
& MONO_CUSTOM_ATTR_MASK
;
729 guint32 index
= val
>> MONO_CUSTOM_ATTR_BITS
;
733 case MONO_CUSTOM_ATTR_METHODDEF
:
736 case MONO_CUSTOM_ATTR_FIELDDEF
:
739 case MONO_CUSTOM_ATTR_TYPEREF
:
742 case MONO_CUSTOM_ATTR_TYPEDEF
:
745 case MONO_CUSTOM_ATTR_PARAMDEF
:
748 case MONO_CUSTOM_ATTR_INTERFACE
:
749 table
= "InterfaceImpl";
751 case MONO_CUSTOM_ATTR_MEMBERREF
:
754 case MONO_CUSTOM_ATTR_MODULE
:
757 case MONO_CUSTOM_ATTR_PERMISSION
:
758 table
= "DeclSecurity?";
760 case MONO_CUSTOM_ATTR_PROPERTY
:
763 case MONO_CUSTOM_ATTR_EVENT
:
766 case MONO_CUSTOM_ATTR_SIGNATURE
:
767 table
= "StandAloneSignature";
769 case MONO_CUSTOM_ATTR_MODULEREF
:
772 case MONO_CUSTOM_ATTR_TYPESPEC
:
775 case MONO_CUSTOM_ATTR_ASSEMBLY
:
778 case MONO_CUSTOM_ATTR_ASSEMBLYREF
:
779 table
= "AssemblyRef";
781 case MONO_CUSTOM_ATTR_FILE
:
784 case MONO_CUSTOM_ATTR_EXP_TYPE
:
785 table
= "ExportedType";
787 case MONO_CUSTOM_ATTR_MANIFEST
:
790 case MONO_CUSTOM_ATTR_GENERICPAR
:
791 table
= "GenericParam";
798 * FIXME: we should decode the index into something more uman-friendly.
800 return g_strdup_printf ("%s: %d", table
, index
);
804 custom_attr_params (MonoImage
*m
, MonoMethodSignature
* sig
, const char* value
)
806 int len
, i
, slen
, type
;
809 const char *p
= value
;
811 len
= mono_metadata_decode_value (p
, &p
);
812 if (len
< 2 || read16 (p
) != 0x0001) /* Prolog */
813 return g_strdup ("");
817 res
= g_string_new ("");
818 for (i
= 0; i
< sig
->param_count
; ++i
) {
820 g_string_append (res
, ", ");
821 type
= sig
->params
[i
]->type
;
825 g_string_append_printf (res
, "%d", (unsigned int)*p
);
829 g_string_append_printf (res
, "%d", *p
);
832 case MONO_TYPE_BOOLEAN
:
833 g_string_append_printf (res
, "%s", *p
?"true":"false");
837 g_string_append_printf (res
, "'%c'", read16 (p
));
841 g_string_append_printf (res
, "%d", read16 (p
));
845 g_string_append_printf (res
, "%d", (gint16
)read16 (p
));
849 g_string_append_printf (res
, "%d", read32 (p
));
853 g_string_append_printf (res
, "%d", (gint32
)read32 (p
));
857 g_string_append_printf (res
, "%lld", (long long)read64 (p
));
861 g_string_append_printf (res
, "%lld", (long long)read64 (p
));
870 g_string_append_printf (res
, "(00 00 80 ff)"); /* negative infinity */
872 g_string_append_printf (res
, "(00 00 80 7f)"); /* positive infinity */
873 else if (isnan (val
))
874 g_string_append_printf (res
, "(00 00 c0 ff)"); /* NaN */
876 g_string_append_printf (res
, "%g", val
);
887 g_string_append_printf (res
, "(00 00 00 00 00 00 f0 ff)"); /* negative infinity */
889 g_string_append_printf (res
, "(00 00 00 00 00 00 f0 7f)"); /* positive infinity */
890 else if (isnan (val
))
891 g_string_append_printf (res
, "(00 00 00 00 00 00 f8 ff)"); /* NaN */
893 g_string_append_printf (res
, "%g", val
);
897 case MONO_TYPE_VALUETYPE
:
898 if (mono_class_is_enum (sig
->params
[i
]->data
.klass
)) {
899 type
= mono_class_enum_basetype (sig
->params
[i
]->data
.klass
)->type
;
902 g_warning ("generic valutype not handled in custom attr value decoding");
905 case MONO_TYPE_CLASS
: /* It must be a Type: check? */
906 case MONO_TYPE_STRING
:
907 if (*p
== (char)0xff) {
908 g_string_append (res
, "null");
912 slen
= mono_metadata_decode_value (p
, &p
);
913 g_string_append_c (res
, '"');
914 g_string_append (res
, p
);
915 g_string_append_c (res
, '"');
919 g_warning ("Type %02x not handled in custom attr value decoding", sig
->params
[i
]->type
);
925 g_string_append_printf (res
, " %d named args: (", slen
);
926 slen
= len
- (p
- value
) + 1;
927 for (i
= 0; i
< slen
; ++i
) {
928 g_string_append_printf (res
, " %02X", (p
[i
] & 0xff));
930 g_string_append_c (res
, ')');
933 g_string_free (res
, FALSE
);
938 dump_table_customattr (MonoImage
*m
)
940 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_CUSTOMATTRIBUTE
];
943 fprintf (output
, "Custom Attributes Table (1..%d)\n", t
->rows
);
944 for (i
= 1; i
<= t
->rows
; i
++) {
945 guint32 cols
[MONO_CUSTOM_ATTR_SIZE
];
952 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_CUSTOM_ATTR_SIZE
);
953 desc
= has_cattr_get_table (m
, cols
[MONO_CUSTOM_ATTR_PARENT
]);
954 mtoken
= cols
[MONO_CUSTOM_ATTR_TYPE
] >> MONO_CUSTOM_ATTR_TYPE_BITS
;
955 switch (cols
[MONO_CUSTOM_ATTR_TYPE
] & MONO_CUSTOM_ATTR_TYPE_MASK
) {
956 case MONO_CUSTOM_ATTR_TYPE_METHODDEF
:
957 mtoken
|= MONO_TOKEN_METHOD_DEF
;
959 case MONO_CUSTOM_ATTR_TYPE_MEMBERREF
:
960 mtoken
|= MONO_TOKEN_MEMBER_REF
;
963 g_warning ("Unknown table for custom attr type %08x", cols
[MONO_CUSTOM_ATTR_TYPE
]);
966 method
= get_method (m
, mtoken
, NULL
);
967 meth
= mono_get_method (m
, mtoken
, NULL
);
968 params
= custom_attr_params (m
, mono_method_signature (meth
), mono_metadata_blob_heap (m
, cols
[MONO_CUSTOM_ATTR_VALUE
]));
969 fprintf (output
, "%d: %s: %s [%s]\n", i
, desc
, method
, params
);
977 dump_table_nestedclass (MonoImage
*m
)
979 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_NESTEDCLASS
];
980 guint32 cols
[MONO_NESTED_CLASS_SIZE
];
982 char *nested
, *nesting
;
983 fprintf (output
, "NestedClass Table (1..%d)\n", t
->rows
);
985 for (i
= 1; i
<= t
->rows
; i
++){
986 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_NESTED_CLASS_SIZE
);
987 nested
= get_typedef (m
, cols
[MONO_NESTED_CLASS_NESTED
]);
988 nesting
= get_typedef (m
, cols
[MONO_NESTED_CLASS_ENCLOSING
]);
989 fprintf (output
, "%d: %d %d: %s in %s\n", i
,
990 cols
[MONO_NESTED_CLASS_NESTED
],
991 cols
[MONO_NESTED_CLASS_ENCLOSING
], nested
, nesting
);
999 dump_table_exported (MonoImage
*m
)
1001 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_EXPORTEDTYPE
];
1002 guint32 cols
[MONO_EXP_TYPE_SIZE
];
1004 const char *name
, *nspace
;
1006 guint32 index
, flags
;
1007 fprintf (output
, "ExportedType Table (1..%d)\n", t
->rows
);
1009 for (i
= 1; i
<= t
->rows
; i
++) {
1010 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_EXP_TYPE_SIZE
);
1011 name
= mono_metadata_string_heap (m
, cols
[MONO_EXP_TYPE_NAME
]);
1012 nspace
= mono_metadata_string_heap (m
, cols
[MONO_EXP_TYPE_NAMESPACE
]);
1013 impl
= get_manifest_implementation (m
, cols
[MONO_EXP_TYPE_IMPLEMENTATION
]);
1014 index
= cols
[MONO_EXP_TYPE_TYPEDEF
];
1015 flags
= cols
[MONO_EXP_TYPE_FLAGS
];
1016 fprintf (output
, "%d: %s%s%s is in %s, index=%x, flags=0x%x\n", i
, nspace
, *nspace
? "." : "", name
, impl
, index
, flags
);
1023 dump_blob (MonoImage
*m
, const char* blob
)
1027 bsize
= mono_metadata_decode_blob_size (blob
, &blob
);
1029 for (j
= 0; j
< bsize
; j
++) {
1030 fprintf (output
, "%02x ", blob
[j
] & 0xff);
1035 dump_table_field_marshal (MonoImage
*m
)
1037 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_FIELDMARSHAL
];
1038 guint32 cols
[MONO_FIELD_MARSHAL_SIZE
];
1039 int i
, is_field
, idx
;
1043 fprintf (output
, "FieldMarshal Table (1..%d)\n", t
->rows
);
1045 for (i
= 1; i
<= t
->rows
; i
++) {
1046 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_FIELD_MARSHAL_SIZE
);
1047 blob
= mono_metadata_blob_heap (m
, cols
[MONO_FIELD_MARSHAL_NATIVE_TYPE
]);
1048 native
= get_marshal_info (m
, blob
);
1049 is_field
= (cols
[MONO_FIELD_MARSHAL_PARENT
] & MONO_HAS_FIELD_MARSHAL_MASK
) == MONO_HAS_FIELD_MARSHAL_FIELDSREF
;
1050 idx
= cols
[MONO_FIELD_MARSHAL_PARENT
] >> MONO_HAS_FIELD_MARSHAL_BITS
;
1051 fprintf (output
, "%d: (0x%04x) %s %d: %s\n", i
, cols
[MONO_FIELD_MARSHAL_PARENT
], is_field
? "Field" : "Param", idx
, native
);
1052 fprintf (output
, "\tblob encoding: ");
1053 dump_blob (m
, blob
);
1054 fprintf (output
, "\n");
1061 get_security_action (int val
) {
1062 static char buf
[32];
1065 case SECURITY_ACTION_DEMAND
:
1067 case SECURITY_ACTION_ASSERT
:
1069 case SECURITY_ACTION_DENY
:
1071 case SECURITY_ACTION_PERMITONLY
:
1072 return "PermitOnly";
1073 case SECURITY_ACTION_LINKDEMAND
:
1074 return "LinkDemand";
1075 case SECURITY_ACTION_INHERITDEMAND
:
1076 return "InheritanceDemand";
1077 case SECURITY_ACTION_REQMIN
:
1078 return "RequestMinimum";
1079 case SECURITY_ACTION_REQOPT
:
1080 return "RequestOptional";
1081 case SECURITY_ACTION_REQREFUSE
:
1082 return "RequestRefuse";
1083 /* Special actions (for non CAS permissions) */
1084 case SECURITY_ACTION_NONCASDEMAND
:
1085 return "NonCasDemand";
1086 case SECURITY_ACTION_NONCASLINKDEMAND
:
1087 return "NonCasLinkDemand";
1088 case SECURITY_ACTION_NONCASINHERITANCE
:
1089 return "NonCasInheritance";
1090 /* Fx 2.0 actions (for both CAS and non-CAS permissions) */
1091 case SECURITY_ACTION_LINKDEMANDCHOICE
:
1092 return "LinkDemandChoice";
1093 case SECURITY_ACTION_INHERITDEMANDCHOICE
:
1094 return "InheritanceDemandChoice";
1095 case SECURITY_ACTION_DEMANDCHOICE
:
1096 return "DemandChoice";
1098 g_snprintf (buf
, sizeof (buf
), "0x%04X", val
);
1104 dump_table_declsec (MonoImage
*m
)
1106 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_DECLSECURITY
];
1107 guint32 cols
[MONO_DECL_SECURITY_SIZE
];
1110 const char *blob
, *action
;
1111 const char* parent
[] = {
1112 "TypeDef", "MethodDef", "Assembly", ""
1115 fprintf (output
, "DeclSecurity Table (1..%d)\n", t
->rows
);
1117 for (i
= 1; i
<= t
->rows
; i
++) {
1118 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_DECL_SECURITY_SIZE
);
1119 blob
= mono_metadata_blob_heap (m
, cols
[MONO_DECL_SECURITY_PERMISSIONSET
]);
1120 len
= mono_metadata_decode_blob_size (blob
, &blob
);
1121 action
= get_security_action (cols
[MONO_DECL_SECURITY_ACTION
]);
1122 idx
= cols
[MONO_DECL_SECURITY_PARENT
];
1123 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");
1126 if (blob
[0] == MONO_DECLSEC_FORMAT_20
) {
1127 /* 2.0 declarative security format */
1128 char *declsec
= dump_declsec_entry20 (m
, blob
, "\t");
1129 fprintf (output
, "%s", declsec
);
1132 /* 1.0 declarative security format - Unicode XML */
1133 for (idx
= 0; idx
< len
; ++idx
)
1134 fprintf (output
, "%c", blob
[idx
]);
1136 fprintf (output
, "\n");
1141 dump_table_genericpar (MonoImage
*m
)
1143 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_GENERICPARAM
];
1144 guint32 cols
[MONO_GENERICPARAM_SIZE
];
1147 fprintf (output
, "GenericParameters (1..%d)\n", t
->rows
);
1149 for (i
= 1; i
<= t
->rows
; i
++) {
1151 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_GENERICPARAM_SIZE
);
1153 // sig = get_type_or_methdef (m, cols [MONO_GENERICPARAM_OWNER]);
1154 sig
= g_strdup_printf ("%x", cols
[MONO_GENERICPARAM_OWNER
]);
1155 fprintf (output
, "%d: %d, flags=%d, owner=%s %s\n", i
,
1156 cols
[MONO_GENERICPARAM_NUMBER
],
1157 cols
[MONO_GENERICPARAM_FLAGS
], sig
,
1158 mono_metadata_string_heap (m
, cols
[MONO_GENERICPARAM_NAME
]));
1164 dump_table_methodspec (MonoImage
*m
)
1166 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_METHODSPEC
];
1167 guint32 cols
[MONO_METHODSPEC_SIZE
];
1170 fprintf (output
, "MethodSpec (1..%d)\n", t
->rows
);
1172 for (i
= 1; i
<= t
->rows
; i
++) {
1177 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_METHODSPEC_SIZE
);
1179 /* build a methodspec token to get the method */
1180 token
= MONO_TOKEN_METHOD_SPEC
| i
;
1181 method
= get_method (m
, token
, NULL
);
1183 sig
= get_method_type_param (m
, cols
[MONO_METHODSPEC_SIGNATURE
], NULL
);
1184 fprintf (output
, "%d: %s, %s\n", i
, method
, sig
);
1191 dump_table_parconstraint (MonoImage
*m
)
1193 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_GENERICPARAMCONSTRAINT
];
1194 guint32 cols
[MONO_GENPARCONSTRAINT_SIZE
];
1197 fprintf (output
, "Generic Param Constraint (1..%d)\n", t
->rows
);
1199 for (i
= 1; i
<= t
->rows
; i
++) {
1201 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_GENPARCONSTRAINT_SIZE
);
1203 // sig = get_typedef_or_ref (m, cols [MONO_GENPARCONSTRAINT_CONSTRAINT], NULL);
1204 sig
= g_strdup_printf ("%x", cols
[MONO_GENPARCONSTRAINT_CONSTRAINT
]);
1205 fprintf (output
, "%d: gen-par=%d, Constraint=%s\n", i
,
1206 cols
[MONO_GENPARCONSTRAINT_GENERICPAR
], sig
);
1212 dump_stream_blob (MonoImage
*m
)
1216 fprintf (output
, "Blob heap contents\n");
1218 for (i
= 0; i
< m
->heap_blob
.size
; i
++) {
1221 fprintf (output
, "\n");
1222 else if ((i
% 8) == 0)
1223 fprintf (output
, "- ");
1225 fprintf (output
, "%02x ", m
->heap_blob
.data
[i
] & 0xff);
1228 fprintf (output
, "\n");
1232 dump_stream_strings (MonoImage
*m
)
1236 fprintf (output
, "Strings heap contents\n");
1238 for (i
= 0; i
< m
->heap_strings
.size
; ) {
1239 const char *str
= mono_metadata_string_heap (m
, i
);
1240 fprintf (output
, "%02x: \"%s\"\n", i
, str
);
1241 i
+= strlen (str
) + 1;
1246 dump_stream_us (MonoImage
*m
)
1250 fprintf (output
, "User Strings heap contents\n");
1252 for (i
= 0; i
< m
->heap_us
.size
; ) {
1253 const char *us_ptr
= mono_metadata_user_string (m
, i
);
1254 int len
= mono_metadata_decode_blob_size (us_ptr
, (const char**)&us_ptr
);
1256 char *str
= get_encoded_user_string_or_bytearray ((const guchar
*)us_ptr
, len
);
1257 fprintf (output
, "%02x: %s\n", i
, str
);
1264 dump_table_standalonesig (MonoImage
*m
)
1266 MonoTableInfo
*t
= &m
->tables
[MONO_TABLE_STANDALONESIG
];
1267 guint32 cols
[MONO_STAND_ALONE_SIGNATURE_SIZE
];
1270 fprintf (output
, "Stand alone signature (1..%d)\n", t
->rows
);
1272 for (i
= 1; i
<= t
->rows
; i
++) {
1273 const char *locals_ptr
;
1276 mono_metadata_decode_row (t
, i
- 1, cols
, MONO_STAND_ALONE_SIGNATURE_SIZE
);
1278 locals_ptr
= mono_metadata_blob_heap (m
, cols
[MONO_STAND_ALONE_SIGNATURE
]);
1279 bsize
= mono_metadata_decode_blob_size (locals_ptr
, &locals_ptr
);
1281 fprintf (output
, "%d: blob[0x%x] = ", i
, cols
[MONO_STAND_ALONE_SIGNATURE
]);
1283 for (j
= 0; j
< bsize
; j
++) {
1284 fprintf (output
, "%02x ", locals_ptr
[j
] & 0xff);
1286 fprintf (output
, "\n");
1291 dump_table_ptr (MonoImage
*m
, int table
, const char *name
)
1293 MonoTableInfo
*t
= &m
->tables
[table
];
1297 fprintf (output
, "%s (1..%d)\n", name
, t
->rows
);
1299 for (i
= 1; i
<= t
->rows
; i
++) {
1300 mono_metadata_decode_row (t
, i
- 1, cols
, 1);
1302 fprintf (output
, "%d: %d\n", i
, cols
[0]);
1307 dump_table_methodptr (MonoImage
*m
)
1309 dump_table_ptr (m
, MONO_TABLE_METHOD_POINTER
, "Method Ptr");
1313 dump_table_fieldptr (MonoImage
*m
)
1315 dump_table_ptr (m
, MONO_TABLE_FIELD_POINTER
, "Field Ptr");
1319 dump_table_paramptr (MonoImage
*m
)
1321 dump_table_ptr (m
, MONO_TABLE_PARAM_POINTER
, "Param Ptr");
1325 dump_table_eventptr (MonoImage
*m
)
1327 dump_table_ptr (m
, MONO_TABLE_EVENT_POINTER
, "Event Ptr");
1331 dump_table_propertyptr (MonoImage
*m
)
1333 dump_table_ptr (m
, MONO_TABLE_PROPERTY_POINTER
, "Property Ptr");