ホーム › System.Diagnostics.Debug › IMAGE_OPTIONAL_HEADER64

IMAGE_OPTIONAL_HEADER64

構造体

サイズx64: 240 バイト / x86: 240 バイトパッキング4

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド	型	サイズ	x64	x86	説明
Magic	IMAGE_OPTIONAL_HEADER_MAGIC	2	+0	+0	オプションヘッダ形式を示すマジック値(PE32/PE32+)。
MajorLinkerVersion	BYTE	1	+2	+2	リンカのメジャーバージョン。
MinorLinkerVersion	BYTE	1	+3	+3	リンカのマイナーバージョン。
SizeOfCode	DWORD	4	+4	+4	全コードセクションの合計サイズ。
SizeOfInitializedData	DWORD	4	+8	+8	初期化済みデータの合計サイズ。
SizeOfUninitializedData	DWORD	4	+12	+12	未初期化データ(BSS)の合計サイズ。
AddressOfEntryPoint	DWORD	4	+16	+16	エントリポイントのRVA。
BaseOfCode	DWORD	4	+20	+20	コードセクションの基準RVA。
ImageBase	ULONGLONG	8	+24	+24	優先ロードベースアドレス(64ビット)。
SectionAlignment	DWORD	4	+32	+32	メモリ上のセクション整列単位。
FileAlignment	DWORD	4	+36	+36	ファイル上のセクション整列単位。
MajorOperatingSystemVersion	WORD	2	+40	+40	必要OSのメジャーバージョン。
MinorOperatingSystemVersion	WORD	2	+42	+42	必要OSのマイナーバージョン。
MajorImageVersion	WORD	2	+44	+44	イメージのメジャーバージョン。
MinorImageVersion	WORD	2	+46	+46	イメージのマイナーバージョン。
MajorSubsystemVersion	WORD	2	+48	+48	サブシステムのメジャーバージョン。
MinorSubsystemVersion	WORD	2	+50	+50	サブシステムのマイナーバージョン。
Win32VersionValue	DWORD	4	+52	+52	予約。0でなければならない。
SizeOfImage	DWORD	4	+56	+56	メモリ上のイメージ全体サイズ。
SizeOfHeaders	DWORD	4	+60	+60	全ヘッダの合計サイズ(FileAlignment整列)。
CheckSum	DWORD	4	+64	+64	イメージのチェックサム。
Subsystem	IMAGE_SUBSYSTEM	2	+68	+68	必要なサブシステムを示すIMAGE_SUBSYSTEM値。
DllCharacteristics	IMAGE_DLL_CHARACTERISTICS	2	+70	+70	DLL特性を示すIMAGE_DLL_CHARACTERISTICSフラグ。
SizeOfStackReserve	ULONGLONG	8	+72	+72	スタックに予約する仮想メモリサイズ(64ビット)。
SizeOfStackCommit	ULONGLONG	8	+80	+80	初期コミットするスタックサイズ(64ビット)。
SizeOfHeapReserve	ULONGLONG	8	+88	+88	ヒープに予約する仮想メモリサイズ(64ビット)。
SizeOfHeapCommit	ULONGLONG	8	+96	+96	初期コミットするヒープサイズ(64ビット)。
LoaderFlags	DWORD	4	+104	+104	予約。0でなければならない。
NumberOfRvaAndSizes	DWORD	4	+108	+108	DataDirectory配列のエントリ数。
DataDirectory	IMAGE_DATA_DIRECTORY	128	+112	+112	データディレクトリ(IMAGE_DATA_DIRECTORY)配列。

各言語での定義

#include <windows.h>

// IMAGE_DATA_DIRECTORY  (x64 8 / x86 8 バイト)
typedef struct IMAGE_DATA_DIRECTORY {
    DWORD VirtualAddress;
    DWORD Size;
} IMAGE_DATA_DIRECTORY;

