2 * pedump.c: Dumps the contents of an extended PE/COFF file
5 * Miguel de Icaza (miguel@ximian.com)
7 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
8 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
9 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
15 #include <mono/metadata/image.h>
17 #include <mono/metadata/cil-coff.h>
18 #include <mono/metadata/mono-endian.h>
19 #include <mono/metadata/verify.h>
20 #include <mono/metadata/class.h>
21 #include <mono/metadata/debug-helpers.h>
22 #include <mono/metadata/tokentype.h>
23 #include <mono/metadata/appdomain.h>
24 #include <mono/metadata/assembly.h>
25 #include <mono/metadata/metadata-internals.h>
26 #include <mono/metadata/class-internals.h>
27 #include <mono/metadata/verify-internals.h>
28 #include <mono/metadata/marshal.h>
29 #include "mono/utils/mono-digest.h"
30 #include <mono/utils/mono-mmap.h>
31 #include <mono/utils/mono-counters.h>
32 #include <sys/types.h>
38 gboolean dump_data
= TRUE
;
39 gboolean verify_pe
= FALSE
;
40 gboolean verify_metadata
= FALSE
;
41 gboolean verify_code
= FALSE
;
42 gboolean verify_partial_md
= FALSE
;
44 static MonoAssembly
*pedump_preload (MonoAssemblyName
*aname
, gchar
**assemblies_path
, gpointer user_data
);
45 static void pedump_assembly_load_hook (MonoAssembly
*assembly
, gpointer user_data
);
46 static MonoAssembly
*pedump_assembly_search_hook (MonoAssemblyName
*aname
, gpointer user_data
);
50 hex_dump (const char *buffer, int base, int count)
54 for (i = 0; i < count; i++){
56 printf ("\n0x%08x: ", (unsigned char) base + i);
58 printf ("%02x ", (unsigned char) (buffer [i]));
64 hex8 (const char *label
, unsigned char x
)
66 printf ("\t%s: 0x%02x\n", label
, (unsigned char) x
);
70 hex16 (const char *label
, guint16 x
)
72 printf ("\t%s: 0x%04x\n", label
, x
);
76 hex32 (const char *label
, guint32 x
)
78 printf ("\t%s: 0x%08x\n", label
, x
);
82 dump_coff_header (MonoCOFFHeader
*coff
)
84 printf ("\nCOFF Header:\n");
85 hex16 (" Machine", coff
->coff_machine
);
86 hex16 (" Sections", coff
->coff_sections
);
87 hex32 (" Time stamp", coff
->coff_time
);
88 hex32 ("Pointer to Symbol Table", coff
->coff_symptr
);
89 hex32 (" Symbol Count", coff
->coff_symcount
);
90 hex16 (" Optional Header Size", coff
->coff_opt_header_size
);
91 hex16 (" Characteristics", coff
->coff_attributes
);
96 dump_pe_header (MonoPEHeader
*pe
)
98 printf ("\nPE Header:\n");
99 hex16 (" Magic (0x010b)", pe
->pe_magic
);
100 hex8 (" LMajor (6)", pe
->pe_major
);
101 hex8 (" LMinor (0)", pe
->pe_minor
);
102 hex32 (" Code Size", pe
->pe_code_size
);
103 hex32 (" Initialized Data Size", pe
->pe_data_size
);
104 hex32 ("Uninitialized Data Size", pe
->pe_uninit_data_size
);
105 hex32 (" Entry Point RVA", pe
->pe_rva_entry_point
);
106 hex32 (" Code Base RVA", pe
->pe_rva_code_base
);
107 hex32 (" Data Base RVA", pe
->pe_rva_data_base
);
112 dump_nt_header (MonoPEHeaderNT
*nt
)
114 printf ("\nNT Header:\n");
116 hex32 (" Image Base (0x400000)", nt
->pe_image_base
);
117 hex32 ("Section Alignment (8192)", nt
->pe_section_align
);
118 hex32 (" File Align (512/4096)", nt
->pe_file_alignment
);
119 hex16 (" OS Major (4)", nt
->pe_os_major
);
120 hex16 (" OS Minor (0)", nt
->pe_os_minor
);
121 hex16 (" User Major (0)", nt
->pe_user_major
);
122 hex16 (" User Minor (0)", nt
->pe_user_minor
);
123 hex16 (" Subsys major (4)", nt
->pe_subsys_major
);
124 hex16 (" Subsys minor (0)", nt
->pe_subsys_minor
);
125 hex32 (" Reserverd", nt
->pe_reserved_1
);
126 hex32 (" Image Size", nt
->pe_image_size
);
127 hex32 (" Header Size", nt
->pe_header_size
);
128 hex32 (" Checksum (0)", nt
->pe_checksum
);
129 hex16 (" Subsystem", nt
->pe_subsys_required
);
130 hex16 (" DLL Flags (0)", nt
->pe_dll_flags
);
131 hex32 (" Stack Reserve Size (1M)", nt
->pe_stack_reserve
);
132 hex32 ("Stack commit Size (4096)", nt
->pe_stack_commit
);
133 hex32 (" Heap Reserve Size (1M)", nt
->pe_heap_reserve
);
134 hex32 (" Heap Commit Size (4096)", nt
->pe_heap_commit
);
135 hex32 (" Loader flags (0x1)", nt
->pe_loader_flags
);
136 hex32 (" Data Directories (16)", nt
->pe_data_dir_count
);
140 dent (const char *label
, MonoPEDirEntry de
)
142 printf ("\t%s: 0x%08x [0x%08x]\n", label
, de
.rva
, de
.size
);
146 dump_blob (const char *desc
, const char* p
, guint32 size
)
156 for (i
= 0; i
< size
; ++i
) {
159 printf (" %02X", p
[i
] & 0xFF);
165 dump_public_key (MonoImage
*m
)
170 p
= mono_image_get_public_key (m
, &size
);
171 dump_blob ("\nPublic key:", p
, size
);
175 dump_strong_name (MonoImage
*m
)
180 p
= mono_image_get_strong_name (m
, &size
);
181 dump_blob ("\nStrong name:", p
, size
);
185 dump_datadir (MonoPEDatadir
*dd
)
187 printf ("\nData directories:\n");
188 dent (" Export Table", dd
->pe_export_table
);
189 dent (" Import Table", dd
->pe_import_table
);
190 dent (" Resource Table", dd
->pe_resource_table
);
191 dent (" Exception Table", dd
->pe_exception_table
);
192 dent ("Certificate Table", dd
->pe_certificate_table
);
193 dent (" Reloc Table", dd
->pe_reloc_table
);
194 dent (" Debug", dd
->pe_debug
);
195 dent (" Copyright", dd
->pe_copyright
);
196 dent (" Global Ptr", dd
->pe_global_ptr
);
197 dent (" TLS Table", dd
->pe_tls_table
);
198 dent ("Load Config Table", dd
->pe_load_config_table
);
199 dent (" Bound Import", dd
->pe_bound_import
);
200 dent (" IAT", dd
->pe_iat
);
201 dent ("Delay Import Desc", dd
->pe_delay_import_desc
);
202 dent (" CLI Header", dd
->pe_cli_header
);
206 dump_dotnet_header (MonoDotNetHeader
*header
)
208 dump_coff_header (&header
->coff
);
209 dump_pe_header (&header
->pe
);
210 dump_nt_header (&header
->nt
);
211 dump_datadir (&header
->datadir
);
215 dump_section_table (MonoSectionTable
*st
)
217 guint32 flags
= st
->st_flags
;
219 printf ("\n\tName: %s\n", st
->st_name
);
220 hex32 (" Virtual Size", st
->st_virtual_size
);
221 hex32 ("Virtual Address", st
->st_virtual_address
);
222 hex32 (" Raw Data Size", st
->st_raw_data_size
);
223 hex32 (" Raw Data Ptr", st
->st_raw_data_ptr
);
224 hex32 (" Reloc Ptr", st
->st_reloc_ptr
);
225 hex32 (" LineNo Ptr", st
->st_lineno_ptr
);
226 hex16 (" Reloc Count", st
->st_reloc_count
);
227 hex16 (" Line Count", st
->st_line_count
);
229 printf ("\tFlags: %s%s%s%s%s%s%s%s%s%s\n",
230 (flags
& SECT_FLAGS_HAS_CODE
) ? "code, " : "",
231 (flags
& SECT_FLAGS_HAS_INITIALIZED_DATA
) ? "data, " : "",
232 (flags
& SECT_FLAGS_HAS_UNINITIALIZED_DATA
) ? "bss, " : "",
233 (flags
& SECT_FLAGS_MEM_DISCARDABLE
) ? "discard, " : "",
234 (flags
& SECT_FLAGS_MEM_NOT_CACHED
) ? "nocache, " : "",
235 (flags
& SECT_FLAGS_MEM_NOT_PAGED
) ? "nopage, " : "",
236 (flags
& SECT_FLAGS_MEM_SHARED
) ? "shared, " : "",
237 (flags
& SECT_FLAGS_MEM_EXECUTE
) ? "exec, " : "",
238 (flags
& SECT_FLAGS_MEM_READ
) ? "read, " : "",
239 (flags
& SECT_FLAGS_MEM_WRITE
) ? "write" : "");
243 dump_sections (MonoCLIImageInfo
*iinfo
)
245 const int top
= iinfo
->cli_header
.coff
.coff_sections
;
248 for (i
= 0; i
< top
; i
++)
249 dump_section_table (&iinfo
->cli_section_tables
[i
]);
253 dump_cli_header (MonoCLIHeader
*ch
)
256 printf (" CLI header size: %d\n", ch
->ch_size
);
257 printf (" Runtime required: %d.%d\n", ch
->ch_runtime_major
, ch
->ch_runtime_minor
);
258 printf (" Flags: %s, %s, %s, %s\n",
259 (ch
->ch_flags
& CLI_FLAGS_ILONLY
? "ilonly" : "contains native"),
260 (ch
->ch_flags
& CLI_FLAGS_32BITREQUIRED
? "32bits" : "32/64"),
261 (ch
->ch_flags
& CLI_FLAGS_TRACKDEBUGDATA
? "trackdebug" : "no-trackdebug"),
262 (ch
->ch_flags
& CLI_FLAGS_STRONGNAMESIGNED
? "strongnamesigned" : "notsigned"));
263 dent (" Metadata", ch
->ch_metadata
);
264 hex32 ("Entry Point Token", ch
->ch_entry_point
);
265 dent (" Resources at", ch
->ch_resources
);
266 dent (" Strong Name at", ch
->ch_strong_name
);
267 dent (" Code Manager at", ch
->ch_code_manager_table
);
268 dent (" VTableFixups at", ch
->ch_vtable_fixups
);
269 dent (" EAT jumps at", ch
->ch_export_address_table_jumps
);
273 dsh (const char *label
, MonoImage
*meta
, MonoStreamHeader
*sh
)
275 printf ("%s: 0x%08x - 0x%08x [%d == 0x%08x]\n",
277 (int)(sh
->data
- meta
->raw_metadata
), (int)(sh
->data
+ sh
->size
- meta
->raw_metadata
),
282 dump_metadata_header (MonoImage
*meta
)
284 printf ("\nMetadata header:\n");
285 printf (" Version: %d.%d\n", meta
->md_version_major
, meta
->md_version_minor
);
286 printf (" Version string: %s\n", meta
->version
);
290 dump_metadata_ptrs (MonoImage
*meta
)
292 printf ("\nMetadata pointers:\n");
293 dsh ("\tTables (#~)", meta
, &meta
->heap_tables
);
294 dsh ("\t Strings", meta
, &meta
->heap_strings
);
295 dsh ("\t Blob", meta
, &meta
->heap_blob
);
296 dsh ("\tUser string", meta
, &meta
->heap_us
);
297 dsh ("\t GUID", meta
, &meta
->heap_guid
);
301 dump_metadata (MonoImage
*meta
)
305 dump_metadata_header (meta
);
307 dump_metadata_ptrs (meta
);
310 for (table
= 0; table
< MONO_TABLE_NUM
; table
++){
311 if (meta
->tables
[table
].rows
== 0)
313 printf ("Table %s: %d records (%d bytes, at %x)\n",
314 mono_meta_table_name (table
),
315 meta
->tables
[table
].rows
,
316 meta
->tables
[table
].row_size
,
317 (unsigned int)(meta
->tables
[table
].base
- meta
->raw_data
)
323 dump_methoddef (MonoImage
*metadata
, guint32 token
)
329 loc
= mono_metadata_locate_token (metadata
, token
);
331 printf ("RVA for Entry Point: 0x%08x\n", read32 (loc
));
335 dump_dotnet_iinfo (MonoImage
*image
)
337 MonoCLIImageInfo
*iinfo
= (MonoCLIImageInfo
*)image
->image_info
;
339 dump_dotnet_header (&iinfo
->cli_header
);
340 dump_sections (iinfo
);
341 dump_cli_header (&iinfo
->cli_cli_header
);
342 dump_strong_name (image
);
343 dump_public_key (image
);
344 dump_metadata (image
);
346 dump_methoddef (image
, iinfo
->cli_cli_header
.ch_entry_point
);
350 dump_verify_info (MonoImage
*image
, int flags
)
352 GSList
*errors
, *tmp
;
353 int count
= 0, verifiable
= 0;
354 const char* desc
[] = {
355 "Ok", "Error", "Warning", NULL
, "CLS", NULL
, NULL
, NULL
, "Not Verifiable"
358 if (verify_code
) { /* verify code */
360 MonoTableInfo
*m
= &image
->tables
[MONO_TABLE_METHOD
];
362 for (i
= 0; i
< m
->rows
; ++i
) {
366 method
= mono_get_method_checked (image
, MONO_TOKEN_METHOD_DEF
| (i
+1), NULL
, NULL
, &error
);
368 g_print ("Warning: Cannot lookup method with token 0x%08x due to %s\n", i
+ 1, mono_error_get_message (&error
));
369 mono_error_cleanup (&error
);
372 errors
= mono_method_verify (method
, flags
);
374 MonoClass
*klass
= mono_method_get_class (method
);
375 char *name
= mono_type_full_name (&klass
->byval_arg
);
376 if (mono_method_signature (method
) == NULL
) {
377 g_print ("In method: %s::%s(ERROR)\n", name
, mono_method_get_name (method
));
380 sig
= mono_signature_get_desc (mono_method_signature (method
), FALSE
);
381 g_print ("In method: %s::%s(%s)\n", name
, mono_method_get_name (method
), sig
);
387 for (tmp
= errors
; tmp
; tmp
= tmp
->next
) {
388 MonoVerifyInfo
*info
= (MonoVerifyInfo
*)tmp
->data
;
389 g_print ("%s: %s\n", desc
[info
->status
], info
->message
);
390 if (info
->status
== MONO_VERIFY_ERROR
) {
394 if(info
->status
== MONO_VERIFY_NOT_VERIFIABLE
) {
399 mono_free_verify_list (errors
);
404 g_print ("Error count: %d\n", count
);
411 printf ("Usage is: pedump [--verify error,warn,cls,all,code,fail-on-verifiable,non-strict,valid-only,metadata] file.exe\n");
416 verify_image_file (const char *fname
)
418 GSList
*errors
= NULL
, *tmp
;
420 MonoTableInfo
*table
;
421 MonoAssembly
*assembly
;
422 MonoImageOpenStatus status
;
424 const char* desc
[] = {
425 "Ok", "Error", "Warning", NULL
, "CLS", NULL
, NULL
, NULL
, "Not Verifiable"
428 image
= mono_image_open_raw (fname
, &status
);
430 printf ("Could not open %s\n", fname
);
434 if (!mono_verifier_verify_pe_data (image
, &errors
))
437 if (!mono_image_load_pe_data (image
)) {
438 printf ("Could not load pe data for assembly %s\n", fname
);
442 if (!mono_verifier_verify_cli_data (image
, &errors
))
445 if (!mono_image_load_cli_data (image
)) {
446 printf ("Could not load cli data for assembly %s\n", fname
);
450 if (!mono_verifier_verify_table_data (image
, &errors
))
453 mono_image_load_names (image
);
455 /*fake an assembly for class loading to work*/
456 assembly
= g_new0 (MonoAssembly
, 1);
457 assembly
->in_gac
= FALSE
;
458 assembly
->image
= image
;
459 image
->assembly
= assembly
;
460 mono_assembly_fill_assembly_name (image
, &assembly
->aname
);
462 /*Finish initializing the runtime*/
463 mono_install_assembly_load_hook (pedump_assembly_load_hook
, NULL
);
464 mono_install_assembly_search_hook (pedump_assembly_search_hook
, NULL
);
466 mono_init_version ("pedump", image
->version
);
468 mono_install_assembly_preload_hook (pedump_preload
, GUINT_TO_POINTER (FALSE
));
471 mono_marshal_init ();
474 if (!verify_partial_md
&& !mono_verifier_verify_full_table_data (image
, &errors
))
478 table
= &image
->tables
[MONO_TABLE_TYPEDEF
];
479 for (i
= 1; i
<= table
->rows
; ++i
) {
481 guint32 token
= i
| MONO_TOKEN_TYPE_DEF
;
482 MonoClass
*klass
= mono_class_get_checked (image
, token
, &error
);
484 printf ("Could not load class with token %x due to %s\n", token
, mono_error_get_message (&error
));
485 mono_error_cleanup (&error
);
488 mono_class_init (klass
);
489 if (mono_class_has_failure (klass
)) {
490 printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token
, klass
->name_space
, klass
->name
);
494 mono_class_setup_vtable (klass
);
495 if (mono_class_has_failure (klass
)) {
496 printf ("Error verifying class(0x%08x) %s.%s a type load error happened\n", token
, klass
->name_space
, klass
->name
);
505 for (tmp
= errors
; tmp
; tmp
= tmp
->next
) {
506 MonoVerifyInfo
*info
= (MonoVerifyInfo
*)tmp
->data
;
507 g_print ("%s: %s\n", desc
[info
->status
], info
->message
);
508 if (info
->status
== MONO_VERIFY_ERROR
)
511 mono_free_verify_list (errors
);
513 g_print ("Error count: %d\n", count
);
518 try_load_from (MonoAssembly
**assembly
, const gchar
*path1
, const gchar
*path2
,
519 const gchar
*path3
, const gchar
*path4
, gboolean refonly
)
524 fullpath
= g_build_filename (path1
, path2
, path3
, path4
, NULL
);
525 if (g_file_test (fullpath
, G_FILE_TEST_IS_REGULAR
))
526 *assembly
= mono_assembly_open_full (fullpath
, NULL
, refonly
);
529 return (*assembly
!= NULL
);
532 static MonoAssembly
*
533 real_load (gchar
**search_path
, const gchar
*culture
, const gchar
*name
, gboolean refonly
)
535 MonoAssembly
*result
= NULL
;
538 const gchar
*local_culture
;
541 if (!culture
|| *culture
== '\0') {
544 local_culture
= culture
;
547 filename
= g_strconcat (name
, ".dll", NULL
);
548 len
= strlen (filename
);
550 for (path
= search_path
; *path
; path
++) {
552 continue; /* Ignore empty ApplicationBase */
554 /* See test cases in bug #58992 and bug #57710 */
555 /* 1st try: [culture]/[name].dll (culture may be empty) */
556 strcpy (filename
+ len
- 4, ".dll");
557 if (try_load_from (&result
, *path
, local_culture
, "", filename
, refonly
))
560 /* 2nd try: [culture]/[name].exe (culture may be empty) */
561 strcpy (filename
+ len
- 4, ".exe");
562 if (try_load_from (&result
, *path
, local_culture
, "", filename
, refonly
))
565 /* 3rd try: [culture]/[name]/[name].dll (culture may be empty) */
566 strcpy (filename
+ len
- 4, ".dll");
567 if (try_load_from (&result
, *path
, local_culture
, name
, filename
, refonly
))
570 /* 4th try: [culture]/[name]/[name].exe (culture may be empty) */
571 strcpy (filename
+ len
- 4, ".exe");
572 if (try_load_from (&result
, *path
, local_culture
, name
, filename
, refonly
))
581 * Try to load referenced assemblies from assemblies_path.
583 static MonoAssembly
*
584 pedump_preload (MonoAssemblyName
*aname
,
585 gchar
**assemblies_path
,
588 MonoAssembly
*result
= NULL
;
589 gboolean refonly
= GPOINTER_TO_UINT (user_data
);
591 if (assemblies_path
&& assemblies_path
[0] != NULL
) {
592 result
= real_load (assemblies_path
, aname
->culture
, aname
->name
, refonly
);
598 static GList
*loaded_assemblies
= NULL
;
601 pedump_assembly_load_hook (MonoAssembly
*assembly
, gpointer user_data
)
603 loaded_assemblies
= g_list_prepend (loaded_assemblies
, assembly
);
606 static MonoAssembly
*
607 pedump_assembly_search_hook (MonoAssemblyName
*aname
, gpointer user_data
)
611 for (tmp
= loaded_assemblies
; tmp
; tmp
= tmp
->next
) {
612 MonoAssembly
*ass
= (MonoAssembly
*)tmp
->data
;
613 if (mono_assembly_names_equal (aname
, &ass
->aname
))
619 #define VALID_ONLY_FLAG 0x08000000
620 #define VERIFY_CODE_ONLY MONO_VERIFY_ALL + 1
621 #define VERIFY_METADATA_ONLY VERIFY_CODE_ONLY + 1
622 #define VERIFY_PARTIAL_METADATA VERIFY_CODE_ONLY + 2
625 main (int argc
, char *argv
[])
627 int image_result
= 0;
631 MiniVerifierMode verifier_mode
= MONO_VERIFIER_MODE_VERIFIABLE
;
632 const char *flag_desc
[] = {"error", "warn", "cls", "all", "code", "fail-on-verifiable", "non-strict", "valid-only", "metadata", "partial-md", NULL
};
633 guint flag_vals
[] = {MONO_VERIFY_ERROR
, MONO_VERIFY_WARNING
, MONO_VERIFY_CLS
, MONO_VERIFY_ALL
, VERIFY_CODE_ONLY
, MONO_VERIFY_FAIL_FAST
, MONO_VERIFY_NON_STRICT
, VALID_ONLY_FLAG
, VERIFY_METADATA_ONLY
, VERIFY_PARTIAL_METADATA
, 0};
634 int i
, verify_flags
= MONO_VERIFY_REPORT_ALL_ERRORS
, run_new_metadata_verifier
= 0;
636 for (i
= 1; i
< argc
; i
++){
637 if (argv
[i
][0] != '-'){
642 if (strcmp (argv
[i
], "--help") == 0)
644 else if (strcmp (argv
[i
], "--verify") == 0) {
657 #ifndef DISABLE_PERFCOUNTERS
658 mono_perfcounters_init ();
660 mono_counters_init ();
661 mono_metadata_init ();
663 mono_assemblies_init ();
667 char *tok
= strtok (flags
, ",");
672 for (i
= 0; flag_desc
[i
]; ++i
) {
673 if (strcmp (tok
, flag_desc
[i
]) == 0) {
674 if (flag_vals
[i
] == VERIFY_CODE_ONLY
) {
677 } else if(flag_vals
[i
] == MONO_VERIFY_ALL
) {
679 } else if(flag_vals
[i
] == VERIFY_METADATA_ONLY
) {
681 run_new_metadata_verifier
= 1;
682 } else if(flag_vals
[i
] == VERIFY_PARTIAL_METADATA
) {
683 verify_partial_md
= 1;
685 if (flag_vals
[i
] == VALID_ONLY_FLAG
)
686 verifier_mode
= MONO_VERIFIER_MODE_VALID
;
688 verify_flags
|= flag_vals
[i
];
693 g_print ("Unknown verify flag %s\n", tok
);
694 tok
= strtok (NULL
, ",");
697 mono_verifier_set_mode (verifier_mode
);
701 if (verify_pe
|| run_new_metadata_verifier
) {
702 run_new_metadata_verifier
= 1;
705 if (run_new_metadata_verifier
) {
706 mono_verifier_set_mode (verifier_mode
);
708 image_result
= verify_image_file (file
);
709 if (image_result
== 1 || !verify_code
)
713 image
= mono_image_open (file
, NULL
);
715 fprintf (stderr
, "Cannot open image %s\n", file
);
720 dump_dotnet_iinfo (image
);
722 MonoAssembly
*assembly
;
724 MonoImageOpenStatus status
;
727 mono_verifier_set_mode (verifier_mode
);
729 assembly
= mono_assembly_open (file
, NULL
);
730 /*fake an assembly for netmodules so the verifier works*/
731 if (!assembly
&& (image
= mono_image_open (file
, &status
)) && image
->tables
[MONO_TABLE_ASSEMBLY
].rows
== 0) {
732 assembly
= g_new0 (MonoAssembly
, 1);
733 assembly
->in_gac
= FALSE
;
734 assembly
->image
= image
;
735 image
->assembly
= assembly
;
739 g_print ("Could not open assembly %s\n", file
);
743 code_result
= dump_verify_info (assembly
->image
, verify_flags
);
744 return code_result
? code_result
: image_result
;
746 mono_image_close (image
);