| /* od-pe.c -- dump information about a PE object file. | |
| Copyright (C) 2011-2026 Free Software Foundation, Inc. | |
| Written by Tristan Gingold, Adacore and Nick Clifton, Red Hat. | |
| This file is part of GNU Binutils. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 3, or (at your option) | |
| any later version. | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with this program; if not, write to the Free Software | |
| Foundation, 51 Franklin Street - Fifth Floor, Boston, | |
| MA 02110-1301, USA. */ | |
| #include "sysdep.h" | |
| #include <stddef.h> | |
| #include <time.h> | |
| #include "safe-ctype.h" | |
| #include "bfd.h" | |
| #include "objdump.h" | |
| #include "bucomm.h" | |
| #include "bfdlink.h" | |
| #include "coff/internal.h" | |
| #define L_LNNO_SIZE 4 /* FIXME: which value should we use ? */ | |
| #include "coff/external.h" | |
| #include "coff/pe.h" | |
| #include "libcoff.h" | |
| #include "libpei.h" | |
| #include "libiberty.h" | |
| /* Index of the options in the options[] array. */ | |
| #define OPT_FILE_HEADER 0 | |
| #define OPT_AOUT 1 | |
| #define OPT_SECTIONS 2 | |
| #define OPT_SYMS 3 | |
| #define OPT_RELOCS 4 | |
| #define OPT_LINENO 5 | |
| #define OPT_LOADER 6 | |
| #define OPT_EXCEPT 7 | |
| #define OPT_TYPCHK 8 | |
| #define OPT_TRACEBACK 9 | |
| #define OPT_TOC 10 | |
| #define OPT_LDINFO 11 | |
| /* List of actions. */ | |
| static struct objdump_private_option options[] = | |
| { | |
| { "header", 0 }, | |
| { "aout", 0 }, | |
| { "sections", 0 }, | |
| { "syms", 0 }, | |
| { "relocs", 0 }, | |
| { "lineno", 0 }, | |
| { "loader", 0 }, | |
| { "except", 0 }, | |
| { "typchk", 0 }, | |
| { "traceback", 0 }, | |
| { "toc", 0 }, | |
| { "ldinfo", 0 }, | |
| { NULL, 0 } | |
| }; | |
| /* Simplified section header. */ | |
| struct pe_section | |
| { | |
| /* NUL terminated name. */ | |
| char name[9]; | |
| /* Section flags. */ | |
| unsigned int flags; | |
| /* Offsets in file. */ | |
| ufile_ptr scnptr; | |
| ufile_ptr relptr; | |
| ufile_ptr lnnoptr; | |
| /* Number of relocs and line numbers. */ | |
| unsigned int nreloc; | |
| unsigned int nlnno; | |
| }; | |
| /* Translation entry type. The last entry must be {0, NULL}. */ | |
| struct xlat_table | |
| { | |
| unsigned int val; | |
| const char * name; | |
| }; | |
| /* PE file flags. */ | |
| static const struct xlat_table file_flag_xlat[] = | |
| { | |
| { IMAGE_FILE_RELOCS_STRIPPED, "RELOCS STRIPPED"}, | |
| { IMAGE_FILE_EXECUTABLE_IMAGE, "EXECUTABLE"}, | |
| { IMAGE_FILE_LINE_NUMS_STRIPPED, "LINE NUMS STRIPPED"}, | |
| { IMAGE_FILE_LOCAL_SYMS_STRIPPED, "LOCAL SYMS STRIPPED"}, | |
| { IMAGE_FILE_AGGRESSIVE_WS_TRIM, "AGGRESSIVE WS TRIM"}, | |
| { IMAGE_FILE_LARGE_ADDRESS_AWARE, "LARGE ADDRESS AWARE"}, | |
| { IMAGE_FILE_16BIT_MACHINE, "16BIT MACHINE"}, | |
| { IMAGE_FILE_BYTES_REVERSED_LO, "BYTES REVERSED LO"}, | |
| { IMAGE_FILE_32BIT_MACHINE, "32BIT MACHINE"}, | |
| { IMAGE_FILE_DEBUG_STRIPPED, "DEBUG STRIPPED"}, | |
| { IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP, "REMOVABLE RUN FROM SWAP"}, | |
| { IMAGE_FILE_NET_RUN_FROM_SWAP, "NET RUN FROM SWAP"}, | |
| { IMAGE_FILE_SYSTEM, "SYSTEM"}, | |
| { IMAGE_FILE_DLL, "DLL"}, | |
| { IMAGE_FILE_UP_SYSTEM_ONLY, "UP SYSTEM ONLY"}, | |
| { IMAGE_FILE_BYTES_REVERSED_HI, "BYTES REVERSED HI"}, | |
| { 0, NULL } | |
| }; | |
| /* PE section flags. */ | |
| static const struct xlat_table section_flag_xlat[] = | |
| { | |
| { IMAGE_SCN_MEM_DISCARDABLE, "DISCARDABLE" }, | |
| { IMAGE_SCN_MEM_EXECUTE, "EXECUTE" }, | |
| { IMAGE_SCN_MEM_READ, "READ" }, | |
| { IMAGE_SCN_MEM_WRITE, "WRITE" }, | |
| { IMAGE_SCN_TYPE_NO_PAD, "NO PAD" }, | |
| { IMAGE_SCN_CNT_CODE, "CODE" }, | |
| { IMAGE_SCN_CNT_INITIALIZED_DATA, "INITIALIZED DATA" }, | |
| { IMAGE_SCN_CNT_UNINITIALIZED_DATA, "UNINITIALIZED DATA" }, | |
| { IMAGE_SCN_LNK_OTHER, "OTHER" }, | |
| { IMAGE_SCN_LNK_INFO, "INFO" }, | |
| { IMAGE_SCN_LNK_REMOVE, "REMOVE" }, | |
| { IMAGE_SCN_LNK_COMDAT, "COMDAT" }, | |
| { IMAGE_SCN_MEM_FARDATA, "FARDATA" }, | |
| { IMAGE_SCN_MEM_PURGEABLE, "PURGEABLE" }, | |
| { IMAGE_SCN_MEM_LOCKED, "LOCKED" }, | |
| { IMAGE_SCN_MEM_PRELOAD, "PRELOAD" }, | |
| { IMAGE_SCN_LNK_NRELOC_OVFL, "NRELOC OVFL" }, | |
| { IMAGE_SCN_MEM_NOT_CACHED, "NOT CACHED" }, | |
| { IMAGE_SCN_MEM_NOT_PAGED, "NOT PAGED" }, | |
| { IMAGE_SCN_MEM_SHARED, "SHARED" }, | |
| { 0, NULL } | |
| }; | |
| typedef struct target_specific_info | |
| { | |
| unsigned int machine_number; | |
| const char * name; | |
| unsigned int aout_hdr_size; | |
| } target_specific_info; | |
| const struct target_specific_info targ_info[] = | |
| { | |
| { IMAGE_FILE_MACHINE_ALPHA, "ALPHA", 80 }, | |
| { IMAGE_FILE_MACHINE_ALPHA64, "ALPHA64", 80 }, | |
| { IMAGE_FILE_MACHINE_AM33, "AM33", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_AMD64, "AMD64", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_ARM, "ARM", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_ARM64, "ARM64", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_ARMNT, "ARM NT", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_CEE, "CEE", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_CEF, "CEF", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_EBC, "EBC", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_I386, "I386", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_IA64, "IA64", 108 }, | |
| { IMAGE_FILE_MACHINE_LOONGARCH64, "LOONGARCH64", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_M32R, "M32R", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_M68K, "M68K", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_MIPS16, "MIPS16", 56 }, | |
| { IMAGE_FILE_MACHINE_MIPSFPU, "MIPSFPU", 56 }, | |
| { IMAGE_FILE_MACHINE_MIPSFPU16, "MIPSFPU16", 56 }, | |
| { IMAGE_FILE_MACHINE_POWERPC, "POWERPC", 72 }, | |
| { IMAGE_FILE_MACHINE_POWERPCFP, "POWERPCFP", 72 }, | |
| { IMAGE_FILE_MACHINE_R10000, "R10000", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_R3000, "R3000", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_R4000, "R4000", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_SH3, "SH3", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_SH3DSP, "SH3DSP", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_SH3E, "SH3E", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_SH4, "SH4", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_SH5, "SH5", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_THUMB, "THUMB", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_TRICORE, "TRICORE", AOUTHDRSZ }, | |
| { IMAGE_FILE_MACHINE_WCEMIPSV2, "WCEMIPSV2", AOUTHDRSZ }, | |
| { 0x0093, "TI C4X", 28 }, | |
| { 0x00C1, "TI C4X", 28 }, | |
| { 0x00C2, "TI C4X", 28 }, | |
| { 0x0500, "SH (big endian)", AOUTHDRSZ }, | |
| { 0x0550, "SH (little endian)", AOUTHDRSZ }, | |
| { 0x0a00, "ARM", AOUTHDRSZ }, | |
| { 0x0b00, "MCore", AOUTHDRSZ } | |
| }; | |
| static const struct target_specific_info unknown_info = | |
| { 0, "unknown", AOUTHDRSZ }; | |
| static const struct target_specific_info * | |
| get_target_specific_info (unsigned int machine) | |
| { | |
| unsigned int i; | |
| for (i = ARRAY_SIZE (targ_info); i--;) | |
| if (targ_info[i].machine_number == machine) | |
| return targ_info + i; | |
| return &unknown_info; | |
| } | |
| /* Display help. */ | |
| static void | |
| pe_help (FILE *stream) | |
| { | |
| fprintf (stream, _("\ | |
| For PE files:\n\ | |
| header Display the file header\n\ | |
| sections Display the section headers\n\ | |
| ")); | |
| } | |
| /* Return true if ABFD is handled. */ | |
| static int | |
| pe_filter (bfd *abfd) | |
| { | |
| return bfd_get_flavour (abfd) == bfd_target_coff_flavour; | |
| } | |
| /* Return string representation of the platform id | |
| stored in upper 2 bits of Win32Version field. */ | |
| static const char * | |
| pe_platform_id_str (unsigned int platform_id) | |
| { | |
| static const char *const platform_id_str_table[4] = | |
| { "WinNT", "WinCE", "Win32s", "Win9x" }; | |
| return platform_id_str_table[platform_id & 0x3]; | |
| } | |
| /* Display the list of name (from TABLE) for FLAGS, using comma to | |
| separate them. A name is displayed if FLAGS & VAL is not 0. */ | |
| static void | |
| dump_flags (const struct xlat_table * table, unsigned int flags) | |
| { | |
| unsigned int r = flags; | |
| bool first = true; | |
| const struct xlat_table *t; | |
| for (t = table; t->name; t++) | |
| if ((flags & t->val) != 0) | |
| { | |
| r &= ~t->val; | |
| if (first) | |
| first = false; | |
| else | |
| putchar (','); | |
| fputs (t->name, stdout); | |
| } | |
| /* Undecoded flags. */ | |
| if (r != 0) | |
| { | |
| if (!first) | |
| putchar (','); | |
| printf (_("unknown: 0x%x"), r); | |
| } | |
| } | |
| /* Dump the file header. */ | |
| static void | |
| dump_pe_file_header (bfd * abfd, | |
| struct external_PEI_filehdr * fhdr, | |
| struct external_PEI_IMAGE_hdr * ihdr) | |
| { | |
| unsigned int data; | |
| unsigned long ldata; | |
| unsigned long ihdr_off = 0; | |
| if (fhdr == NULL) | |
| printf (_("\n File header not present\n")); | |
| else | |
| { | |
| printf (_("\n File Header (at offset 0):\n")); | |
| // The values of the following fields are normally fixed. | |
| // But we display them anyway, in case there are discrepancies. | |
| data = bfd_h_get_16 (abfd, fhdr->e_cblp); | |
| printf (_("Bytes on Last Page:\t\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_cp); | |
| printf (_("Pages In File:\t\t\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_crlc); | |
| printf (_("Relocations:\t\t\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_cparhdr); | |
| printf (_("Size of header in paragraphs:\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_minalloc); | |
| printf (_("Min extra paragraphs needed:\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_maxalloc); | |
| printf (_("Max extra paragraphs needed:\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_ss); | |
| printf (_("Initial (relative) SS value:\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_sp); | |
| printf (_("Initial SP value:\t\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_csum); | |
| printf (_("Checksum:\t\t\t%#x\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_ip); | |
| printf (_("Initial IP value:\t\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_cs); | |
| printf (_("Initial (relative) CS value:\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_lfarlc); | |
| printf (_("File address of reloc table:\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_ovno); | |
| printf (_("Overlay number:\t\t\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_oemid); | |
| printf (_("OEM identifier:\t\t\t%d\n"), data); | |
| data = bfd_h_get_16 (abfd, fhdr->e_oeminfo); | |
| printf (_("OEM information:\t\t%#x\n"), data); | |
| ldata = bfd_h_get_32 (abfd, fhdr->e_lfanew); | |
| printf (_("File address of new exe header:\t%#lx\n"), ldata); | |
| /* Display the first string found in the stub. | |
| FIXME: Look for more than one string ? | |
| FIXME: Strictly speaking we may not have read the full stub, since | |
| it can be longer than the dos_message array in the PEI_fileheader | |
| structure. */ | |
| const unsigned char * message = (const unsigned char *) fhdr->dos_message; | |
| unsigned int len = sizeof (fhdr->dos_message); | |
| unsigned int i; | |
| unsigned int seen_count = 0; | |
| unsigned int string_start = 0; | |
| for (i = 0; i < len; i++) | |
| { | |
| if (ISPRINT (message[i])) | |
| { | |
| if (string_start == 0) | |
| string_start = i; | |
| ++ seen_count; | |
| if (seen_count > 4) | |
| break; | |
| } | |
| else | |
| { | |
| seen_count = string_start = 0; | |
| } | |
| } | |
| if (seen_count > 4) | |
| { | |
| printf (_("Stub message:\t\t\t")); | |
| while (string_start < len) | |
| { | |
| char c = message[string_start ++]; | |
| if (! ISPRINT (c)) | |
| break; | |
| putchar (c); | |
| } | |
| putchar ('\n'); | |
| } | |
| ihdr_off = (long) bfd_h_get_32 (abfd, fhdr->e_lfanew); | |
| } | |
| printf (_("\n Image Header (at offset %#lx):\n"), ihdr_off); | |
| /* Note - we try to make this output use the same format as the output from -p. | |
| But since there are multiple headers to display and the order of the fields | |
| in the headers do not match the order of information displayed by -p, there | |
| are some discrepancies. */ | |
| unsigned int machine = (int) bfd_h_get_16 (abfd, ihdr->f_magic); | |
| printf (_("Machine Number:\t\t\t%#x\t\t- %s\n"), machine, | |
| get_target_specific_info (machine)->name); | |
| printf (_("Number of sections:\t\t\%d\n"), (int) bfd_h_get_16 (abfd, ihdr->f_nscns)); | |
| long timedat = bfd_h_get_32 (abfd, ihdr->f_timdat); | |
| printf (_("Time/Date:\t\t\t%#08lx\t- "), timedat); | |
| if (timedat == 0) | |
| printf (_("not set\n")); | |
| else | |
| { | |
| /* Not correct on all platforms, but works on unix. */ | |
| time_t t = timedat; | |
| fputs (ctime (&t), stdout); | |
| } | |
| printf (_("Symbol table offset:\t\t%#08lx\n"), | |
| (long) bfd_h_get_32 (abfd, ihdr->f_symptr)); | |
| printf (_("Number of symbols:\t\t\%ld\n"), | |
| (long) bfd_h_get_32 (abfd, ihdr->f_nsyms)); | |
| unsigned int opt_header_size = (int) bfd_h_get_16 (abfd, ihdr->f_opthdr); | |
| printf (_("Optional header size:\t\t%#x\n"), opt_header_size); | |
| unsigned int flags = (int) bfd_h_get_16 (abfd, ihdr->f_flags); | |
| printf (_("Flags:\t\t\t\t0x%04x\t\t- "), flags); | |
| dump_flags (file_flag_xlat, flags); | |
| putchar ('\n'); | |
| if (opt_header_size == PEPAOUTSZ) | |
| { | |
| PEPAOUTHDR xhdr; | |
| printf (_("\n Optional 64-bit AOUT Header (at offset %#lx):\n"), | |
| ihdr_off + sizeof (* ihdr)); | |
| // Fortunately, it appears that the size and layout of the | |
| // PEPAOUTHDR header is consistent across all architectures. | |
| if (bfd_seek (abfd, ihdr_off + sizeof (* ihdr), SEEK_SET) != 0 | |
| || bfd_read (&xhdr, sizeof (xhdr), abfd) != sizeof (xhdr)) | |
| printf (_("error: unable to read AOUT and PE+ headers\n")); | |
| else | |
| { | |
| data = (int) bfd_h_get_16 (abfd, xhdr.standard.magic); | |
| printf (_("Magic:\t\t\t\t%x\t\t- %s\n"), data, | |
| data == 0x020b ? "PE32+" : _("Unknown")); | |
| printf (_("Linker Version:\t\t\t%x\t\t- %u.%02u\n"), | |
| (int) bfd_h_get_16 (abfd, xhdr.standard.vstamp), | |
| (int) (bfd_h_get_16 (abfd, xhdr.standard.vstamp) & 0xff), | |
| (int) (bfd_h_get_16 (abfd, xhdr.standard.vstamp) >> 8)); | |
| printf (_("Text Size:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.tsize)); | |
| printf (_("Data Size:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.dsize)); | |
| printf (_("BSS Size:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.bsize)); | |
| printf (_("Entry Point:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.entry)); | |
| printf (_("Text Start:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.text_start)); | |
| /* There is no data_start field in the PE+ standard header. */ | |
| printf (_("\n Optional PE+ Header (at offset %#lx):\n"), | |
| ihdr_off + sizeof (* ihdr) + sizeof (xhdr.standard)); | |
| printf (_("Image Base:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.ImageBase)); | |
| printf (_("Section Alignment:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SectionAlignment)); | |
| printf (_("File Alignment:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.FileAlignment)); | |
| printf (_("Image Version:\t\t\t%lx\t\t- %u.%02u\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.MajorImageVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MajorImageVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MinorImageVersion)); | |
| printf (_("Minimal Subsystem Version:\t%lx\t\t- %u.%02u\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.MajorSubsystemVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MajorSubsystemVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MinorSubsystemVersion)); | |
| printf (_("Minimal OS Version:\t\t%lx\t\t- %u.%02u\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.MajorOperatingSystemVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MajorOperatingSystemVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MinorOperatingSystemVersion)); | |
| printf (_("Overwrite OS Version:\t\t%lx\t\t- "), | |
| (long) bfd_h_get_32 (abfd, xhdr.Win32Version)); | |
| if (bfd_h_get_32 (abfd, xhdr.Win32Version) == 0) | |
| printf (_("(default)\n")); | |
| else | |
| printf (_("%u.%02u (build %u, platform %s)\n"), | |
| ((int) (bfd_h_get_32 (abfd, xhdr.Win32Version) & 0xff)), | |
| ((int) ((bfd_h_get_32 (abfd, xhdr.Win32Version) >> 8) & 0xff)), | |
| ((int) ((bfd_h_get_32 (abfd, xhdr.Win32Version) >> 16) & 0x3fff)), | |
| pe_platform_id_str ((bfd_h_get_32 (abfd, xhdr.Win32Version) >> 30) & 0x3)); | |
| printf (_("Size Of Image:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfImage)); | |
| printf (_("Size Of Headers:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfHeaders)); | |
| printf (_("CheckSum:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.CheckSum)); | |
| printf (_("Subsystem:\t\t\t%d\n"), | |
| (int) bfd_h_get_16 (abfd, xhdr.Subsystem)); | |
| // FIXME: Decode the characteristics. | |
| printf (_("DllCharacteristics:\t\t%#x\n"), | |
| (int) bfd_h_get_16 (abfd, xhdr.DllCharacteristics)); | |
| printf (_("Size Of Stack Reserve:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfStackReserve)); | |
| printf (_("Size Of Stack Commit:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfStackCommit)); | |
| printf (_("Size Of Heap Reserve:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfHeapReserve)); | |
| printf (_("Size Of Heap Commit:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfHeapCommit)); | |
| printf (_("Loader Flags:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.LoaderFlags)); | |
| printf (_("Number Of Rva and Sizes:\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.NumberOfRvaAndSizes)); | |
| // FIXME: Decode the Data Directory. | |
| } | |
| } | |
| else if (opt_header_size == AOUTSZ) | |
| { | |
| PEAOUTHDR xhdr; | |
| /* Different architectures have different sizes of AOUT header. */ | |
| unsigned int aout_hdr_size = get_target_specific_info (machine)->aout_hdr_size; | |
| unsigned long off = ihdr_off + sizeof (* ihdr); | |
| unsigned long size = sizeof (xhdr.standard); | |
| printf (_("\n Optional 32-bit AOUT Header (at offset %#lx, size %d):\n"), | |
| off, aout_hdr_size); | |
| if (bfd_seek (abfd, off, SEEK_SET) != 0 | |
| || bfd_read (&xhdr.standard, size, abfd) != size) | |
| printf (_("error: unable to seek to/read AOUT header\n")); | |
| else | |
| { | |
| data = (int) bfd_h_get_16 (abfd, xhdr.standard.magic); | |
| printf (_("Magic:\t\t\t\t%x\t\t- %s\n"), data, | |
| data == 0x010b ? "PE32" : _("Unknown")); | |
| printf (_("Linker Version:\t\t\t%x\t\t- %u.%02u\n"), | |
| (int) bfd_h_get_16 (abfd, xhdr.standard.vstamp), | |
| (int) (bfd_h_get_16 (abfd, xhdr.standard.vstamp) & 0xff), | |
| (int) (bfd_h_get_16 (abfd, xhdr.standard.vstamp) >> 8)); | |
| printf (_("Text Size:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.tsize)); | |
| printf (_("Data Size:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.dsize)); | |
| printf (_("BSS Size:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.bsize)); | |
| printf (_("Entry Point:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.entry)); | |
| printf (_("Text Start:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.text_start)); | |
| printf (_("Data Start:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.standard.data_start)); | |
| } | |
| off = ihdr_off + sizeof (* ihdr) + aout_hdr_size; | |
| size = sizeof (xhdr) - sizeof (xhdr.standard); | |
| printf (_("\n Optional PE Header (at offset %#lx):\n"), off); | |
| /* FIXME: Sanitizers might complain about reading more bytes than | |
| fit into the ImageBase field. Find a way to solve this. */ | |
| if (bfd_seek (abfd, off, SEEK_SET) != 0 | |
| || bfd_read (&xhdr.ImageBase, size, abfd) != size) | |
| printf (_("error: unable to seek to/read PE header\n")); | |
| else | |
| { | |
| printf (_("Image Base:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.ImageBase)); | |
| printf (_("Section Alignment:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SectionAlignment)); | |
| printf (_("File Alignment:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.FileAlignment)); | |
| printf (_("Image Version:\t\t\t%lx\t\t- %u.%02u\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.MajorImageVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MajorImageVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MinorImageVersion)); | |
| printf (_("Minimal Subsystem Version:\t%lx\t\t- %u.%02u\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.MajorSubsystemVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MajorSubsystemVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MinorSubsystemVersion)); | |
| printf (_("Minimal OS Version:\t\t%lx\t\t- %u.%02u\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.MajorOperatingSystemVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MajorOperatingSystemVersion), | |
| (int) bfd_h_get_16 (abfd, xhdr.MinorOperatingSystemVersion)); | |
| printf (_("Overwrite OS Version:\t\t%lx\t\t- "), | |
| (long) bfd_h_get_32 (abfd, xhdr.Win32Version)); | |
| if (bfd_h_get_32 (abfd, xhdr.Win32Version) == 0) | |
| printf (_("(default)\n")); | |
| else | |
| printf (_("%u.%02u (build %u, platform %s)\n"), | |
| ((int) (bfd_h_get_32 (abfd, xhdr.Win32Version) & 0xff)), | |
| ((int) ((bfd_h_get_32 (abfd, xhdr.Win32Version) >> 8) & 0xff)), | |
| ((int) ((bfd_h_get_32 (abfd, xhdr.Win32Version) >> 16) & 0x3fff)), | |
| pe_platform_id_str ((bfd_h_get_32 (abfd, xhdr.Win32Version) >> 30) & 0x3)); | |
| printf (_("Size Of Image:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfImage)); | |
| printf (_("Size Of Headers:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfHeaders)); | |
| printf (_("CheckSum:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.CheckSum)); | |
| printf (_("Subsystem:\t\t\t%d\n"), | |
| (int) bfd_h_get_16 (abfd, xhdr.Subsystem)); | |
| // FIXME: Decode the characteristics. | |
| printf (_("DllCharacteristics:\t\t%#x\n"), | |
| (int) bfd_h_get_16 (abfd, xhdr.DllCharacteristics)); | |
| printf (_("Size Of Stack Reserve:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfStackReserve)); | |
| printf (_("Size Of Stack Commit:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfStackCommit)); | |
| printf (_("Size Of Heap Reserve:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfHeapReserve)); | |
| printf (_("Size Of Heap Commit:\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.SizeOfHeapCommit)); | |
| printf (_("Loader Flags:\t\t\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.LoaderFlags)); | |
| printf (_("Number Of Rva and Sizes:\t%#lx\n"), | |
| (long) bfd_h_get_32 (abfd, xhdr.NumberOfRvaAndSizes)); | |
| // FIXME: Decode the Data Directory. | |
| } | |
| } | |
| else if (opt_header_size != 0) | |
| { | |
| printf (_("\nUnsupported size of Optional Header\n")); | |
| } | |
| else | |
| printf (_("\n Optional header not present\n")); | |
| } | |
| static void | |
| dump_alignment (unsigned int flags) | |
| { | |
| flags &= IMAGE_SCN_ALIGN_POWER_BIT_MASK; | |
| if (flags == IMAGE_SCN_ALIGN_8192BYTES) | |
| printf (_("Align: 8192 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_4096BYTES) | |
| printf (_("Align: 4096 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_2048BYTES) | |
| printf (_("Align: 2048 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_1024BYTES) | |
| printf (_("Align: 1024 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_512BYTES) | |
| printf (_("Align: 512 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_256BYTES) | |
| printf (_("Align: 256 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_128BYTES) | |
| printf (_("Align: 128 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_64BYTES) | |
| printf (_("Align: 64 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_32BYTES) | |
| printf (_("Align: 32 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_16BYTES) | |
| printf (_("Align: 16 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_8BYTES) | |
| printf (_("Align: 8 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_4BYTES) | |
| printf (_("Align: 4 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_2BYTES) | |
| printf (_("Align: 2 ")); | |
| else if (flags == IMAGE_SCN_ALIGN_1BYTES) | |
| printf (_("Align: 1 ")); | |
| else | |
| printf (_("Align: *unknown* ")); | |
| } | |
| /* Dump the section's header. */ | |
| static void | |
| dump_pe_sections_header (bfd * abfd, | |
| struct external_PEI_filehdr * fhdr, | |
| struct external_PEI_IMAGE_hdr * ihdr) | |
| { | |
| unsigned int opthdr = (int) bfd_h_get_16 (abfd, ihdr->f_opthdr); | |
| unsigned int n_scns = (int) bfd_h_get_16 (abfd, ihdr->f_nscns); | |
| unsigned int off; | |
| /* The section header starts after the file, image and optional headers. */ | |
| if (fhdr == NULL) | |
| off = sizeof (struct external_filehdr) + opthdr; | |
| else | |
| off = (int) bfd_h_get_16 (abfd, fhdr->e_lfanew) + sizeof (* ihdr) + opthdr; | |
| printf (_("\nSection headers (at offset 0x%08x):\n"), off); | |
| if (n_scns == 0) | |
| { | |
| printf (_(" No section headers\n")); | |
| return; | |
| } | |
| if (bfd_seek (abfd, off, SEEK_SET) != 0) | |
| { | |
| non_fatal (_("cannot seek to section headers start\n")); | |
| return; | |
| } | |
| /* We don't translate this string as it consists of field names. */ | |
| if (wide_output) | |
| printf (" # Name paddr vaddr size scnptr relptr lnnoptr nrel nlnno Flags\n"); | |
| else | |
| printf (" # Name paddr vaddr size scnptr relptr lnnoptr nrel nlnno\n"); | |
| unsigned int i; | |
| for (i = 0; i < n_scns; i++) | |
| { | |
| struct external_scnhdr scn; | |
| unsigned int flags; | |
| if (bfd_read (&scn, sizeof (scn), abfd) != sizeof (scn)) | |
| { | |
| non_fatal (_("cannot read section header")); | |
| return; | |
| } | |
| printf ("%2d %-8.8s %08x %08x %08x %08x %08x %08x %5d %5d", | |
| i + 1, scn.s_name, | |
| (unsigned int) bfd_h_get_32 (abfd, scn.s_paddr), | |
| (unsigned int) bfd_h_get_32 (abfd, scn.s_vaddr), | |
| (unsigned int) bfd_h_get_32 (abfd, scn.s_size), | |
| (unsigned int) bfd_h_get_32 (abfd, scn.s_scnptr), | |
| (unsigned int) bfd_h_get_32 (abfd, scn.s_relptr), | |
| (unsigned int) bfd_h_get_32 (abfd, scn.s_lnnoptr), | |
| (unsigned int) bfd_h_get_16 (abfd, scn.s_nreloc), | |
| (unsigned int) bfd_h_get_16 (abfd, scn.s_nlnno)); | |
| flags = bfd_h_get_32 (abfd, scn.s_flags); | |
| if (wide_output) | |
| printf (_(" %08x "), flags); | |
| else | |
| printf (_("\n Flags: %08x: "), flags); | |
| if (flags & IMAGE_SCN_ALIGN_POWER_BIT_MASK) | |
| { | |
| dump_alignment (flags); | |
| flags &= ~ IMAGE_SCN_ALIGN_POWER_BIT_MASK; | |
| } | |
| if (flags != 0) | |
| dump_flags (section_flag_xlat, flags); | |
| putchar ('\n'); | |
| } | |
| } | |
| /* Handle a PE format file. */ | |
| static void | |
| dump_pe (bfd * abfd, | |
| struct external_PEI_filehdr * fhdr, | |
| struct external_PEI_IMAGE_hdr * ihdr) | |
| { | |
| if (options[OPT_FILE_HEADER].selected) | |
| dump_pe_file_header (abfd, fhdr, ihdr); | |
| if (options[OPT_SECTIONS].selected) | |
| dump_pe_sections_header (abfd, fhdr, ihdr); | |
| } | |
| /* Dump ABFD (according to the options[] array). */ | |
| static void | |
| pe_dump_obj (bfd *abfd) | |
| { | |
| struct external_PEI_filehdr fhdr; | |
| /* Read file header. */ | |
| if (bfd_seek (abfd, 0, SEEK_SET) != 0 | |
| || bfd_read (&fhdr, sizeof (fhdr), abfd) != sizeof (fhdr)) | |
| { | |
| non_fatal (_("cannot seek to/read file header")); | |
| return; | |
| } | |
| unsigned short magic = bfd_h_get_16 (abfd, fhdr.e_magic); | |
| /* PE format executable files have a full external_PEI_filehdr structure | |
| at the start. PE format object files just have an external_filehdr | |
| structure at the start. */ | |
| if (magic == IMAGE_DOS_SIGNATURE) | |
| { | |
| unsigned int ihdr_offset = (int) bfd_h_get_16 (abfd, fhdr.e_lfanew); | |
| /* FIXME: We could reuse the fields in fhdr, but that might | |
| confuse various sanitization and memory checker tools. */ | |
| struct external_PEI_IMAGE_hdr ihdr; | |
| if (bfd_seek (abfd, ihdr_offset, SEEK_SET) != 0 | |
| || bfd_read (&ihdr, sizeof (ihdr), abfd) != sizeof (ihdr)) | |
| { | |
| non_fatal (_("cannot seek to/read image header at offset %#x"), | |
| ihdr_offset); | |
| return; | |
| } | |
| unsigned int signature = (int) bfd_h_get_16 (abfd, ihdr.nt_signature); | |
| if (signature != IMAGE_NT_SIGNATURE) | |
| { | |
| non_fatal ("file does not have an NT format signature: %#x", | |
| signature); | |
| return; | |
| } | |
| dump_pe (abfd, &fhdr, &ihdr); | |
| } | |
| /* See if we recognise this particular PE object file. */ | |
| else if (get_target_specific_info (magic)->machine_number) | |
| { | |
| struct external_filehdr ehdr; | |
| if (bfd_seek (abfd, 0, SEEK_SET) != 0 | |
| || bfd_read (&ehdr, sizeof (ehdr), abfd) != sizeof (ehdr)) | |
| { | |
| non_fatal (_("cannot seek to/read image header")); | |
| return; | |
| } | |
| struct external_PEI_IMAGE_hdr ihdr; | |
| memcpy (&ihdr.f_magic, &ehdr, sizeof (ehdr)); | |
| dump_pe (abfd, NULL, &ihdr); | |
| } | |
| else | |
| { | |
| non_fatal ("unknown PE format binary - unsupported magic number: %#x", | |
| magic); | |
| return; | |
| } | |
| } | |
| /* Dump a PE file. */ | |
| static void | |
| pe_dump (bfd *abfd) | |
| { | |
| /* We rely on BFD to decide if the file is a core file. Note that core | |
| files are only supported on native environment by BFD. */ | |
| switch (bfd_get_format (abfd)) | |
| { | |
| case bfd_core: | |
| // FIXME: Handle PE format core files ? | |
| break; | |
| default: | |
| pe_dump_obj (abfd); | |
| break; | |
| } | |
| } | |
| /* Vector for pe. */ | |
| const struct objdump_private_desc objdump_private_desc_pe = | |
| { | |
| pe_help, | |
| pe_filter, | |
| pe_dump, | |
| options | |
| }; |