// IMAGE_OPTIONAL_HEADER64  (x64 240 / x86 240 バイト)
#pragma pack(push, 4)
typedef struct IMAGE_OPTIONAL_HEADER64 {
    IMAGE_OPTIONAL_HEADER_MAGIC Magic;
    BYTE MajorLinkerVersion;
    BYTE MinorLinkerVersion;
    DWORD SizeOfCode;
    DWORD SizeOfInitializedData;
    DWORD SizeOfUninitializedData;
    DWORD AddressOfEntryPoint;
    DWORD BaseOfCode;
    ULONGLONG ImageBase;
    DWORD SectionAlignment;
    DWORD FileAlignment;
    WORD MajorOperatingSystemVersion;
    WORD MinorOperatingSystemVersion;
    WORD MajorImageVersion;
    WORD MinorImageVersion;
    WORD MajorSubsystemVersion;
    WORD MinorSubsystemVersion;
    DWORD Win32VersionValue;
    DWORD SizeOfImage;
    DWORD SizeOfHeaders;
    DWORD CheckSum;
    IMAGE_SUBSYSTEM Subsystem;
    IMAGE_DLL_CHARACTERISTICS DllCharacteristics;
    ULONGLONG SizeOfStackReserve;
    ULONGLONG SizeOfStackCommit;
    ULONGLONG SizeOfHeapReserve;
    ULONGLONG SizeOfHeapCommit;
    DWORD LoaderFlags;
    DWORD NumberOfRvaAndSizes;
    IMAGE_DATA_DIRECTORY DataDirectory[16];
} IMAGE_OPTIONAL_HEADER64;
#pragma pack(pop)

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IMAGE_DATA_DIRECTORY
{
    public uint VirtualAddress;
    public uint Size;
}

[StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Unicode)]
public struct IMAGE_OPTIONAL_HEADER64
{
    public ushort Magic;
    public byte MajorLinkerVersion;
    public byte MinorLinkerVersion;
    public uint SizeOfCode;
    public uint SizeOfInitializedData;
    public uint SizeOfUninitializedData;
    public uint AddressOfEntryPoint;
    public uint BaseOfCode;
    public ulong ImageBase;
    public uint SectionAlignment;
    public uint FileAlignment;
    public ushort MajorOperatingSystemVersion;
    public ushort MinorOperatingSystemVersion;
    public ushort MajorImageVersion;
    public ushort MinorImageVersion;
    public ushort MajorSubsystemVersion;
    public ushort MinorSubsystemVersion;
    public uint Win32VersionValue;
    public uint SizeOfImage;
    public uint SizeOfHeaders;
    public uint CheckSum;
    public ushort Subsystem;
    public ushort DllCharacteristics;
    public ulong SizeOfStackReserve;
    public ulong SizeOfStackCommit;
    public ulong SizeOfHeapReserve;
    public ulong SizeOfHeapCommit;
    public uint LoaderFlags;
    public uint NumberOfRvaAndSizes;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public IMAGE_DATA_DIRECTORY[] DataDirectory;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IMAGE_DATA_DIRECTORY
    Public VirtualAddress As UInteger
    Public Size As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, Pack:=4, CharSet:=CharSet.Unicode)>
Public Structure IMAGE_OPTIONAL_HEADER64
    Public Magic As UShort
    Public MajorLinkerVersion As Byte
    Public MinorLinkerVersion As Byte
    Public SizeOfCode As UInteger
    Public SizeOfInitializedData As UInteger
    Public SizeOfUninitializedData As UInteger
    Public AddressOfEntryPoint As UInteger
    Public BaseOfCode As UInteger
    Public ImageBase As ULong
    Public SectionAlignment As UInteger
    Public FileAlignment As UInteger
    Public MajorOperatingSystemVersion As UShort
    Public MinorOperatingSystemVersion As UShort
    Public MajorImageVersion As UShort
    Public MinorImageVersion As UShort
    Public MajorSubsystemVersion As UShort
    Public MinorSubsystemVersion As UShort
    Public Win32VersionValue As UInteger
    Public SizeOfImage As UInteger
    Public SizeOfHeaders As UInteger
    Public CheckSum As UInteger
    Public Subsystem As UShort
    Public DllCharacteristics As UShort
    Public SizeOfStackReserve As ULong
    Public SizeOfStackCommit As ULong
    Public SizeOfHeapReserve As ULong
    Public SizeOfHeapCommit As ULong
    Public LoaderFlags As UInteger
    Public NumberOfRvaAndSizes As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=16)> Public DataDirectory() As IMAGE_DATA_DIRECTORY
