From: Hans Leidekker hans@codeweavers.com
--- tools/winedump/pe.c | 873 +++++++++++++++++++++++++++++--------------- 1 file changed, 583 insertions(+), 290 deletions(-)
diff --git a/tools/winedump/pe.c b/tools/winedump/pe.c index 34e22e3b27f..795ba7249f7 100644 --- a/tools/winedump/pe.c +++ b/tools/winedump/pe.c @@ -2740,6 +2740,12 @@ static void dump_dir_debug(void) printf("\n"); }
+static struct +{ + const BYTE *data; + UINT size; +} strings, userstrings, blobs, guids, tables; + static void print_clr_flags( const char *title, UINT value ) { printf(" %-34s 0x%X\n", title, value); @@ -2757,18 +2763,36 @@ static void print_clr_directory( const char *title, const IMAGE_DATA_DIRECTORY * printf(" %-23s rva: 0x%-8x size: 0x%-8x\n", title, (UINT)dir->VirtualAddress, (UINT)dir->Size); }
-static void print_clr_strings( const BYTE *strings, UINT size ) +static UINT clr_indent = 4; + +static void print_clr_indent( void ) +{ + UINT i; + for (i = 0; i < clr_indent; i++) printf( " " ); +} + +static void print_clr( const char *str ) +{ + print_clr_indent(); + printf( "%s", str ); +} + +static void print_clr_strings( const BYTE *data, UINT data_size ) { - const char *beg = (const char *)strings, *end; + const char *beg = (const char *)data, *end; UINT count = 0;
+ if (!data_size) return; + clr_indent += 4; for (;;) { - if (!(end = memchr( beg, '\0', size - (beg - (const char *)strings) ))) break; - printf( " %-10u"%s"\n", count, beg ); + if (!(end = memchr( beg, '\0', data_size - (beg - (const char *)data) ))) break; + print_clr_indent(); + printf( "%-10u"%s"\n", count, beg ); beg = end + 1; count++; } + clr_indent -= 4; }
static UINT clr_blob_size( const BYTE *data, UINT data_size, UINT *skip ) @@ -2797,24 +2821,33 @@ static UINT clr_blob_size( const BYTE *data, UINT data_size, UINT *skip ) static void print_clr_blobs( const BYTE *data, UINT data_size ) { const BYTE *blob = data + 1; - UINT i, size, skip, count = 1; + UINT i, size, skip;
if (!data_size) return; - printf( " 0 %02x\n", data[0] ); + + clr_indent += 4; + print_clr_indent(); + printf( "%-10u %02x\n", 0, data[0] ); data_size--; for (;;) { if (!(size = clr_blob_size( blob, data_size, &skip ))) break; - printf( " %-10u", count++ ); + print_clr_indent(); + printf( "%-10u ", (UINT)(blob - data) ); for (i = 0; i < size; i++) { printf( "%02x ", blob[i + skip] ); - if (i && i < size - 1 && !((i + 1) % 30)) printf( "\n " ); + if (i && i < size - 1 && !((i + 1) % 30)) + { + printf( "\n" ); + print_clr( " " ); + } } printf( "\n" ); data_size -= size - skip; blob += size + skip; } + clr_indent -= 4; }
static void print_clr_guids( const BYTE *data, UINT data_size ) @@ -2822,9 +2855,11 @@ static void print_clr_guids( const BYTE *data, UINT data_size ) const BYTE *guid = data; UINT i, j, count = data_size / 16;
+ clr_indent += 4; for (i = 0; i < count; i++) { - printf( " %-10u", count ); + print_clr_indent(); + printf( "%-10u ", count ); printf( "%08x", *(UINT *)guid ); printf( " %04x", *(UINT *)guid + 4 ); printf( " %04x", *(USHORT *)guid + 6 ); @@ -2832,61 +2867,86 @@ static void print_clr_guids( const BYTE *data, UINT data_size ) printf( "\n" ); guid += 16; } + clr_indent -= 4; }
static UINT str_idx_size = 2; static UINT guid_idx_size = 2; static UINT blob_idx_size = 2;
-static void print_clr_byte( const char *prefix, const BYTE **ptr, UINT *size, BOOL flags ) +static void print_clr_byte( const BYTE **ptr, UINT *size, BOOL flags ) { if (*size < 1) return; - printf( flags ? "%s0x%02x" : "%s%-3u", prefix, **ptr ); + printf( flags ? "0x%02x " : "%-16u", **ptr ); (*ptr)++; (*size)--; }
-static void print_clr_ushort( const char *prefix, const BYTE **ptr, UINT *size, BOOL flags ) +static void print_clr_ushort( const BYTE **ptr, UINT *size, BOOL flags ) { if (*size < sizeof(USHORT)) return; - printf( flags ? "%s0x%04x" : "%s%-5u", prefix, *(const USHORT *)*ptr ); + printf( flags ? "0x%04x " : "%-16u", *(const USHORT *)*ptr ); *ptr += sizeof(USHORT); *size -= sizeof(USHORT); }
-static void print_clr_uint( const char *prefix, const BYTE **ptr, UINT *size, BOOL flags ) +static void print_clr_uint( const BYTE **ptr, UINT *size, BOOL flags ) { if (*size < sizeof(UINT)) return; - printf( flags ? "%s0x%08x" : "%s%-10u", prefix, *(const UINT *)*ptr ); + printf( flags ? "0x%08x " : "%-16u", *(const UINT *)*ptr ); *ptr += sizeof(UINT); *size -= sizeof(UINT); }
-static void print_clr_uint64( const char *prefix, const BYTE **ptr, UINT *size ) +static void print_clr_uint64( const BYTE **ptr, UINT *size ) { if (*size < sizeof(UINT64)) return; - printf( "%s0x%08x%08x", prefix, (UINT)(*(const UINT64 *)*ptr >> 32), (UINT)*(const UINT64 *)*ptr ); + printf( "0x%08x%08x", (UINT)(*(const UINT64 *)*ptr >> 32), (UINT)*(const UINT64 *)*ptr ); *ptr += sizeof(UINT64); *size -= sizeof(UINT64); }
-static void print_clr_string_idx( const char *prefix, const BYTE **ptr, UINT *size ) +static void print_clr_string_idx( const BYTE **ptr, UINT *size ) { if (*size < str_idx_size) return; - if (str_idx_size == 2) printf( "%s%-5u", prefix, *(const USHORT *)*ptr ); - else printf( "%s%-10u", prefix, *(const UINT *)*ptr ); + if (str_idx_size == 2) + { + USHORT idx = *(const USHORT *)*ptr; + printf( "%-16u", idx ); + } + else + { + UINT idx = *(const UINT *)*ptr; + printf( "%-16u", idx ); + } *ptr += str_idx_size; *size -= str_idx_size; }
-static void print_clr_blob_idx( const char *prefix, const BYTE **ptr, UINT *size ) +static void print_clr_blob_idx( const BYTE **ptr, UINT *size ) { if (*size < blob_idx_size) return; - if (blob_idx_size == 2) printf( "%s%-5u", prefix, *(const USHORT *)*ptr ); - else printf( "%s%-10u", prefix, *(const UINT *)*ptr ); + if (blob_idx_size == 2) + { + USHORT idx = *(const USHORT *)*ptr; + printf( "%-16u", idx ); + } + else + { + UINT idx = *(const UINT *)*ptr; + printf( "%-16u", idx ); + } *ptr += blob_idx_size; *size -= blob_idx_size; }
-static void print_clr_guid_idx( const char *prefix, const BYTE **ptr, UINT *size ) +static void print_clr_guid_idx( const BYTE **ptr, UINT *size ) { if (*size < guid_idx_size) return; - if (guid_idx_size == 2) printf( "%s%-5u", prefix, *(const USHORT *)*ptr ); - else printf( "%s%-10u", prefix, *(const UINT *)*ptr ); + if (guid_idx_size == 2) + { + USHORT idx = *(const USHORT *)*ptr; + printf( "%-16u", idx ); + } + else + { + UINT idx = *(const UINT *)*ptr; + printf( "%-16u", idx ); + } *ptr += guid_idx_size; *size -= guid_idx_size; }
@@ -2933,590 +2993,762 @@ enum CLR_TABLE_MAX = 0x2d, };
-static void print_clr_table_idx( const char *prefix, const BYTE **ptr, UINT *size ) +static void print_clr_table_idx( const BYTE **ptr, UINT *size ) { + USHORT idx; if (*size < sizeof(USHORT)) return; /* FIXME should be 4 bytes if the number of rows exceeds 2^16 */ - printf( "%s0x%04x", prefix, *(const USHORT *)*ptr ); + idx = *(const USHORT *)*ptr; + printf( "0x%04x ", idx ); *ptr += sizeof(USHORT); *size -= sizeof(USHORT); }
+static void print_clr_row( UINT row ) +{ + print_clr_indent(); + printf( "%-10u ", row ); +} + +static void print_clr_table_header( const char * const *header ) +{ + const char *str; + + print_clr_indent(); + printf( "%-11s", "#" ); + while ((str = *header++)) printf( "%-16s", str ); + printf( "\n" ); +} + static void print_clr_table_module( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Generation", "Name", "Mvid", "EncId", "EncBaseId", NULL }; + UINT i, row = 1;
- printf( " Module table\n" ); - printf( " Generation Name Mvid EncId EncBaseId\n" ); + print_clr( "Module table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_string_idx( " ", ptr, size ); - print_clr_guid_idx( " ", ptr, size ); - print_clr_guid_idx( " ", ptr, size ); - print_clr_guid_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_string_idx( ptr, size ); + print_clr_guid_idx( ptr, size ); + print_clr_guid_idx( ptr, size ); + print_clr_guid_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_typeref( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "ResolutionScope", "TypeName", "TypeNamespace", NULL }; + UINT i, row = 1;
- printf( " TypeRef table\n" ); - printf( " ResolutionScope TypeName TypeNamsespace\n" ); + print_clr( "TypeRef table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_string_idx( ptr, size ); + print_clr_string_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_typedef( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Flags", "TypeName", "TypeNamespace", "Extends", "FieldList", + "MethodList", NULL }; + UINT i, row = 1;
- printf( " TypeDef table\n" ); - printf( " Flags TypeName TypeNamsespace Extends FieldList MethodList\n" ); + print_clr( "TypeDef table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_string_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); + print_clr_string_idx( ptr, size ); + print_clr_string_idx( ptr, size ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_field( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Flags", "Name", "Signature", NULL }; + UINT i, row = 1;
- printf( " Field table\n" ); - printf( " Flags Name Signature\n" ); + print_clr( "Field table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_string_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_string_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_methoddef( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "RVA", "ImplFlags", "Flags", "Name", "Signature", "ParamList", NULL }; + UINT i, row = 1;
- printf( " MethodDef table\n" ); - printf( " RVA ImplFlags Flags Name Signature ParamList\n" ); + print_clr( "MethodDef table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_string_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_string_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_param( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Flags", "Sequence", "Name", NULL }; + UINT i, row = 1;
- printf( " Param table\n" ); - printf( " Flags Sequence Name\n" ); + print_clr( "Param table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_string_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_string_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_interfaceimpl( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Class", "Interface", NULL }; + UINT i, row = 1;
- printf( " InterfaceImpl table\n" ); - printf( " Class Interface\n" ); + print_clr( "InterfaceImpl table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_memberref( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Class", "Name", "Signature", NULL }; + UINT i, row = 1;
- printf( " MemberRef table\n" ); - printf( " Class Name Signature\n" ); + print_clr( "MemberRef table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_string_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_constant( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Type", "Padding", "Parent", "Value", NULL }; + UINT i, row = 1;
- printf( " Constant table\n" ); - printf( " Type Padding Parent Value\n" ); + print_clr( "Constant table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_byte( " ", ptr, size, FALSE ); - print_clr_byte( " ", ptr, size, FALSE ); - print_clr_table_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_byte( ptr, size, FALSE ); + print_clr_byte( ptr, size, FALSE ); + print_clr_table_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_customattribute( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Parent", "Type", "Value", NULL }; + UINT i, row = 1;
- printf( " CustomAttribute table\n" ); - printf( " Parent Type Value\n" ); + print_clr( "CustomAttribute table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_fieldmarshal( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Parent", "NativeType", NULL }; + UINT i, row = 1;
- printf( " FieldMarshal table\n" ); - printf( " Parent NativeType\n" ); + print_clr( "FieldMarshal table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_declsecurity( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Action", "Parent", "PermissionSet", NULL }; + UINT i, row = 1;
- printf( " DeclSecurity table\n" ); - printf( " Action Parent PermissionSet\n" ); + print_clr( "DeclSecurity table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_table_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_table_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_classlayout( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "PackingSize", "ClassSize", "Parent", NULL }; + UINT i, row = 1;
- printf( " ClassLayout table\n" ); - printf( " PackingSize ClassSize Parent\n" ); + print_clr( "ClassLayout table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_uint( " ", ptr, size, FALSE ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_uint( ptr, size, FALSE ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_fieldlayout( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Offset", "Field", NULL }; + UINT i, row = 1;
- printf( " FieldLayout table\n" ); - printf( " Offset Field\n" ); + print_clr( "FieldLayout table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, FALSE ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, FALSE ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_standalonesig( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Signature", NULL }; + UINT i, row = 1;
- printf( " StandAloneSig table\n" ); - printf( " Signature\n" ); + print_clr( "StandAloneSig table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_eventmap( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Parent", "EventList", NULL }; + UINT i, row = 1;
- printf( " EventMap table\n" ); - printf( " Parent EvenList\n" ); + print_clr( "EventMap table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_blob_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_event( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "EventFlags", "Name", "EventType", NULL }; + UINT i, row = 1;
- printf( " Event table\n" ); - printf( " EventFlags Name EventType\n" ); + print_clr( "Event table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_string_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_string_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_propertymap( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Parent", "PropertyList", NULL }; + UINT i, row = 1;
- printf( " PropertyMap table\n" ); - printf( " Parent PropertyList\n" ); + print_clr( "PropertyMap table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_property( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Flags", "Name", "Type", NULL }; + UINT i, row = 1;
- printf( " Property table\n" ); - printf( " Flags Name Type\n" ); + print_clr( "Property table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_string_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_string_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_methodsemantics( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Semantics", "Method", "Association", NULL }; + UINT i, row = 1;
- printf( " MethodSemantics table\n" ); - printf( " Semantics Method Association\n" ); + print_clr( "MethodSemantics table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_table_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_methodimpl( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Class", "Body", "Declaration", NULL }; + UINT i, row = 1;
- printf( " MethodImpl table\n" ); - printf( " Class MethodBody MethodDeclaration\n" ); + print_clr( "MethodImpl table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_moduleref( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Name", NULL }; + UINT i, row = 1;
- printf( " ModuleRef table\n" ); - printf( " Name\n" ); + print_clr( "ModuleRef table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_string_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_string_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_typespec( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Signature", NULL }; + UINT i, row = 1;
- printf( " TypeSpec table\n" ); - printf( " Signature\n" ); + print_clr( "TypeSpec table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_implmap( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "MappingFlags", "MemberForwarded", "ImportName", "ImportScope", NULL }; + UINT i, row = 1;
- printf( " ImplMap table\n" ); - printf( " MappingFlags MemberForwarded ImportName ImportScope\n" ); + print_clr( "ImplMap table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_table_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_table_idx( ptr, size ); + print_clr_string_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_fieldrva( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "RVA", "Field", NULL }; + UINT i, row = 1;
- printf( " FieldRVA table\n" ); - printf( " RVA Field\n" ); + print_clr( "FieldRVA table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_assembly( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "HashAlgId", "MajorVersion", "MinorVersion", "BuildNumber", + "RevisionNumber", "Flags", "PublicKey", "Name", NULL }; + UINT i, row = 1;
- printf( " Assembly table\n" ); - printf( " HashAlgId MajorVersion MinorVersion BuildNumber RevisionNumber Flags " - "PublicKey Name\n" ); + print_clr( "Assembly table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_blob_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_uint( ptr, size, TRUE ); + print_clr_blob_idx( ptr, size ); + print_clr_string_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_assemblyprocessor( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Processor", NULL }; + UINT i, row = 1;
- printf( " AssemblyProcessor table\n" ); - printf( " Processor\n" ); + print_clr( "AssemblyProcessor table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, TRUE ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_assemblyos( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "OSPlatformID", "OSMajorVersion", "OSMinorVersion", NULL }; + UINT i, row = 1;
- printf( " AssemblyOS table\n" ); - printf( " OSPlatformID OSMajorVersion OSMinorVersion\n" ); + print_clr( "AssemblyOS table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_uint( " ", ptr, size, FALSE ); - print_clr_uint( " ", ptr, size, FALSE ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); + print_clr_uint( ptr, size, FALSE ); + print_clr_uint( ptr, size, FALSE ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_assemblyref( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "MajorVersion", "MinorVersion", "BuildNumber", "RevisionNumber", "Flags", + "PublicKeyOrToken", "Name", "Culture", "HashValue", NULL }; + UINT i, row = 1;
- printf( " AssemblyRef table\n" ); - printf( " MajorVersion MinorVersion BuildNumber RevisionNumber PublicKeyOrToken " - "Name Culture HashValue\n" ); + print_clr( "AssemblyRef table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_blob_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_uint( ptr, size, TRUE ); + print_clr_blob_idx( ptr, size ); + print_clr_string_idx( ptr, size ); + print_clr_string_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_assemblyrefprocessor( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Processor", "AssemblyRef", NULL }; + UINT i, row = 1;
- printf( " AssemblyRefProcessor table\n" ); - printf( " Processor AssemblyRef\n" ); + print_clr( "AssemblyRefProcessor table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_assemblyrefos( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "OSPlatformId", "OSMajorVersion", "OSMinorVersion", "AssemblyRef", NULL }; + UINT i, row = 1;
- printf( " AssemblyRefOS table\n" ); - printf( " OSPlatformId OSMajorVersion OSMinorVersion AssemblyRef\n" ); + print_clr( "AssemblyRefOS table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_uint( " ", ptr, size, FALSE ); - print_clr_uint( " ", ptr, size, FALSE ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); + print_clr_uint( ptr, size, FALSE ); + print_clr_uint( ptr, size, FALSE ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_file( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Flags", "Name", "HashValue", NULL }; + UINT i, row = 1;
- printf( " File table\n" ); - printf( " Flags Name HashValue\n" ); + print_clr( "File table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_string_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); + print_clr_string_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_exportedtype( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Flags", "TypeDefId", "TypeName", "TypeNamespace", "Implementation", NULL }; + UINT i, row = 1;
- printf( " ExportedType table\n" ); - printf( " Flags TypeDefId TypeName TypeNamespace Implementation\n" ); + print_clr( "ExportedType table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_string_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, TRUE ); + print_clr_uint( ptr, size, TRUE ); + print_clr_string_idx( ptr, size ); + print_clr_string_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_manifestresource( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Offset", "Flags", "Name", "Implementation", NULL }; + UINT i, row = 1;
- printf( " ManifestResource table\n" ); - printf( " Offset Flags Name Implementation\n" ); + print_clr( "ManifestResource table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_uint( " ", ptr, size, FALSE ); - print_clr_uint( " ", ptr, size, TRUE ); - print_clr_string_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_uint( ptr, size, FALSE ); + print_clr_uint( ptr, size, TRUE ); + print_clr_string_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_nestedclass( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "NestedClass", "EnclosingClass", NULL }; + UINT i, row = 1;
- printf( " NestedClass table\n" ); - printf( " NestedClass EnclosingClass\n" ); + print_clr( "NestedClass table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_table_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_table_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_genericparam( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Number", "Flags", "Owner", "Name", NULL }; + UINT i, row = 1;
- printf( " GenericParam table\n" ); - printf( " Number Flags Owner Name\n" ); + print_clr( "GenericParam table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_ushort( " ", ptr, size, FALSE ); - print_clr_ushort( " ", ptr, size, TRUE ); - print_clr_table_idx( " ", ptr, size ); - print_clr_string_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_ushort( ptr, size, FALSE ); + print_clr_ushort( ptr, size, TRUE ); + print_clr_table_idx( ptr, size ); + print_clr_string_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_methodspec( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Method", "Instantiation", NULL }; + UINT i, row = 1;
- printf( " MethodSpec table\n" ); - printf( " Method Instantiation\n" ); + print_clr( "MethodSpec table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
static void print_clr_table_genericparamconstraint( const BYTE **ptr, UINT *size, UINT row_count ) { - UINT i; + static const char * const header[] = { "Owner", "Constraint", NULL }; + UINT i, row = 1;
- printf( " GenericParamConstraint table\n" ); - printf( " Owner Constraint\n" ); + print_clr( "GenericParamConstraint table\n" ); + clr_indent += 4; + print_clr_table_header( header ); for (i = 0; i < row_count; i++) { - print_clr_table_idx( " ", ptr, size ); - print_clr_blob_idx( " ", ptr, size ); + print_clr_row( row++ ); + print_clr_table_idx( ptr, size ); + print_clr_blob_idx( ptr, size ); printf( "\n" ); } + clr_indent -= 4; }
enum @@ -3534,39 +3766,52 @@ static void print_clr_tables( const BYTE *data, UINT data_size ) const UINT *row_count; UINT64 valid, j;
- print_clr_uint( " Reserved ", &ptr, &size, FALSE ); + if (!data_size) return; + + clr_indent += 4; + print_clr( "Reserved " ); + print_clr_uint( &ptr, &size, FALSE ); printf( "\n" ); - print_clr_byte( " MajorVersion ", &ptr, &size, FALSE ); + print_clr( "MajorVersion " ); + print_clr_byte( &ptr, &size, FALSE ); printf( "\n" ); - print_clr_byte( " MinorVersion ", &ptr, &size, FALSE ); + print_clr( "MinorVersion " ); + print_clr_byte( &ptr, &size, FALSE ); printf( "\n" );
if (size < 1) return; heap_sizes = *ptr; - print_clr_byte( " HeapSizes ", &ptr, &size, TRUE ); + print_clr( "HeapSizes " ); + print_clr_byte( &ptr, &size, TRUE ); printf( "\n" ); if (heap_sizes & HEAP_SIZE_FLAG_STRING) str_idx_size = 4; if (heap_sizes & HEAP_SIZE_FLAG_GUID) guid_idx_size = 4; if (heap_sizes & HEAP_SIZE_FLAG_BLOB) blob_idx_size = 4;
- print_clr_byte( " Reserved ", &ptr, &size, FALSE ); + print_clr( "Reserved " ); + print_clr_byte( &ptr, &size, FALSE ); printf( "\n" );
if (size < sizeof(UINT64)) return; valid = *(UINT64 *)ptr; - print_clr_uint64( " Valid ", &ptr, &size ); + print_clr( "Valid " ); + print_clr_uint64( &ptr, &size ); printf( "\n" ); for (j = 0; j < sizeof(valid) * 8; j++) if (valid & (1ul << j)) count++;
- print_clr_uint64( " Sorted ", &ptr, &size ); + print_clr( "Sorted " ); + print_clr_uint64( &ptr, &size ); printf( "\n" ); + clr_indent -= 4;
row_count = (const UINT *)ptr; - if (count) printf( " Row counts\n" ); + if (count) print_clr( "Row counts\n" ); for (i = 0; i < count; i++) { - printf( " %-10u", i ); - print_clr_uint( " ", &ptr, &size, FALSE ); + clr_indent += 4; + print_clr_indent(); + print_clr_uint( &ptr, &size, FALSE ); + clr_indent -= 4; printf( "\n" ); }
@@ -3710,25 +3955,52 @@ static void print_clr_stream( const BYTE *base, const BYTE **ptr, UINT *size )
if (*size < sizeof(UINT)) return; stream_offset = *(const UINT *)*ptr; - print_clr_uint( " Offset ", ptr, size, FALSE ); + print_clr( "Offset " ); + print_clr_uint( ptr, size, FALSE ); printf( "\n" );
if (*size < sizeof(UINT)) return; stream_size = *(const UINT *)*ptr; - print_clr_uint( " Size ", ptr, size, FALSE ); + print_clr( "Size " ); + print_clr_uint( ptr, size, FALSE ); printf( "\n" );
if (!memchr( *ptr, '\0', *size )) return; name = (const char *)*ptr; - printf( " Name %s\n", name ); + print_clr( "Name " ); + printf( "%s\n", name ); len = ((strlen( name ) + 1) + 3) & ~3; if (*size < len) return; *ptr += len; *size -= len;
- if (!strcmp( name, "#Strings" )) print_clr_strings( base + stream_offset, stream_size ); - else if (!strcmp( name, "#US" ) || !strcmp( name, "#Blob" )) print_clr_blobs( base + stream_offset, stream_size ); - else if (!strcmp( name, "#GUID" )) print_clr_guids( base + stream_offset, stream_size ); - else if (!strcmp( name, "#~" )) print_clr_tables( base + stream_offset, stream_size ); + if (!strcmp( name, "#Strings" )) + { + strings.data = base + stream_offset; + strings.size = stream_size; + /* remove padding */ + while (strings.size > 1 && !strings.data[strings.size -2] && !strings.data[strings.size - 1]) + strings.size--; + } + else if (!strcmp( name, "#US" )) + { + userstrings.data = base + stream_offset; + userstrings.size = stream_size; + } + else if (!strcmp( name, "#Blob" )) + { + blobs.data = base + stream_offset; + blobs.size = stream_size; + } + else if (!strcmp( name, "#GUID" )) + { + guids.data = base + stream_offset; + guids.size = stream_size; + } + else if (!strcmp( name, "#~" )) + { + tables.data = base + stream_offset; + tables.size = stream_size; + } }
static void print_clr_metadata( const BYTE *data, UINT data_size ) @@ -3737,36 +4009,57 @@ static void print_clr_metadata( const BYTE *data, UINT data_size ) UINT size = data_size, len, nb_streams, i; const char *version;
- print_clr_uint( " Signature ", &ptr, &size, TRUE ); + print_clr( "Signature " ); + print_clr_uint( &ptr, &size, TRUE ); printf( "\n" ); - print_clr_ushort( " MajorVersion ", &ptr, &size, FALSE ); + print_clr( "MajorVersion " ); + print_clr_ushort( &ptr, &size, FALSE ); printf( "\n" ); - print_clr_ushort( " MinorVersion ", &ptr, &size, FALSE ); + print_clr( "MinorVersion " ); + print_clr_ushort( &ptr, &size, FALSE ); printf( "\n" ); - print_clr_uint( " Reserved ", &ptr, &size, FALSE ); + print_clr( "Reserved " ); + print_clr_uint( &ptr, &size, FALSE ); printf( "\n" );
if (size < sizeof(UINT)) return; len = *(const UINT *)ptr; - print_clr_uint( " Length ", &ptr, &size, FALSE ); + print_clr( "Length " ); + print_clr_uint( &ptr, &size, FALSE ); printf( "\n" );
if (size < len || !memchr( ptr, '\0', len )) return; version = (const char *)ptr; - printf( " Version %s\n", version ); + print_clr( "Version " ); + printf( "%s\n", version ); len = ((strlen( version ) + 1) + 3) & ~3; if (size < len) return; ptr += len; size -= len;
- print_clr_ushort( " Flags ", &ptr, &size, TRUE ); + print_clr( "Flags " ); + print_clr_ushort( &ptr, &size, TRUE ); printf( "\n" );
if (size < sizeof(USHORT)) return; nb_streams = *(const USHORT *)ptr; - print_clr_ushort( " Streams ", &ptr, &size, FALSE ); + print_clr( "Streams " ); + print_clr_ushort( &ptr, &size, FALSE ); printf( "\n" );
+ clr_indent += 4; for (i = 0; i < nb_streams; i++) print_clr_stream( data, &ptr, &size ); + clr_indent -= 4; + + print_clr( "Tables\n" ); + print_clr_tables( tables.data, tables.size ); + print_clr( "Strings\n" ); + print_clr_strings( strings.data, strings.size ); + print_clr( "Userstrings\n" ); + print_clr_blobs( userstrings.data, userstrings.size ); + print_clr( "GUIDs\n" ); + print_clr_guids( guids.data, guids.size ); + print_clr( "Blobs\n" ); + print_clr_blobs( blobs.data, blobs.size ); }
static void dump_dir_clr_header(void)