pelite/
image.rs

1/*!
2Image structures as defined by Windows.
3
4No attempt is made to abstract over endianness.
5
6Sources:
7
8* [winnt.h](https://source.winehq.org/source/include/winnt.h), ctrl-f `IMAGE_DOS_HEADER`
9* [ImageHlp Structures](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680198.aspx)
10* [Peering Inside the PE: A Tour of the Win32 Portable Executable File Format](https://msdn.microsoft.com/en-us/library/ms809762.aspx)
11
12*/
13
14#![allow(non_snake_case)]
15#![allow(non_camel_case_types)]
16
17use std::{fmt, mem};
18
19use crate::Pod;
20
21#[cfg(windows)]
22extern "C" {
23	#[cfg(target_env = "msvc")]
24	static __ImageBase: IMAGE_DOS_HEADER;
25	#[cfg(target_env = "gnu")]
26	static __image_base__: IMAGE_DOS_HEADER;
27}
28
29/// Gets the base address of the module this code is linked with.
30///
31/// This uses a linker pseudovariable and is only available on windows targets.
32#[cfg(all(windows, target_env = "msvc"))]
33#[inline]
34pub fn image_base() -> &'static IMAGE_DOS_HEADER {
35	unsafe { &__ImageBase }
36}
37/// Gets the base address of the module this code is linked with.
38///
39/// This uses a linker pseudovariable and is only available on windows targets.
40#[cfg(all(windows, target_env = "gnu", target_pointer_width = "64"))]
41#[inline]
42pub fn image_base() -> &'static IMAGE_DOS_HEADER {
43	unsafe { &__image_base__ }
44}
45/// Gets the base address of the module this code is linked with.
46///
47/// When linked with GCC on 32-bit targets the linker pseudovariable is undefined?
48/// Since this function isn't critical, panic instead of failing to link.
49///
50/// FIXME! I've been scouring the internet for a solution but no dice.
51#[cfg(all(windows, target_env = "gnu", not(target_pointer_width = "64")))]
52#[inline]
53pub fn image_base() -> &'static IMAGE_DOS_HEADER {
54	panic!("undefined reference to `__image_base__'")
55}
56
57#[cfg(all(windows, target_env = "gnu", not(target_pointer_width = "64")))]
58#[allow(dead_code)]
59pub(crate) const IMAGE_BASE_PANICS: bool = true;
60#[cfg(not(all(windows, target_env = "gnu", not(target_pointer_width = "64"))))]
61#[allow(dead_code)]
62pub(crate) const IMAGE_BASE_PANICS: bool = false;
63
64//----------------------------------------------------------------
65
66pub const IMAGE_DOS_SIGNATURE: u16 = 0x5A4D;
67
68#[derive(Copy, Clone, Debug)]
69#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
70#[repr(C)]
71pub struct IMAGE_DOS_HEADER {
72	pub e_magic: u16,
73	pub e_cblp: u16,
74	pub e_cp: u16,
75	pub e_crlc: u16,
76	pub e_cparhdr: u16,
77	pub e_minalloc: u16,
78	pub e_maxalloc: u16,
79	pub e_ss: u16,
80	pub e_sp: u16,
81	pub e_csum: u16,
82	pub e_ip: u16,
83	pub e_cs: u16,
84	pub e_lfarlc: u16,
85	pub e_ovno: u16,
86	pub e_res: [u16; 4],
87	pub e_oemid: u16,
88	pub e_oeminfo: u16,
89	pub e_res2: [u16; 10],
90	pub e_lfanew: u32,
91}
92
93//----------------------------------------------------------------
94
95pub const IMAGE_FILE_MACHINE_I386: u16  = 0x014c;
96pub const IMAGE_FILE_MACHINE_IA64: u16  = 0x0200;
97pub const IMAGE_FILE_MACHINE_AMD64: u16 = 0x8664;
98
99pub const IMAGE_FILE_RELOCS_STRIPPED: u16         = 0x0001;
100pub const IMAGE_FILE_EXECUTABLE_IMAGE: u16        = 0x0002;
101pub const IMAGE_FILE_LINE_NUMS_STRIPPED: u16      = 0x0004;
102pub const IMAGE_FILE_LOCAL_SYMS_STRIPPED: u16     = 0x0008;
103pub const IMAGE_FILE_AGGRESIVE_WS_TRIM: u16       = 0x0010;
104pub const IMAGE_FILE_LARGE_ADDRESS_AWARE: u16     = 0x0020;
105pub(crate) const IMAGE_FILE_6: u16                = 0x0040;
106pub const IMAGE_FILE_BYTES_REVERSED_LO: u16       = 0x0080;
107pub const IMAGE_FILE_32BIT_MACHINE: u16           = 0x0100;
108pub const IMAGE_FILE_DEBUG_STRIPPED: u16          = 0x0200;
109pub const IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP: u16 = 0x0400;
110pub const IMAGE_FILE_NET_RUN_FROM_SWAP: u16       = 0x0800;
111pub const IMAGE_FILE_SYSTEM: u16                  = 0x1000;
112pub const IMAGE_FILE_DLL: u16                     = 0x2000;
113pub const IMAGE_FILE_UP_SYSTEM_ONLY: u16          = 0x4000;
114pub const IMAGE_FILE_BYTES_REVERSED_HI: u16       = 0x8000;
115
116#[derive(Copy, Clone, Debug)]
117#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
118#[repr(C)]
119pub struct IMAGE_FILE_HEADER {
120	pub Machine: u16,
121	pub NumberOfSections: u16,
122	pub TimeDateStamp: u32,
123	pub PointerToSymbolTable: u32,
124	pub NumberOfSymbols: u32,
125	pub SizeOfOptionalHeader: u16,
126	pub Characteristics: u16,
127}
128
129//----------------------------------------------------------------
130
131#[derive(Copy, Clone, Debug)]
132#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
133#[repr(C)]
134pub struct IMAGE_DATA_DIRECTORY {
135	pub VirtualAddress: u32,
136	pub Size: u32,
137}
138
139pub const IMAGE_DIRECTORY_ENTRY_EXPORT: usize         = 0;
140pub const IMAGE_DIRECTORY_ENTRY_IMPORT: usize         = 1;
141pub const IMAGE_DIRECTORY_ENTRY_RESOURCE: usize       = 2;
142pub const IMAGE_DIRECTORY_ENTRY_EXCEPTION: usize      = 3;
143pub const IMAGE_DIRECTORY_ENTRY_SECURITY: usize       = 4;
144pub const IMAGE_DIRECTORY_ENTRY_BASERELOC: usize      = 5;
145pub const IMAGE_DIRECTORY_ENTRY_DEBUG: usize          = 6;
146pub const IMAGE_DIRECTORY_ENTRY_ARCHITECTURE: usize   = 7;
147pub const IMAGE_DIRECTORY_ENTRY_GLOBALPTR: usize      = 8;
148pub const IMAGE_DIRECTORY_ENTRY_TLS: usize            = 9;
149pub const IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG: usize    = 10;
150pub const IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT: usize   = 11;
151pub const IMAGE_DIRECTORY_ENTRY_IAT: usize            = 12;
152pub const IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT: usize   = 13;
153pub const IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR: usize = 14;
154
155pub const IMAGE_NUMBEROF_DIRECTORY_ENTRIES: usize   = 16;
156
157//----------------------------------------------------------------
158
159// Helper struct, makes serialization nicer
160#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
161#[repr(C)]
162pub struct IMAGE_VERSION<T> {
163	pub Major: T,
164	pub Minor: T,
165}
166#[cfg(feature = "serde")]
167impl<T: fmt::Display> serde::Serialize for IMAGE_VERSION<T> {
168	fn serialize<S: serde::Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
169		serializer.collect_str(self)
170	}
171}
172impl<T: fmt::Display> fmt::Debug for IMAGE_VERSION<T> {
173	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
174		write!(f, "\"{}.{}\"", self.Major, self.Minor)
175	}
176}
177impl<T: fmt::Display> fmt::Display for IMAGE_VERSION<T> {
178	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
179		write!(f, "{}.{}", self.Major, self.Minor)
180	}
181}
182
183//----------------------------------------------------------------
184
185pub const IMAGE_NT_OPTIONAL_HDR32_MAGIC: u16 = 0x10b;
186pub const IMAGE_NT_OPTIONAL_HDR64_MAGIC: u16 = 0x20b;
187pub const IMAGE_ROM_OPTIONAL_HDR_MAGIC: u16  = 0x107;
188
189pub const IMAGE_SUBSYSTEM_UNKNOWN: u16                  = 0;
190pub const IMAGE_SUBSYSTEM_NATIVE: u16                   = 1;
191pub const IMAGE_SUBSYSTEM_WINDOWS_GUI: u16              = 2;
192pub const IMAGE_SUBSYSTEM_WINDOWS_CUI: u16              = 3;
193pub const IMAGE_SUBSYSTEM_OS2_CUI: u16                  = 5;
194pub const IMAGE_SUBSYSTEM_POSIX_CUI: u16                = 7;
195pub const IMAGE_SUBSYSTEM_NATIVE_WINDOWS: u16           = 8;
196pub const IMAGE_SUBSYSTEM_WINDOWS_CE_GUI: u16           = 9;
197pub const IMAGE_SUBSYSTEM_EFI_APPLICATION: u16          = 10;
198pub const IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER: u16  = 11;
199pub const IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER: u16       = 12;
200pub const IMAGE_SUBSYSTEM_EFI_ROM: u16                  = 13;
201pub const IMAGE_SUBSYSTEM_XBOX: u16                     = 14;
202pub const IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION: u16 = 16;
203
204pub(crate) const IMAGE_DLLCHARACTERISTICS_0: u16              = 0x0001;
205pub(crate) const IMAGE_DLLCHARACTERISTICS_1: u16              = 0x0002;
206pub(crate) const IMAGE_DLLCHARACTERISTICS_2: u16              = 0x0004;
207pub(crate) const IMAGE_DLLCHARACTERISTICS_3: u16              = 0x0008;
208pub(crate) const IMAGE_DLLCHARACTERISTICS_4: u16              = 0x0010;
209pub const IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA: u16       = 0x0020;
210pub const IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE: u16          = 0x0040;
211pub const IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY: u16       = 0x0080;
212pub const IMAGE_DLLCHARACTERISTICS_NX_COMPAT: u16             = 0x0100;
213pub const IMAGE_DLLCHARACTERISTICS_NO_ISOLATION: u16          = 0x0200;
214pub const IMAGE_DLLCHARACTERISTICS_NO_SEH: u16                = 0x0400;
215pub const IMAGE_DLLCHARACTERISTICS_NO_BIND: u16               = 0x0800;
216pub const IMAGE_DLLCHARACTERISTICS_APPCONTAINER: u16          = 0x1000;
217pub const IMAGE_DLLCHARACTERISTICS_WDM_DRIVER: u16            = 0x2000;
218pub const IMAGE_DLLCHARACTERISTICS_GUARD_CF: u16              = 0x4000;
219pub const IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE: u16 = 0x8000;
220
221#[derive(Copy, Clone, Debug)]
222#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
223#[repr(C)]
224pub struct IMAGE_OPTIONAL_HEADER32 {
225	pub Magic: u16,
226	pub LinkerVersion: IMAGE_VERSION<u8>,
227	pub SizeOfCode: u32,
228	pub SizeOfInitializedData: u32,
229	pub SizeOfUninitializedData: u32,
230	pub AddressOfEntryPoint: u32,
231	pub BaseOfCode: u32,
232	pub BaseOfData: u32,
233	pub ImageBase: u32,
234	pub SectionAlignment: u32,
235	pub FileAlignment: u32,
236	pub OperatingSystemVersion: IMAGE_VERSION<u16>,
237	pub ImageVersion: IMAGE_VERSION<u16>,
238	pub SubsystemVersion: IMAGE_VERSION<u16>,
239	pub Win32VersionValue: u32,
240	pub SizeOfImage: u32,
241	pub SizeOfHeaders: u32,
242	pub CheckSum: u32,
243	pub Subsystem: u16,
244	pub DllCharacteristics: u16,
245	pub SizeOfStackReserve: u32,
246	pub SizeOfStackCommit: u32,
247	pub SizeOfHeapReserve: u32,
248	pub SizeOfHeapCommit: u32,
249	pub LoaderFlags: u32,
250	pub NumberOfRvaAndSizes: u32,
251	#[cfg_attr(feature = "serde", serde(skip))]
252	pub DataDirectory: [IMAGE_DATA_DIRECTORY; 0],
253}
254
255#[derive(Copy, Clone, Debug)]
256#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
257#[repr(C)]
258pub struct IMAGE_OPTIONAL_HEADER64 {
259	pub Magic: u16,
260	pub LinkerVersion: IMAGE_VERSION<u8>,
261	pub SizeOfCode: u32,
262	pub SizeOfInitializedData: u32,
263	pub SizeOfUninitializedData: u32,
264	pub AddressOfEntryPoint: u32,
265	pub BaseOfCode: u32,
266	pub ImageBase: u64,
267	pub SectionAlignment: u32,
268	pub FileAlignment: u32,
269	pub OperatingSystemVersion: IMAGE_VERSION<u16>,
270	pub ImageVersion: IMAGE_VERSION<u16>,
271	pub SubsystemVersion: IMAGE_VERSION<u16>,
272	pub Win32VersionValue: u32,
273	pub SizeOfImage: u32,
274	pub SizeOfHeaders: u32,
275	pub CheckSum: u32,
276	pub Subsystem: u16,
277	pub DllCharacteristics: u16,
278	pub SizeOfStackReserve: u64,
279	pub SizeOfStackCommit: u64,
280	pub SizeOfHeapReserve: u64,
281	pub SizeOfHeapCommit: u64,
282	pub LoaderFlags: u32,
283	pub NumberOfRvaAndSizes: u32,
284	#[cfg_attr(feature = "serde", serde(skip))]
285	pub DataDirectory: [IMAGE_DATA_DIRECTORY; 0],
286}
287
288//----------------------------------------------------------------
289
290pub const IMAGE_NT_HEADERS_SIGNATURE: u32 = 0x00004550;
291
292#[derive(Copy, Clone, Debug)]
293#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
294#[repr(C)]
295pub struct IMAGE_NT_HEADERS32 {
296	pub Signature: u32,
297	pub FileHeader: IMAGE_FILE_HEADER,
298	pub OptionalHeader: IMAGE_OPTIONAL_HEADER32,
299}
300
301#[derive(Copy, Clone, Debug)]
302#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
303#[repr(C)]
304pub struct IMAGE_NT_HEADERS64 {
305	pub Signature: u32,
306	pub FileHeader: IMAGE_FILE_HEADER,
307	pub OptionalHeader: IMAGE_OPTIONAL_HEADER64,
308}
309
310//----------------------------------------------------------------
311
312pub const IMAGE_SIZEOF_SHORT_NAME: usize = 8;
313
314pub(crate) const IMAGE_SCN_0: u32               = 0x00000001;
315pub(crate) const IMAGE_SCN_1: u32               = 0x00000002;
316pub(crate) const IMAGE_SCN_2: u32               = 0x00000004;
317pub const IMAGE_SCN_TYPE_NO_PAD: u32            = 0x00000008;
318pub(crate) const IMAGE_SCN_4: u32               = 0x00000010;
319pub const IMAGE_SCN_CNT_CODE: u32               = 0x00000020;
320pub const IMAGE_SCN_CNT_INITIALIZED_DATA: u32   = 0x00000040;
321pub const IMAGE_SCN_CNT_UNINITIALIZED_DATA: u32 = 0x00000080;
322pub const IMAGE_SCN_LNK_OTHER: u32              = 0x00000100;
323pub const IMAGE_SCN_LNK_INFO: u32               = 0x00000200;
324pub(crate) const IMAGE_SCN_10: u32              = 0x00000400;
325pub const IMAGE_SCN_LNK_REMOVE: u32             = 0x00000800;
326pub const IMAGE_SCN_LNK_COMDAT: u32             = 0x00001000;
327pub(crate) const IMAGE_SCN_13: u32              = 0x00002000;
328pub const IMAGE_SCN_NO_DEFER_SPEC_EXC: u32      = 0x00004000;
329pub const IMAGE_SCN_GPREL: u32                  = 0x00008000;
330pub(crate) const IMAGE_SCN_16: u32               = 0x00010000;
331pub const IMAGE_SCN_MEM_PURGEABLE: u32          = 0x00020000;
332pub const IMAGE_SCN_MEM_LOCKED: u32             = 0x00040000;
333pub const IMAGE_SCN_MEM_PRELOAD: u32            = 0x00080000;
334pub(crate) const IMAGE_SCN_ALIGN_1: u32         = 0x00100000;
335pub(crate) const IMAGE_SCN_ALIGN_2: u32         = 0x00200000;
336pub(crate) const IMAGE_SCN_ALIGN_4: u32         = 0x00400000;
337pub(crate) const IMAGE_SCN_ALIGN_8: u32         = 0x00800000;
338pub const IMAGE_SCN_ALIGN_1BYTES: u32           = 0x00100000;
339pub const IMAGE_SCN_ALIGN_2BYTES: u32           = 0x00200000;
340pub const IMAGE_SCN_ALIGN_4BYTES: u32           = 0x00300000;
341pub const IMAGE_SCN_ALIGN_8BYTES: u32           = 0x00400000;
342pub const IMAGE_SCN_ALIGN_16BYTES: u32          = 0x00500000;
343pub const IMAGE_SCN_ALIGN_32BYTES: u32          = 0x00600000;
344pub const IMAGE_SCN_ALIGN_64BYTES: u32          = 0x00700000;
345pub const IMAGE_SCN_ALIGN_128BYTES: u32         = 0x00800000;
346pub const IMAGE_SCN_ALIGN_256BYTES: u32         = 0x00900000;
347pub const IMAGE_SCN_ALIGN_512BYTES: u32         = 0x00A00000;
348pub const IMAGE_SCN_ALIGN_1024BYTES: u32        = 0x00B00000;
349pub const IMAGE_SCN_ALIGN_2048BYTES: u32        = 0x00C00000;
350pub const IMAGE_SCN_ALIGN_4096BYTES: u32        = 0x00D00000;
351pub const IMAGE_SCN_ALIGN_8192BYTES: u32        = 0x00E00000;
352pub const IMAGE_SCN_LNK_NRELOC_OVFL: u32        = 0x01000000;
353pub const IMAGE_SCN_MEM_DISCARDABLE: u32        = 0x02000000;
354pub const IMAGE_SCN_MEM_NOT_CACHED: u32         = 0x04000000;
355pub const IMAGE_SCN_MEM_NOT_PAGED: u32          = 0x08000000;
356pub const IMAGE_SCN_MEM_SHARED: u32             = 0x10000000;
357pub const IMAGE_SCN_MEM_EXECUTE: u32            = 0x20000000;
358pub const IMAGE_SCN_MEM_READ: u32               = 0x40000000;
359pub const IMAGE_SCN_MEM_WRITE: u32              = 0x80000000;
360
361#[derive(Copy, Clone, Debug)]
362#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
363#[repr(C)]
364pub struct IMAGE_SECTION_HEADER {
365	#[cfg_attr(feature = "serde", serde(serialize_with = "crate::wrap::sections::serialize_name"))]
366	pub Name: [u8; IMAGE_SIZEOF_SHORT_NAME],
367	pub VirtualSize: u32,
368	pub VirtualAddress: u32,
369	pub SizeOfRawData: u32,
370	pub PointerToRawData: u32,
371	pub PointerToRelocations: u32,
372	pub PointerToLinenumbers: u32,
373	pub NumberOfRelocations: u16,
374	pub NumberOfLinenumbers: u16,
375	pub Characteristics: u32,
376}
377
378//----------------------------------------------------------------
379
380#[derive(Copy, Clone, Debug)]
381#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
382#[repr(C)]
383pub struct IMAGE_EXPORT_DIRECTORY {
384	pub Characteristics: u32,
385	pub TimeDateStamp: u32,
386	pub Version: IMAGE_VERSION<u16>,
387	pub Name: u32,
388	pub Base: u32,
389	pub NumberOfFunctions: u32,
390	pub NumberOfNames: u32,
391	pub AddressOfFunctions: u32,     // RVA from base of image
392	pub AddressOfNames: u32,         // RVA from base of image
393	pub AddressOfNameOrdinals: u32,  // RVA from base of image
394}
395
396//----------------------------------------------------------------
397
398#[derive(Copy, Clone, Debug)]
399#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
400#[repr(C)]
401pub struct IMAGE_IMPORT_DESCRIPTOR {
402	pub OriginalFirstThunk: u32,
403	pub TimeDateStamp: u32,
404	pub ForwarderChain: u32,
405	pub Name: u32,
406	pub FirstThunk: u32,
407}
408impl IMAGE_IMPORT_DESCRIPTOR {
409	pub fn is_null(&self) -> bool {
410		// This is all that really marks an empty import descriptor
411		self.FirstThunk == 0
412	}
413}
414
415pub const IMAGE_ORDINAL_FLAG32: u32 = 0x80000000;
416pub const IMAGE_ORDINAL_FLAG64: u64 = 0x8000000000000000;
417
418//----------------------------------------------------------------
419
420pub const RT_CURSOR: u16       = 1;
421pub const RT_BITMAP: u16       = 2;
422pub const RT_ICON: u16         = 3;
423pub const RT_MENU: u16         = 4;
424pub const RT_DIALOG: u16       = 5;
425pub const RT_STRING: u16       = 6;
426pub const RT_FONTDIR: u16      = 7;
427pub const RT_FONT: u16         = 8;
428pub const RT_ACCELERATOR: u16  = 9;
429pub const RT_RCDATA: u16       = 10;
430pub const RT_MESSAGETABLE: u16 = 11;
431pub const RT_GROUP_CURSOR: u16 = 12;
432pub const RT_GROUP_ICON: u16   = 14;
433pub const RT_VERSION: u16      = 16;
434pub const RT_DLGINCLUDE: u16   = 17;
435pub const RT_PLUGPLAY: u16     = 19;
436pub const RT_VXD: u16          = 20;
437pub const RT_ANICURSOR: u16    = 21;
438pub const RT_ANIICON: u16      = 22;
439pub const RT_HTML: u16         = 23;
440pub const RT_MANIFEST: u16     = 24;
441
442#[derive(Copy, Clone, Debug)]
443#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
444#[repr(C)]
445pub struct IMAGE_RESOURCE_DIRECTORY {
446	pub Characteristics: u32,
447	pub TimeDateStamp: u32,
448	pub Version: IMAGE_VERSION<u16>,
449	pub NumberOfNamedEntries: u16,
450	pub NumberOfIdEntries: u16,
451}
452
453#[derive(Copy, Clone, Debug)]
454#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
455#[repr(C)]
456pub struct IMAGE_RESOURCE_DIRECTORY_ENTRY {
457	// High bit set means the lower 31 bits are an RVA to its name string otherwise this is a 16 bit WORD id
458	// Name string is encoded in WORDs and is prefixed with a WORD indicating its length (in WORDs)
459	pub Name: u32,
460	// High bit set means this is offset points to an IMAGE_RESOURCE_DIRECTORY otherwise an IMAGE_RESOURCE_DATA_ENTRY
461	pub Offset: u32,
462}
463
464#[derive(Copy, Clone, Debug)]
465#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
466#[repr(C)]
467pub struct IMAGE_RESOURCE_DATA_ENTRY {
468	pub OffsetToData: u32,
469	pub Size: u32,
470	pub CodePage: u32,
471	pub Reserved: u32,
472}
473
474//----------------------------------------------------------------
475
476pub const VS_FIXEDFILEINFO_SIGNATURE: u32 = 0xFEEF04BD;
477
478#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
479#[repr(C)]
480pub struct VS_VERSION {
481	pub Minor: u16,
482	pub Major: u16,
483	pub Build: u16,
484	pub Patch: u16,
485}
486#[cfg(feature = "serde")]
487impl serde::Serialize for VS_VERSION {
488	fn serialize<S: serde::Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
489		serializer.collect_str(self)
490	}
491}
492impl fmt::Debug for VS_VERSION {
493	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
494		write!(f, "\"{}.{}.{}.{}\"", self.Major, self.Minor, self.Patch, self.Build)
495	}
496}
497impl fmt::Display for VS_VERSION {
498	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
499		write!(f, "{}.{}.{}.{}", self.Major, self.Minor, self.Patch, self.Build)
500	}
501}
502
503#[cfg(feature = "serde")]
504fn ser_fixed_file_info_struc_version<S: serde::Serializer>(&version: &u32, serializer: S) -> std::result::Result<S::Ok, S::Error> {
505	let version = IMAGE_VERSION {
506		Major: (version >> 16) as u16,
507		Minor: (version & 0xffff) as u16,
508	};
509	serializer.collect_str(&version)
510}
511
512#[derive(Copy, Clone, Debug)]
513#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
514#[repr(C)]
515pub struct VS_FIXEDFILEINFO {
516	pub dwSignature: u32,
517	#[cfg_attr(feature = "serde", serde(serialize_with = "ser_fixed_file_info_struc_version"))]
518	pub dwStrucVersion: u32,
519	pub dwFileVersion: VS_VERSION,
520	pub dwProductVersion: VS_VERSION,
521	pub dwFileFlagsMask: u32,
522	pub dwFileFlags: u32,
523	pub dwFileOS: u32,
524	pub dwFileType: u32,
525	pub dwFileSubtype: u32,
526	pub dwFileDateMS: u32,
527	pub dwFileDateLS: u32,
528}
529
530//----------------------------------------------------------------
531// Sourced from <Windows.h>
532
533pub const IMAGE_REL_BASED_ABSOLUTE: u8 = 0;
534pub const IMAGE_REL_BASED_HIGH: u8 = 1;
535pub const IMAGE_REL_BASED_LOW: u8 = 2;
536pub const IMAGE_REL_BASED_HIGHLOW: u8 = 3;
537pub const IMAGE_REL_BASED_HIGHADJ: u8 = 4;
538pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_5: u8 = 5;
539pub const IMAGE_REL_BASED_RESERVED: u8 = 6;
540pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_7: u8 = 7;
541pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_8: u8 = 8;
542pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_9: u8 = 9;
543pub const IMAGE_REL_BASED_DIR64: u8 = 10;
544
545pub const IMAGE_REL_BASED_IA64IMM64: u8 = 9;
546
547pub const IMAGE_REL_BASED_MIPSJMPADDR: u8 = 5;
548pub const IMAGE_REL_BASED_MIPSJMPADDR16: u8 = 9;
549
550pub const IMAGE_REL_BASED_ARM_MOV32: u8 = 5;
551pub const IMAGE_REL_BASED_THUMB_MOV32: u8 = 7;
552
553#[derive(Copy, Clone, Debug)]
554#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
555#[repr(C)]
556pub struct IMAGE_BASE_RELOCATION {
557	pub VirtualAddress: u32,
558	pub SizeOfBlock: u32,
559}
560
561//----------------------------------------------------------------
562
563#[derive(Copy, Clone, Debug)]
564#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
565#[repr(C)]
566pub struct IMAGE_LOAD_CONFIG_DIRECTORY32 {
567	pub Size: u32,
568	pub TimeDateStamp: u32,
569	pub Version: IMAGE_VERSION<u16>,
570	pub GlobalFlagsClear: u32,
571	pub GlobalFlagsSet: u32,
572	pub CriticalSectionDefaultTimeout: u32,
573	pub DeCommitFreeBlockThreshold: u32,
574	pub DeCommitTotalFreeThreshold: u32,
575	pub LockPrefixTable: u32,
576	pub MaximumAllocationSize: u32,
577	pub VirtualMemoryThreshold: u32,
578	pub ProcessAffinityMask: u32,
579	pub ProcessHeapFlags: u32,
580	pub CSDVersion: u16,
581	pub DependentLoadFlags: u16,
582	pub EditList: u32,
583	pub SecurityCookie: u32,
584	pub SEHandlerTable: u32,
585	pub SEHandlerCount: u32,
586}
587
588#[derive(Copy, Clone, Debug)]
589#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
590#[repr(C)]
591pub struct IMAGE_LOAD_CONFIG_DIRECTORY64 {
592	pub Size: u32,
593	pub TimeDateStamp: u32,
594	pub Version: IMAGE_VERSION<u16>,
595	pub GlobalFlagsClear: u32,
596	pub GlobalFlagsSet: u32,
597	pub CriticalSectionDefaultTimeout: u32,
598	pub DeCommitFreeBlockThreshold: u64,
599	pub DeCommitTotalFreeThreshold: u64,
600	pub LockPrefixTable: u64,
601	pub MaximumAllocationSize: u64,
602	pub VirtualMemoryThreshold: u64,
603	pub ProcessAffinityMask: u64,
604	pub ProcessHeapFlags: u32,
605	pub CSDVersion: u16,
606	pub DependentLoadFlags: u16,
607	pub EditList: u64,
608	pub SecurityCookie: u64,
609	pub SEHandlerTable: u64,
610	pub SEHandlerCount: u64,
611}
612
613//----------------------------------------------------------------
614// Control flow guard bits of the LoadConfig
615//
616// Note that IMAGE_GUARDCF is not an official name but to keep it separate from IMAGE_LOAD_CONFIG.
617//
618// References:
619// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-_image_load_config_directory32
620// https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-_image_load_config_directory64
621// https://redplait.blogspot.com/2016/10/imageloadconfigdirectory-from-sdk-14951.html
622// https://lucasg.github.io/2017/02/05/Control-Flow-Guard/
623
624#[derive(Copy, Clone, Debug)]
625#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
626#[repr(C)]
627pub struct IMAGE_LOAD_CONFIG_CODE_INTEGRITY {
628	pub Flags: u16,
629	pub Catalog: u16,
630	pub CatalogOffset: u32,
631	pub Reserved: u32,
632}
633
634pub const IMAGE_DYNAMIC_RELOCATION_GUARD_RF_PROLOGUE: u32 = 0x00000001;
635pub const IMAGE_DYNAMIC_RELOCATION_GUARD_RF_EPILOGUE: u32 = 0x00000002;
636
637#[derive(Copy, Clone, Debug)]
638#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
639#[repr(C)]
640pub struct IMAGE_DYNAMIC_RELOCATION_TABLE {
641	pub Version: u32,
642	pub Size: u32,
643}
644
645#[derive(Copy, Clone, Debug)]
646#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
647#[repr(C)]
648pub struct IMAGE_DYNAMIC_RELOCATION32 {
649	pub Symbol: u32,
650	pub BaseRelocSize: u32,
651}
652
653#[derive(Copy, Clone, Debug)]
654#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
655#[repr(C)]
656pub struct IMAGE_DYNAMIC_RELOCATION64 {
657	pub Symbol: [u32; 2], // 64-bit packed int
658	pub BaseRelocSize: u32,
659}
660
661pub const IMAGE_GUARD_CF_INSTRUMENTED: u32                    = 0x00000100;
662pub const IMAGE_GUARD_CFW_INSTRUMENTED: u32                   = 0x00000200;
663pub const IMAGE_GUARD_CF_FUNCTION_TABLE_PRESENT: u32          = 0x00000400;
664pub const IMAGE_GUARD_SECURITY_COOKIE_UNUSED: u32             = 0x00000800;
665pub const IMAGE_GUARD_PROTECT_DELAYLOAD_IAT: u32              = 0x00001000;
666pub const IMAGE_GUARD_DELAYLOAD_IAT_IN_ITS_OWN_SECTION: u32   = 0x00002000;
667pub const IMAGE_GUARD_CF_EXPORT_SUPPRESSION_INFO_PRESENT: u32 = 0x00004000;
668pub const IMAGE_GUARD_CF_ENABLE_EXPORT_SUPPRESSION: u32       = 0x00008000;
669pub const IMAGE_GUARD_CF_LONGJUMP_TABLE_PRESENT: u32          = 0x00010000;
670pub const IMAGE_GUARD_RF_INSTRUMENTED: u32                    = 0x00020000;
671pub const IMAGE_GUARD_RF_ENABLE: u32                          = 0x00040000;
672pub const IMAGE_GUARD_RF_STRICT: u32                          = 0x00080000;
673pub const IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK: u32        = 0xF0000000;
674pub const IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_SHIFT: u32       = 28;
675
676#[derive(Copy, Clone, Debug)]
677#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
678#[repr(C)]
679pub struct IMAGE_GUARDCF32 {
680	pub GuardCFCheckFunctionPointer: u32,
681	pub GuardCFDispatchFunctionPointer: u32,
682	pub GuardCFFunctionTable: u32,
683	pub GuardCFFunctionCount: u32,
684	pub GuardFlags: u32,
685	pub CodeIntegrity: IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
686	pub GuardAddressTakenIatEntryTable: u32,
687	pub GuardAddressTakenIatEntryCount: u32,
688	pub GuardLongJumpTargetTable: u32,
689	pub GuardLongJumpTargetCount: u32,
690	pub DynamicValueRelocTable: u32,
691	pub HybridMetadataPointer: u32,
692	pub GuardRFFailureRoutine: u32,
693	pub GuardRFFailureRoutineFunctionPointer: u32,
694	pub DynamicValueRelocTableOffset: u32,
695	pub DynamicValueRelocTableSection: u16,
696	pub Reserved2: u16,
697	pub GuardRFVerifyStackPointerFunctionPointer: u32,
698	pub HotPatchTableOffset: u32,
699	pub Reserved3: u32,
700	pub EnclaveConfigurationPointer: u32,
701}
702
703#[derive(Copy, Clone, Debug)]
704#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
705#[repr(C)]
706pub struct IMAGE_GUARDCF64 {
707	pub GuardCFCheckFunctionPointer: u64,
708	pub GuardCFDispatchFunctionPointer: u64,
709	pub GuardCFFunctionTable: u64,
710	pub GuardCFFunctionCount: u64,
711	pub GuardFlags: u32,
712	pub CodeIntegrity: IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
713	pub GuardAddressTakenIatEntryTable: u64,
714	pub GuardAddressTakenIatEntryCount: u64,
715	pub GuardLongJumpTargetTable: u64,
716	pub GuardLongJumpTargetCount: u64,
717	pub DynamicValueRelocTable: u64,
718	pub HybridMetadataPointer: u64,
719	pub GuardRFFailureRoutine: u64,
720	pub GuardRFFailureRoutineFunctionPointer: u64,
721	pub DynamicValueRelocTableOffset: u32,
722	pub DynamicValueRelocTableSection: u16,
723	pub Reserved2: u16,
724	pub GuardRFVerifyStackPointerFunctionPointer: u64,
725	pub HotPatchTableOffset: u32,
726	pub Reserved3: u32,
727	pub EnclaveConfigurationPointer: u64,
728}
729
730//----------------------------------------------------------------
731
732#[derive(Copy, Clone, Debug)]
733#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
734#[repr(C)]
735pub struct IMAGE_TLS_DIRECTORY32 {
736	pub StartAddressOfRawData: u32,
737	pub EndAddressOfRawData: u32,
738	pub AddressOfIndex: u32,
739	pub AddressOfCallBacks: u32,
740	pub SizeOfZeroFill: u32,
741	pub Characteristics: u32,
742}
743
744#[derive(Copy, Clone, Debug)]
745#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
746#[repr(C)]
747pub struct IMAGE_TLS_DIRECTORY64 {
748	pub StartAddressOfRawData: u64,
749	pub EndAddressOfRawData: u64,
750	pub AddressOfIndex: u64,
751	pub AddressOfCallBacks: u64,
752	pub SizeOfZeroFill: u32,
753	pub Characteristics: u32,
754}
755
756//----------------------------------------------------------------
757
758pub const WIN_CERT_REVISION_1_0: u16 = 0x0100;
759
760pub const WIN_CERT_TYPE_X509: u16             = 0x0001;
761pub const WIN_CERT_TYPE_PKCS_SIGNED_DATA: u16 = 0x0002;
762pub const WIN_CERT_TYPE_RESERVED_1: u16       = 0x0003;
763pub const WIN_CERT_TYPE_PKCS1_SIGN: u16       = 0x0009;
764
765#[derive(Copy, Clone, Debug)]
766#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
767#[repr(C)]
768pub struct WIN_CERTIFICATE {
769	pub dwLength: u32,
770	pub wRevision: u16,
771	pub wCertificateType: u16,
772	#[cfg_attr(feature = "serde", serde(skip))]
773	pub bCertificate: [u8; 0],
774}
775
776//----------------------------------------------------------------
777// References
778// https://docs.microsoft.com/en-gb/cpp/build/unwind-data-definitions-in-c
779// https://www.reactos.org/wiki/Techwiki:SEH64
780// http://www.osronline.com/article.cfm?article=469
781
782pub const UWOP_PUSH_NONVOL: u8     = 0;  // info == register number
783pub const UWOP_ALLOC_LARGE: u8     = 1;  // no info, alloc size in next 2 slots
784pub const UWOP_ALLOC_SMALL: u8     = 2;  // info == size of allocation / 8 - 1
785pub const UWOP_SET_FPREG: u8       = 3;  // no info, FP = RSP + UNWIND_INFO.FPRegOffset*16
786pub const UWOP_SAVE_NONVOL: u8     = 4;  // info == register number, offset in next slot
787pub const UWOP_SAVE_NONVOL_FAR: u8 = 5;  // info == register number, offset in next 2 slots
788pub const UWOP_SAVE_XMM128: u8     = 8;  // info == XMM reg number, offset in next slot
789pub const UWOP_SAVE_XMM128_FAR: u8 = 9;  // info == XMM reg number, offset in next 2 slots
790pub const UWOP_PUSH_MACHFRAME: u8  = 10; // info == 0: no error-code, 1: error-code
791
792#[derive(Copy, Clone, Debug)]
793#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
794#[repr(C)]
795pub struct UNWIND_CODE {
796	pub CodeOffset: u8,
797	pub UnwindOpInfo: u8,
798}
799
800pub const UNW_FLAG_NHANDLER: u8  = 0x00;
801pub const UNW_FLAG_EHANDLER: u8  = 0x01;
802pub const UNW_FLAG_UHANDLER: u8  = 0x02;
803pub const UNW_FLAG_FHANDLER: u8  = 0x03; // inofficial
804pub const UNW_FLAG_CHAININFO: u8 = 0x04;
805
806#[derive(Copy, Clone, Debug)]
807#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
808#[repr(C)]
809pub struct UNWIND_INFO {
810	pub VersionFlags: u8,
811	pub SizeOfProlog: u8,
812	pub CountOfCodes: u8,
813	pub FrameRegisterOffset: u8,
814	#[cfg_attr(feature = "serde", serde(skip))]
815	pub UnwindCode: [UNWIND_CODE; 0],
816}
817
818#[derive(Copy, Clone, Debug)]
819#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
820#[repr(C)]
821pub struct RUNTIME_FUNCTION {
822	pub BeginAddress: u32,
823	pub EndAddress: u32,
824	pub UnwindData: u32,
825}
826
827#[derive(Copy, Clone, Debug)]
828#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
829#[repr(C)]
830pub struct SCOPE_RECORD {
831	pub BeginAddress: u32,
832	pub EndAddress: u32,
833	pub HandlerAddress: u32,
834	pub JumpTarget: u32,
835}
836
837#[derive(Copy, Clone, Debug)]
838#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
839#[repr(C)]
840pub struct SCOPE_TABLE {
841	pub Count: u32,
842	#[cfg_attr(feature = "serde", serde(skip))]
843	pub ScopeRecord: [SCOPE_RECORD; 0],
844}
845
846//----------------------------------------------------------------
847// http://www.debuginfo.com/articles/debuginfomatch.html
848// https://docs.microsoft.com/en-us/windows/desktop/debug/pe-format#the-debug-section
849
850#[derive(Copy, Clone, PartialEq, Eq)]
851#[repr(C)]
852pub struct GUID {
853	pub Data1: u32,
854	pub Data2: u16,
855	pub Data3: u16,
856	pub Data4: [u8; 8],
857}
858
859pub const IMAGE_DEBUG_TYPE_UNKNOWN: u32       = 0;
860pub const IMAGE_DEBUG_TYPE_COFF: u32          = 1;
861pub const IMAGE_DEBUG_TYPE_CODEVIEW: u32      = 2;
862pub const IMAGE_DEBUG_TYPE_FPO: u32           = 3;
863pub const IMAGE_DEBUG_TYPE_MISC: u32          = 4;
864pub const IMAGE_DEBUG_TYPE_EXCEPTION: u32     = 5;
865pub const IMAGE_DEBUG_TYPE_FIXUP: u32         = 6;
866pub const IMAGE_DEBUG_TYPE_OMAP_TO_SRC: u32   = 7;
867pub const IMAGE_DEBUG_TYPE_OMAP_FROM_SRC: u32 = 8;
868pub const IMAGE_DEBUG_TYPE_BORLAND: u32       = 9;
869pub const IMAGE_DEBUG_TYPE_RESERVED10: u32    = 10;
870pub const IMAGE_DEBUG_TYPE_CLSID: u32         = 11;
871pub const IMAGE_DEBUG_TYPE_VC_FEATURE: u32    = 12;
872pub const IMAGE_DEBUG_TYPE_POGO: u32          = 13;
873pub const IMAGE_DEBUG_TYPE_ILTCG: u32         = 14;
874pub const IMAGE_DEBUG_TYPE_MPX: u32           = 15;
875pub const IMAGE_DEBUG_TYPE_REPRO: u32         = 16;
876
877#[derive(Copy, Clone, Debug)]
878#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
879#[repr(C)]
880pub struct IMAGE_DEBUG_DIRECTORY {
881	pub Characteristics: u32,
882	pub TimeDateStamp: u32,
883	pub Version: IMAGE_VERSION<u16>,
884	pub Type: u32,
885	pub SizeOfData: u32,
886	pub AddressOfRawData: u32,
887	pub PointerToRawData: u32,
888}
889
890#[derive(Copy, Clone, Debug)]
891#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
892#[repr(C)]
893pub struct IMAGE_DEBUG_CV_INFO_PDB20 {
894	pub CvSignature: u32,
895	pub Offset: u32,
896	pub TimeDateStamp: u32,
897	pub Age: u32,
898	#[cfg_attr(feature = "serde", serde(skip))]
899	pub PdbFileName: [u8; 0],
900}
901
902#[derive(Copy, Clone, Debug)]
903#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
904#[repr(C)]
905pub struct IMAGE_DEBUG_CV_INFO_PDB70 {
906	pub CvSignature: u32,
907	pub Signature: GUID,
908	pub Age: u32,
909	#[cfg_attr(feature = "serde", serde(skip))]
910	pub PdbFileName: [u8; 0],
911}
912
913pub const IMAGE_DEBUG_MISC_EXENAME: u32 = 1;
914
915#[derive(Copy, Clone, Debug)]
916#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
917#[repr(C)]
918pub struct IMAGE_DEBUG_MISC {
919	pub DataType: u32,
920	pub Length: u32,
921	pub Unicode: u8,
922	#[cfg_attr(feature = "serde", serde(skip))]
923	pub Reserved: [u8; 3],
924	#[cfg_attr(feature = "serde", serde(skip))]
925	pub Name: [u8; 0],
926}
927
928pub const FRAME_FPO: u16 = 0;
929pub const FRAME_TRAP: u16 = 1;
930pub const FRAME_TSS: u16 = 2;
931
932#[derive(Copy, Clone, Debug)]
933#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
934#[repr(C)]
935pub struct FPO_DATA {
936	// offset 1st byte of function code
937	pub ulOffStart: u32,
938	// # bytes in function
939	pub cbProcSize: u32,
940	// # bytes in locals/4
941	pub cdwLocals: u16,
942	// # bytes in params/4
943	pub cdwParams: u16,
944	// # bytes in prolog
945	pub cbProlog: u8,
946	// cbRegs   : 3  // # regs saved
947	// fHasSEH  : 1  // TRUE if SEH in func
948	// fUseBP   : 1  // TRUE if EBP has been allocated
949	// reserved : 1  // reserved for future use
950	// cbFrame  : 2  // frame type
951	pub fFlags: u8,
952}
953
954#[derive(Copy, Clone, Debug)]
955#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
956#[repr(C)]
957pub struct IMAGE_DEBUG_VC_FEATURE {
958	pub PreVCPP: u32, // Pre-VC++ 11.00
959	pub CCPP: u32,    // C/C++
960	pub GS: u32,      // /GS
961	pub SDL: u32,     // /sdl
962	pub GuardN: u32,  // guardN
963}
964
965//----------------------------------------------------------------
966
967unsafe impl Pod for IMAGE_DOS_HEADER {}
968unsafe impl Pod for IMAGE_FILE_HEADER {}
969unsafe impl Pod for IMAGE_DATA_DIRECTORY {}
970unsafe impl<T: Pod> Pod for IMAGE_VERSION<T> {}
971unsafe impl Pod for IMAGE_OPTIONAL_HEADER32 {}
972unsafe impl Pod for IMAGE_OPTIONAL_HEADER64 {}
973unsafe impl Pod for IMAGE_NT_HEADERS32 {}
974unsafe impl Pod for IMAGE_NT_HEADERS64 {}
975unsafe impl Pod for IMAGE_SECTION_HEADER {}
976unsafe impl Pod for IMAGE_EXPORT_DIRECTORY {}
977unsafe impl Pod for IMAGE_IMPORT_DESCRIPTOR {}
978unsafe impl Pod for IMAGE_RESOURCE_DIRECTORY {}
979unsafe impl Pod for IMAGE_RESOURCE_DIRECTORY_ENTRY {}
980unsafe impl Pod for IMAGE_RESOURCE_DATA_ENTRY {}
981unsafe impl Pod for VS_VERSION {}
982unsafe impl Pod for VS_FIXEDFILEINFO {}
983unsafe impl Pod for IMAGE_BASE_RELOCATION {}
984unsafe impl Pod for IMAGE_LOAD_CONFIG_DIRECTORY32 {}
985unsafe impl Pod for IMAGE_LOAD_CONFIG_DIRECTORY64 {}
986unsafe impl Pod for IMAGE_LOAD_CONFIG_CODE_INTEGRITY {}
987unsafe impl Pod for IMAGE_DYNAMIC_RELOCATION_TABLE {}
988unsafe impl Pod for IMAGE_DYNAMIC_RELOCATION32 {}
989unsafe impl Pod for IMAGE_DYNAMIC_RELOCATION64 {}
990unsafe impl Pod for IMAGE_GUARDCF32 {}
991unsafe impl Pod for IMAGE_GUARDCF64 {}
992unsafe impl Pod for IMAGE_TLS_DIRECTORY32 {}
993unsafe impl Pod for IMAGE_TLS_DIRECTORY64 {}
994unsafe impl Pod for WIN_CERTIFICATE {}
995unsafe impl Pod for UNWIND_CODE {}
996unsafe impl Pod for UNWIND_INFO {}
997unsafe impl Pod for RUNTIME_FUNCTION {}
998unsafe impl Pod for SCOPE_RECORD {}
999unsafe impl Pod for SCOPE_TABLE {}
1000unsafe impl Pod for GUID {}
1001unsafe impl Pod for IMAGE_DEBUG_DIRECTORY {}
1002unsafe impl Pod for IMAGE_DEBUG_CV_INFO_PDB20 {}
1003unsafe impl Pod for IMAGE_DEBUG_CV_INFO_PDB70 {}
1004unsafe impl Pod for IMAGE_DEBUG_MISC {}
1005unsafe impl Pod for FPO_DATA {}
1006unsafe impl Pod for IMAGE_DEBUG_VC_FEATURE {}
1007
1008//----------------------------------------------------------------
1009
1010const _: [(); 64] = [(); mem::size_of::<IMAGE_DOS_HEADER>()];
1011const _: [(); 20] = [(); mem::size_of::<IMAGE_FILE_HEADER>()];
1012const _: [(); 8] = [(); mem::size_of::<IMAGE_DATA_DIRECTORY>()];
1013const _: [(); 96] = [(); mem::size_of::<IMAGE_OPTIONAL_HEADER32>()]; // Unsized
1014const _: [(); 112] = [(); mem::size_of::<IMAGE_OPTIONAL_HEADER64>()]; // Unsized
1015const _: [(); 120] = [(); mem::size_of::<IMAGE_NT_HEADERS32>()]; // Unsized
1016const _: [(); 136] = [(); mem::size_of::<IMAGE_NT_HEADERS64>()]; // Unsized
1017const _: [(); 40] = [(); mem::size_of::<IMAGE_SECTION_HEADER>()];
1018const _: [(); 40] = [(); mem::size_of::<IMAGE_EXPORT_DIRECTORY>()];
1019const _: [(); 20] = [(); mem::size_of::<IMAGE_IMPORT_DESCRIPTOR>()];
1020const _: [(); 16] = [(); mem::size_of::<IMAGE_RESOURCE_DIRECTORY>()];
1021const _: [(); 8] = [(); mem::size_of::<IMAGE_RESOURCE_DIRECTORY_ENTRY>()];
1022const _: [(); 16] = [(); mem::size_of::<IMAGE_RESOURCE_DATA_ENTRY>()];
1023const _: [(); 8] = [(); mem::size_of::<IMAGE_BASE_RELOCATION>()];
1024const _: [(); 18 * 4] = [(); mem::size_of::<IMAGE_LOAD_CONFIG_DIRECTORY32>()];
1025const _: [(); 28 * 4] = [(); mem::size_of::<IMAGE_LOAD_CONFIG_DIRECTORY64>()];
1026const _: [(); 3 * 4] = [(); mem::size_of::<IMAGE_LOAD_CONFIG_CODE_INTEGRITY>()];
1027const _: [(); 2 * 4] = [(); mem::size_of::<IMAGE_DYNAMIC_RELOCATION_TABLE>()]; // Unsized
1028const _: [(); 2 * 4] = [(); mem::size_of::<IMAGE_DYNAMIC_RELOCATION32>()]; // Unsized
1029const _: [(); 3 * 4] = [(); mem::size_of::<IMAGE_DYNAMIC_RELOCATION64>()]; // Unsized
1030const _: [(); 22 * 4] = [(); mem::size_of::<IMAGE_GUARDCF32>()];
1031const _: [(); 36 * 4] = [(); mem::size_of::<IMAGE_GUARDCF64>()];
1032const _: [(); 24] = [(); mem::size_of::<IMAGE_TLS_DIRECTORY32>()];
1033const _: [(); 40] = [(); mem::size_of::<IMAGE_TLS_DIRECTORY64>()];
1034const _: [(); 2] = [(); mem::size_of::<UNWIND_CODE>()];
1035const _: [(); 4] = [(); mem::size_of::<UNWIND_INFO>()]; // Unsized
1036const _: [(); 12] = [(); mem::size_of::<RUNTIME_FUNCTION>()];
1037const _: [(); 4] = [(); mem::size_of::<SCOPE_TABLE>()]; // Unsized
1038const _: [(); 16] = [(); mem::size_of::<SCOPE_RECORD>()];
1039const _: [(); 16] = [(); mem::size_of::<GUID>()];
1040const _: [(); 28] = [(); mem::size_of::<IMAGE_DEBUG_DIRECTORY>()];
1041const _: [(); 16] = [(); mem::size_of::<IMAGE_DEBUG_CV_INFO_PDB20>()]; // Unsized
1042const _: [(); 24] = [(); mem::size_of::<IMAGE_DEBUG_CV_INFO_PDB70>()]; // Unsized
1043const _: [(); 12] = [(); mem::size_of::<IMAGE_DEBUG_MISC>()]; // Unsized
pelite/image.rs

pelite/
image.rs