End Structure

import ctypes
from ctypes import wintypes

class IMAGE_DATA_DIRECTORY(ctypes.Structure):
    _fields_ = [
        ("VirtualAddress", wintypes.DWORD),
        ("Size", wintypes.DWORD),
    ]

class IMAGE_OPTIONAL_HEADER64(ctypes.Structure):
    _pack_ = 4
    _fields_ = [
        ("Magic", ctypes.c_ushort),
        ("MajorLinkerVersion", ctypes.c_ubyte),
        ("MinorLinkerVersion", ctypes.c_ubyte),
        ("SizeOfCode", wintypes.DWORD),
        ("SizeOfInitializedData", wintypes.DWORD),
        ("SizeOfUninitializedData", wintypes.DWORD),
        ("AddressOfEntryPoint", wintypes.DWORD),
        ("BaseOfCode", wintypes.DWORD),
        ("ImageBase", ctypes.c_ulonglong),
        ("SectionAlignment", wintypes.DWORD),
        ("FileAlignment", wintypes.DWORD),
        ("MajorOperatingSystemVersion", ctypes.c_ushort),
        ("MinorOperatingSystemVersion", ctypes.c_ushort),
        ("MajorImageVersion", ctypes.c_ushort),
        ("MinorImageVersion", ctypes.c_ushort),
        ("MajorSubsystemVersion", ctypes.c_ushort),
        ("MinorSubsystemVersion", ctypes.c_ushort),
        ("Win32VersionValue", wintypes.DWORD),
        ("SizeOfImage", wintypes.DWORD),
        ("SizeOfHeaders", wintypes.DWORD),
        ("CheckSum", wintypes.DWORD),
        ("Subsystem", ctypes.c_ushort),
        ("DllCharacteristics", ctypes.c_ushort),
        ("SizeOfStackReserve", ctypes.c_ulonglong),
        ("SizeOfStackCommit", ctypes.c_ulonglong),
        ("SizeOfHeapReserve", ctypes.c_ulonglong),
        ("SizeOfHeapCommit", ctypes.c_ulonglong),
        ("LoaderFlags", wintypes.DWORD),
        ("NumberOfRvaAndSizes", wintypes.DWORD),
        ("DataDirectory", IMAGE_DATA_DIRECTORY * 16),
    ]

#[repr(C)]
pub struct IMAGE_DATA_DIRECTORY {
    pub VirtualAddress: u32,
    pub Size: u32,
}

#[repr(C, packed(4))]
pub struct IMAGE_OPTIONAL_HEADER64 {
    pub Magic: u16,
    pub MajorLinkerVersion: u8,
    pub MinorLinkerVersion: u8,
    pub SizeOfCode: u32,
    pub SizeOfInitializedData: u32,
    pub SizeOfUninitializedData: u32,
    pub AddressOfEntryPoint: u32,
    pub BaseOfCode: u32,
    pub ImageBase: u64,
    pub SectionAlignment: u32,
    pub FileAlignment: u32,
    pub MajorOperatingSystemVersion: u16,
    pub MinorOperatingSystemVersion: u16,
    pub MajorImageVersion: u16,
    pub MinorImageVersion: u16,
    pub MajorSubsystemVersion: u16,
    pub MinorSubsystemVersion: u16,
    pub Win32VersionValue: u32,
    pub SizeOfImage: u32,
    pub SizeOfHeaders: u32,
    pub CheckSum: u32,
    pub Subsystem: u16,
    pub DllCharacteristics: u16,
    pub SizeOfStackReserve: u64,
    pub SizeOfStackCommit: u64,
    pub SizeOfHeapReserve: u64,
    pub SizeOfHeapCommit: u64,
    pub LoaderFlags: u32,
    pub NumberOfRvaAndSizes: u32,
    pub DataDirectory: [IMAGE_DATA_DIRECTORY; 16],
}

import "golang.org/x/sys/windows"

type IMAGE_DATA_DIRECTORY struct {
	VirtualAddress uint32
	Size uint32
}

type IMAGE_OPTIONAL_HEADER64 struct {
	Magic uint16
	MajorLinkerVersion byte
	MinorLinkerVersion byte
	SizeOfCode uint32
	SizeOfInitializedData uint32
	SizeOfUninitializedData uint32
	AddressOfEntryPoint uint32
	BaseOfCode uint32
	ImageBase uint64
	SectionAlignment uint32
	FileAlignment uint32
	MajorOperatingSystemVersion uint16
	MinorOperatingSystemVersion uint16
	MajorImageVersion uint16
	MinorImageVersion uint16
	MajorSubsystemVersion uint16
	MinorSubsystemVersion uint16
	Win32VersionValue uint32
	SizeOfImage uint32
	SizeOfHeaders uint32
	CheckSum uint32
	Subsystem uint16
	DllCharacteristics uint16
	SizeOfStackReserve uint64
	SizeOfStackCommit uint64
	SizeOfHeapReserve uint64
	SizeOfHeapCommit uint64
	LoaderFlags uint32
	NumberOfRvaAndSizes uint32
	DataDirectory [16]IMAGE_DATA_DIRECTORY
}

type
  IMAGE_DATA_DIRECTORY = record
    VirtualAddress: DWORD;
    Size: DWORD;
  end;

  IMAGE_OPTIONAL_HEADER64 = packed record
    Magic: Word;
    MajorLinkerVersion: Byte;
    MinorLinkerVersion: Byte;
    SizeOfCode: DWORD;
    SizeOfInitializedData: DWORD;
    SizeOfUninitializedData: DWORD;
    AddressOfEntryPoint: DWORD;
    BaseOfCode: DWORD;
    ImageBase: UInt64;
    SectionAlignment: DWORD;
    FileAlignment: DWORD;
    MajorOperatingSystemVersion: Word;
    MinorOperatingSystemVersion: Word;
    MajorImageVersion: Word;
    MinorImageVersion: Word;
    MajorSubsystemVersion: Word;
    MinorSubsystemVersion: Word;
    Win32VersionValue: DWORD;
    SizeOfImage: DWORD;
    SizeOfHeaders: DWORD;
    CheckSum: DWORD;
    Subsystem: Word;
    DllCharacteristics: Word;
    SizeOfStackReserve: UInt64;
    SizeOfStackCommit: UInt64;
    SizeOfHeapReserve: UInt64;
    SizeOfHeapCommit: UInt64;
    LoaderFlags: DWORD;
    NumberOfRvaAndSizes: DWORD;
    DataDirectory: array[0..15] of IMAGE_DATA_DIRECTORY;
  end;

const IMAGE_DATA_DIRECTORY = extern struct {
    VirtualAddress: u32,
    Size: u32,
};

const IMAGE_OPTIONAL_HEADER64 = extern struct {
    Magic: u16,
    MajorLinkerVersion: u8,
    MinorLinkerVersion: u8,
    SizeOfCode: u32,
    SizeOfInitializedData: u32,
    SizeOfUninitializedData: u32,
    AddressOfEntryPoint: u32,
    BaseOfCode: u32,
    ImageBase: u64,
    SectionAlignment: u32,
    FileAlignment: u32,
    MajorOperatingSystemVersion: u16,
    MinorOperatingSystemVersion: u16,
    MajorImageVersion: u16,
    MinorImageVersion: u16,
    MajorSubsystemVersion: u16,
    MinorSubsystemVersion: u16,
    Win32VersionValue: u32,
    SizeOfImage: u32,
    SizeOfHeaders: u32,
    CheckSum: u32,
    Subsystem: u16,
    DllCharacteristics: u16,
    SizeOfStackReserve: u64,
    SizeOfStackCommit: u64,
    SizeOfHeapReserve: u64,
    SizeOfHeapCommit: u64,
    LoaderFlags: u32,
    NumberOfRvaAndSizes: u32,
    DataDirectory: [16]IMAGE_DATA_DIRECTORY,
};

type
  IMAGE_DATA_DIRECTORY {.bycopy.} = object
    VirtualAddress: uint32
    Size: uint32

  IMAGE_OPTIONAL_HEADER64 {.packed.} = object
    Magic: uint16
    MajorLinkerVersion: uint8
    MinorLinkerVersion: uint8
    SizeOfCode: uint32
    SizeOfInitializedData: uint32
    SizeOfUninitializedData: uint32
    AddressOfEntryPoint: uint32
    BaseOfCode: uint32
    ImageBase: uint64
    SectionAlignment: uint32
    FileAlignment: uint32
    MajorOperatingSystemVersion: uint16
    MinorOperatingSystemVersion: uint16
    MajorImageVersion: uint16
    MinorImageVersion: uint16
    MajorSubsystemVersion: uint16
    MinorSubsystemVersion: uint16
    Win32VersionValue: uint32
    SizeOfImage: uint32
    SizeOfHeaders: uint32
    CheckSum: uint32
    Subsystem: uint16
    DllCharacteristics: uint16
    SizeOfStackReserve: uint64
    SizeOfStackCommit: uint64
    SizeOfHeapReserve: uint64
    SizeOfHeapCommit: uint64
    LoaderFlags: uint32
    NumberOfRvaAndSizes: uint32
    DataDirectory: array[16, IMAGE_DATA_DIRECTORY]

struct IMAGE_DATA_DIRECTORY
{
    uint VirtualAddress;
    uint Size;
}

align(4)
struct IMAGE_OPTIONAL_HEADER64
{
    ushort Magic;
    ubyte MajorLinkerVersion;
    ubyte MinorLinkerVersion;
    uint SizeOfCode;
    uint SizeOfInitializedData;
    uint SizeOfUninitializedData;
    uint AddressOfEntryPoint;
    uint BaseOfCode;
    ulong ImageBase;
    uint SectionAlignment;
    uint FileAlignment;
    ushort MajorOperatingSystemVersion;
    ushort MinorOperatingSystemVersion;
    ushort MajorImageVersion;
    ushort MinorImageVersion;
    ushort MajorSubsystemVersion;
    ushort MinorSubsystemVersion;
    uint Win32VersionValue;
    uint SizeOfImage;
    uint SizeOfHeaders;
    uint CheckSum;
    ushort Subsystem;
    ushort DllCharacteristics;
    ulong SizeOfStackReserve;
    ulong SizeOfStackCommit;
    ulong SizeOfHeapReserve;
    ulong SizeOfHeapCommit;
    uint LoaderFlags;
    uint NumberOfRvaAndSizes;
    IMAGE_DATA_DIRECTORY[16] DataDirectory;
}

HSP用定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; IMAGE_OPTIONAL_HEADER64 サイズ: 240 バイト(x64)
dim st, 60    ; 4byte整数×60(構造体サイズ 240 / 4 切り上げ)
; Magic : IMAGE_OPTIONAL_HEADER_MAGIC (+0, 2byte)  wpoke st,0,値  /  値 = wpeek(st,0)
; MajorLinkerVersion : BYTE (+2, 1byte)  poke st,2,値  /  値 = peek(st,2)
; MinorLinkerVersion : BYTE (+3, 1byte)  poke st,3,値  /  値 = peek(st,3)
; SizeOfCode : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; SizeOfInitializedData : DWORD (+8, 4byte)  st.2 = 値  /  値 = st.2   (lpoke/lpeek も可)
; SizeOfUninitializedData : DWORD (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; AddressOfEntryPoint : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; BaseOfCode : DWORD (+20, 4byte)  st.5 = 値  /  値 = st.5   (lpoke/lpeek も可)
; ImageBase : ULONGLONG (+24, 8byte)  qpoke st,24,値 / qpeek(st,24)  ※IronHSPのみ。3.7/3.8は lpoke st,24,下位 : lpoke st,28,上位
; SectionAlignment : DWORD (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; FileAlignment : DWORD (+36, 4byte)  st.9 = 値  /  値 = st.9   (lpoke/lpeek も可)
; MajorOperatingSystemVersion : WORD (+40, 2byte)  wpoke st,40,値  /  値 = wpeek(st,40)
; MinorOperatingSystemVersion : WORD (+42, 2byte)  wpoke st,42,値  /  値 = wpeek(st,42)
; MajorImageVersion : WORD (+44, 2byte)  wpoke st,44,値  /  値 = wpeek(st,44)
; MinorImageVersion : WORD (+46, 2byte)  wpoke st,46,値  /  値 = wpeek(st,46)
; MajorSubsystemVersion : WORD (+48, 2byte)  wpoke st,48,値  /  値 = wpeek(st,48)
; MinorSubsystemVersion : WORD (+50, 2byte)  wpoke st,50,値  /  値 = wpeek(st,50)
; Win32VersionValue : DWORD (+52, 4byte)  st.13 = 値  /  値 = st.13   (lpoke/lpeek も可)
; SizeOfImage : DWORD (+56, 4byte)  st.14 = 値  /  値 = st.14   (lpoke/lpeek も可)
; SizeOfHeaders : DWORD (+60, 4byte)  st.15 = 値  /  値 = st.15   (lpoke/lpeek も可)
; CheckSum : DWORD (+64, 4byte)  st.16 = 値  /  値 = st.16   (lpoke/lpeek も可)
; Subsystem : IMAGE_SUBSYSTEM (+68, 2byte)  wpoke st,68,値  /  値 = wpeek(st,68)
; DllCharacteristics : IMAGE_DLL_CHARACTERISTICS (+70, 2byte)  wpoke st,70,値  /  値 = wpeek(st,70)
; SizeOfStackReserve : ULONGLONG (+72, 8byte)  qpoke st,72,値 / qpeek(st,72)  ※IronHSPのみ。3.7/3.8は lpoke st,72,下位 : lpoke st,76,上位
; SizeOfStackCommit : ULONGLONG (+80, 8byte)  qpoke st,80,値 / qpeek(st,80)  ※IronHSPのみ。3.7/3.8は lpoke st,80,下位 : lpoke st,84,上位
; SizeOfHeapReserve : ULONGLONG (+88, 8byte)  qpoke st,88,値 / qpeek(st,88)  ※IronHSPのみ。3.7/3.8は lpoke st,88,下位 : lpoke st,92,上位
; SizeOfHeapCommit : ULONGLONG (+96, 8byte)  qpoke st,96,値 / qpeek(st,96)  ※IronHSPのみ。3.7/3.8は lpoke st,96,下位 : lpoke st,100,上位
; LoaderFlags : DWORD (+104, 4byte)  st.26 = 値  /  値 = st.26   (lpoke/lpeek も可)
; NumberOfRvaAndSizes : DWORD (+108, 4byte)  st.27 = 値  /  値 = st.27   (lpoke/lpeek も可)
; DataDirectory : IMAGE_DATA_DIRECTORY (+112, 128byte)  varptr(st)+112 を基点に操作(128byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global IMAGE_DATA_DIRECTORY
    #field int VirtualAddress
    #field int Size
#endstruct

#defstruct global IMAGE_OPTIONAL_HEADER64, pack=4
    #field short Magic
    #field byte MajorLinkerVersion
    #field byte MinorLinkerVersion
    #field int SizeOfCode
    #field int SizeOfInitializedData
    #field int SizeOfUninitializedData
    #field int AddressOfEntryPoint
    #field int BaseOfCode
    #field int64 ImageBase
    #field int SectionAlignment
    #field int FileAlignment
    #field short MajorOperatingSystemVersion
    #field short MinorOperatingSystemVersion
    #field short MajorImageVersion
    #field short MinorImageVersion
    #field short MajorSubsystemVersion
    #field short MinorSubsystemVersion
    #field int Win32VersionValue
    #field int SizeOfImage
    #field int SizeOfHeaders
    #field int CheckSum
    #field short Subsystem
    #field short DllCharacteristics
    #field int64 SizeOfStackReserve
    #field int64 SizeOfStackCommit
    #field int64 SizeOfHeapReserve
    #field int64 SizeOfHeapCommit
    #field int LoaderFlags
    #field int NumberOfRvaAndSizes
    #field IMAGE_DATA_DIRECTORY DataDirectory 16
#endstruct

stdim st, IMAGE_OPTIONAL_HEADER64        ; NSTRUCT 変数を確保
st->Magic = 100
mes "Magic=" + st->Magic

IMAGE_OPTIONAL_HEADER64

フィールド

各言語での定義

HSP用 定義

HSP用定義