peexe.h

#ifndef PEEXE_H
#define PEEXE_H
 
#include <array>
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/options.h"
#include "../linker/segment_manager.h"
#include "coff.h"
#include "mzexe.h"
#include "neexe.h"
 
namespace Microsoft
{
    class PEFormat : public COFF::COFFFormat
    {
    public:
        std::array<char, 4> pe_signature;
 
        struct version_type
        {
            uint16_t major, minor;
        };
 
        class PEOptionalHeader : public AOutHeader
        {
        public:
            static constexpr uint16_t ROM32 = 0x0107;
            static constexpr uint16_t EXE32 = 0x010B;
            static constexpr uint16_t EXE64 = 0x020B;
 
            static constexpr offset_t Win32Base = 0x00400000;
            static constexpr offset_t Dll32Base = 0x10000000;
            static constexpr offset_t WinCEBase = 0x00010000;
            static constexpr offset_t Win64Base = 0x140000000;
            static constexpr offset_t Dll64Base = 0x180000000;
 
            offset_t image_base = 0;
            uint32_t section_align = 0;
            uint32_t file_align = 0;
            version_type os_version = { };
            version_type image_version = { };
            version_type subsystem_version = { };
            uint32_t win32_version = 0;
            uint32_t total_image_size = 0;
            uint32_t total_headers_size = 0;
            uint32_t checksum = 0;
            enum SubsystemType : uint16_t
            {
                Unknown = 0,
                Native = 1,
                WindowsGUI = 2,
                WindowsCUI = 3,
                OS2CUI = 5,
                POSIXCUI = 7,
                NativeWin95 = 8,
                WinCEGUI = 9,
                EFIApplication = 10,
                EFIBootServiceDriver = 11,
                EFIRuntimeDriver = 12,
                EFIROM = 13,
                Xbox = 14,
                WindowsBootApplication = 16,
            };
            SubsystemType subsystem = Unknown;
            uint16_t flags = 0;
            offset_t reserved_stack_size = 0;
            offset_t committed_stack_size = 0;
            offset_t reserved_heap_size = 0;
            offset_t committed_heap_size = 0;
            uint32_t loader_flags = 0;
 
            struct DataDirectory
            {
                uint32_t address = 0, size = 0;
            };
 
            enum
            {
                DirExportTable,
                DirImportTable,
                DirResourceTable,
                DirExceptionTable,
                DirCertificateTable,
                DirBaseRelocationTable,
                DirDebug,
                DirArchitecture, // reserved
                DirGlobalPointer,
                DirTLSTable,
                DirLoadConfigTable,
                DirBoundImport,
                DirIAT,
                DirDelayImportDescriptor,
                DirCLRRuntimeHeader,
                DirReserved,
                DirTotalCount,
            };
 
            std::vector<DataDirectory> data_directories;
 
            bool Is64Bit() const;
 
            PEOptionalHeader()
                : AOutHeader()
            {
            }
 
            uint32_t GetSize() const override;
 
            void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
 
            void WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
 
            offset_t CalculateValues(COFFFormat& coff) override;
 
            uint32_t AddressToRVA(offset_t address) const;
            offset_t RVAToAddress(uint32_t rva, bool suppress_on_zero = false) const;
 
            std::string GetHeaderFormatName(const COFFFormat& coff) const override;
 
        protected:
            void DumpFields(const COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) const override;
        };
 
        PEOptionalHeader& GetOptionalHeader();
        const PEOptionalHeader& GetOptionalHeader() const;
 
        bool Is64Bit() const;
 
        uint32_t AddressToRVA(offset_t address) const;
        offset_t RVAToAddress(uint32_t rva, bool suppress_on_zero = false) const;
        offset_t RVAToFileOffset(uint32_t rva) const;
 
        class Section : public COFF::COFFFormat::Section
        {
        public:
            // TODO: other flags
            static constexpr uint32_t DISCARDABLE = 0x02000000;
            static constexpr uint32_t EXECUTE = 0x20000000;
            static constexpr uint32_t READ = 0x40000000;
            static constexpr uint32_t WRITE = 0x80000000;
 
            Section(uint32_t flags = 0, std::shared_ptr<Linker::Contents> image = nullptr)
                : COFFFormat::Section(flags, image)
            {
            }
 
            constexpr offset_t& virtual_size() { return physical_address; }
            constexpr const offset_t& virtual_size() const { return physical_address; }
 
            void ReadSectionData(const std::shared_ptr<Linker::Reader>& rd, const COFFFormat& coff_format) override;
            void WriteSectionData(const std::shared_ptr<Linker::Writer>& wr, const COFFFormat& coff_format) const override;
            uint32_t ImageSize(const COFFFormat& coff_format) const override;
            void Dump(Dumper::Dumper& dump, const COFFFormat& format, unsigned section_index) const override;
 
            virtual void ReadSectionData(const std::shared_ptr<Linker::Reader>& rd, const PEFormat& fmt);
            virtual void WriteSectionData(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt) const;
            virtual uint32_t ImageSize(const PEFormat& fmt) const;
            virtual uint32_t MemorySize(const PEFormat& fmt) const;
 
            size_t ReadData(size_t bytes, size_t offset, void * buffer) const;
        };
 
        struct PESections
        {
            const PEFormat * pe;
            struct iterator
            {
                std::vector<std::shared_ptr<COFFFormat::Section>>::iterator coff_iterator;
                bool operator !=(const iterator& other) const;
                iterator& operator++();
                std::shared_ptr<PEFormat::Section> operator*() const;
            };
            struct const_iterator
            {
                std::vector<std::shared_ptr<COFFFormat::Section>>::const_iterator coff_iterator;
                bool operator !=(const const_iterator& other) const;
                const_iterator& operator++();
                std::shared_ptr<const PEFormat::Section> operator*() const;
            };
            struct const_reference
            {
                std::vector<std::shared_ptr<COFFFormat::Section>>::const_reference coff_reference;
                PEFormat::Section * get() const;
                PEFormat::Section * operator->() const;
            };
            iterator begin();
            const_iterator begin() const;
            iterator end();
            const_iterator end() const;
            size_t size() const;
            const_reference back() const;
        };
 
        const PESections Sections() const;
        PESections Sections();
 
        size_t MapRVAToSectionData(uint32_t rva, size_t bytes, std::shared_ptr<Section>& found_section, size_t& section_offset) const;
 
        size_t ReadData(size_t bytes, uint32_t rva, void * buffer) const;
        uint64_t ReadUnsigned(size_t bytes, uint32_t rva, ::EndianType endiantype) const;
        int64_t ReadSigned(size_t bytes, uint32_t rva, ::EndianType endiantype) const;
        std::string ReadASCII(uint32_t rva, char terminator, size_t maximum = size_t(-1)) const;
        std::string ReadData(uint32_t rva, size_t count) const;
 
        template <typename Clock = POSIX_clock>
            Timestamp<Clock> ReadTimestamp(uint32_t rva, EndianType endiantype) const
        {
            if constexpr(std::is_signed_v<typename Clock::rep>)
                return Clock::to_time_point(ReadSigned(sizeof(typename Clock::rep), rva, endiantype));
            else
                return Clock::to_time_point(ReadUnsigned(sizeof(typename Clock::rep), rva, endiantype));
        }
 
        class MemoryPortionImage : public virtual Linker::Image
        {
        public:
            const PEFormat& fmt;
            uint32_t rva;
            uint32_t size;
 
            MemoryPortionImage(const PEFormat& fmt, uint32_t rva, uint32_t size)
                : fmt(fmt), rva(rva), size(size)
            {
            }
 
            offset_t ImageSize() const override;
            size_t ReadData(size_t bytes, offset_t offset, void * buffer) const override;
        };
 
        class Resource
        {
        public:
            typedef std::variant<std::string, uint32_t> Identifier;
 
            static constexpr size_t Level_Type = 0;
            static constexpr size_t Level_Name = 1;
            static constexpr size_t Level_Language = 2;
            static constexpr size_t Level_Count = 3;
 
            static void DumpIdentifier(std::vector<Identifier> full_identifier, Dumper::Container& container);
 
            std::vector<Identifier> full_identifier;
            uint32_t data_rva = 0;
            uint32_t size = 0;
            uint32_t codepage = 0;
            uint32_t reserved = 0;
 
            std::shared_ptr<Linker::Section> section = nullptr;
 
            Resource(const std::vector<Resource::Identifier>& full_identifier)
                : full_identifier(full_identifier)
            {
            }
 
            size_t ParseResourceData(const PEFormat& fmt, uint32_t rva);
            void DumpResource(const PEFormat& fmt, Dumper::Dumper& dump, uint32_t rva) const;
            uint32_t AssignAddress(PEFormat& fmt, uint32_t rva);
            void WriteDirectories(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt, uint32_t section_pointer) const;
            offset_t WriteResource(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt, uint32_t rva_to_offset) const;
        };
 
        class ResourcesSection;
 
        class ResourceDirectory
        {
        public:
            class Name
            {
            public:
                std::string name;
                uint32_t offset = 0;
 
                Name(std::string name = "")
                    : name(name)
                {
                }
            };
 
            template <typename Key>
                class Entry
            {
            public:
                Key identifier;
                std::variant<std::shared_ptr<Resource>, std::shared_ptr<ResourceDirectory>> content;
                uint32_t content_offset = 0;
 
                bool IsSubdirectory() const { return std::get_if<std::shared_ptr<ResourceDirectory>>(&content); }
            };
 
            uint32_t flags = 0;
            ::Timestamp<POSIX_clock> timestamp = { };
            version_type version = { };
            std::vector<Entry<Name>> name_entries;
            std::vector<Entry<uint32_t>> id_entries;
 
            void AddResource(std::shared_ptr<Resource>& resource, size_t level = 0);
 
            size_t ParseResourceDirectoryData(const PEFormat& fmt, uint32_t directory_rva, uint32_t rva, const std::vector<Resource::Identifier>& partial_identifier);
            void DumpResourceDirectory(const PEFormat& fmt, Dumper::Dumper& dump, uint32_t directory_rva, uint32_t rva, const std::vector<Resource::Identifier>& partial_identifier, size_t dump_level) const;
            uint32_t CalculateDirectoryOffsets(PEFormat& fmt, uint32_t offset, size_t level_deeper);
            void CollectSubdirectoryStrings(PEFormat& fmt, ResourcesSection& rsrc, size_t level_deeper);
            uint32_t CollectResourceData(PEFormat& fmt, uint32_t rva, size_t level_deeper);
            void WriteDirectories(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt, uint32_t section_pointer) const;
            offset_t WriteResources(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt, uint32_t rva_to_offset) const;
        };
 
        class ResourcesSection : public Section, public ResourceDirectory
        {
        public:
            ResourcesSection()
                : Section(DATA | READ)
            {
                name = ".rsrc";
            }
 
            size_t max_depth = 0;
        protected:
            std::vector<std::string> string_table;
            std::map<std::string, uint32_t> string_table_map;
            uint32_t string_table_offset = 0;
            uint32_t string_table_end_offset = 0;
        public:
            uint32_t FetchString(std::string s);
 
            using Section::ReadSectionData;
            using Section::WriteSectionData;
            using Section::ImageSize;
 
            bool IsPresent() const;
            void Generate(PEFormat& fmt);
            void ReadSectionData(const std::shared_ptr<Linker::Reader>& rd, const PEFormat& fmt) override;
            void WriteSectionData(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt) const override;
            uint32_t ImageSize(const PEFormat& fmt) const override;
            uint32_t MemorySize(const PEFormat& fmt) const override;
 
            void ParseDirectoryData(const PEFormat& fmt, uint32_t directory_rva, uint32_t directory_size);
            void DumpDirectory(const PEFormat& fmt, Dumper::Dumper& dump, uint32_t directory_rva, uint32_t directory_size) const;
        };
 
        std::shared_ptr<ResourcesSection> resources = std::make_shared<ResourcesSection>();
 
        class ImportedLibrary
        {
        public:
            typedef uint16_t Ordinal;
 
            class Name
            {
            public:
                uint16_t hint;
                std::string name = "";
                uint32_t rva = 0;
 
                Name(std::string name, uint16_t hint = 0)
                    : hint(hint), name(name)
                {
                }
            };
 
            typedef std::variant<Ordinal, Name> ImportTableEntry;
 
            uint32_t lookup_table_rva = 0;
            uint32_t address_table_rva = 0;
            ::Timestamp<POSIX_clock> timestamp = { };
            uint32_t forwarder_chain = 0;
            std::string name;
            uint32_t name_rva = 0;
 
            std::vector<ImportTableEntry> import_table;
            std::map<std::string, size_t> imports_by_name;
            std::map<Ordinal, size_t> imports_by_ordinal;
 
            void AddImportByName(std::string entry_name, uint16_t hint);
            void AddImportByOrdinal(uint16_t ordinal);
 
            offset_t GetImportByNameAddress(const PEFormat& fmt, std::string name);
            offset_t GetImportByOrdinalAddress(const PEFormat& fmt, uint16_t ordinal);
 
            ImportedLibrary(std::string name)
                : name(name)
            {
            }
        };
 
        class ImportsSection : public Section
        {
        public:
            std::vector<ImportedLibrary> libraries;
            std::map<std::string, size_t> library_indexes;
 
            uint32_t address_table_rva;
            uint32_t address_table_size;
 
            ImportsSection()
                : Section(DATA | READ | WRITE)
            {
                name = ".idata";
            }
 
            using Section::ReadSectionData;
            using Section::WriteSectionData;
            using Section::ImageSize;
 
            bool IsPresent() const;
            void Generate(PEFormat& fmt);
            void ReadSectionData(const std::shared_ptr<Linker::Reader>& rd, const PEFormat& fmt) override;
            void WriteSectionData(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt) const override;
            uint32_t ImageSize(const PEFormat& fmt) const override;
            uint32_t MemorySize(const PEFormat& fmt) const override;
 
            void ParseDirectoryData(const PEFormat& fmt, uint32_t directory_rva, uint32_t directory_size);
            void DumpDirectory(const PEFormat& fmt, Dumper::Dumper& dump, uint32_t directory_rva, uint32_t directory_size) const;
        };
 
        std::shared_ptr<ImportsSection> imports = std::make_shared<ImportsSection>();
 
        class ExportedEntry
        {
        public:
            class Forwarder
            {
            public:
                std::string dll_name;
                std::variant<std::string, uint32_t> reference;
                std::string reference_name;
                uint32_t rva;
            };
 
            class Name
            {
            public:
                std::string name;
                uint32_t rva = 0;
 
                Name(std::string name)
                    : name(name)
                {
                }
            };
 
            std::variant<uint32_t, Forwarder> value;
            std::optional<Name> name;
 
            ExportedEntry(uint32_t rva)
                : value(rva), name()
            {
            }
 
            ExportedEntry(uint32_t rva, std::string name)
                : value(rva), name(name)
            {
            }
 
            ExportedEntry(Forwarder fwd)
                : value(fwd), name()
            {
            }
        };
 
        class ExportsSection : public Section
        {
        public:
            uint32_t flags = 0;
            ::Timestamp<POSIX_clock> timestamp = { };
            version_type version = { };
            std::string dll_name;
            uint32_t dll_name_rva = 0;
            uint32_t ordinal_base = 1;
            uint32_t first_allowed_ordinal = 1;
            uint32_t address_table_rva = 0;
            uint32_t name_table_rva = 0;
            uint32_t ordinal_table_rva = 0;
            std::map<uint32_t, std::shared_ptr<ExportedEntry>> entries;
            std::map<std::string, uint32_t> named_exports;
 
            void SetEntry(PEFormat& fmt, uint32_t ordinal, std::shared_ptr<ExportedEntry> entry);
            void AddEntry(PEFormat& fmt, std::shared_ptr<ExportedEntry> entry);
 
            ExportsSection()
                : Section(DATA | READ)
            {
                name = ".edata";
                // TODO: flags and other fields
            }
 
            using Section::ReadSectionData;
            using Section::WriteSectionData;
            using Section::ImageSize;
 
            bool IsPresent() const;
            void Generate(PEFormat& fmt);
            void ReadSectionData(const std::shared_ptr<Linker::Reader>& rd, const PEFormat& fmt) override;
            void WriteSectionData(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt) const override;
            uint32_t ImageSize(const PEFormat& fmt) const override;
            uint32_t MemorySize(const PEFormat& fmt) const override;
 
            void ParseDirectoryData(const PEFormat& fmt, uint32_t directory_rva, uint32_t directory_size);
            void DumpDirectory(const PEFormat& fmt, Dumper::Dumper& dump, uint32_t directory_rva, uint32_t directory_size) const;
        };
 
        std::shared_ptr<ExportsSection> exports = std::make_shared<ExportsSection>();
 
        class BaseRelocation
        {
        public:
            enum relocation_type
            {
                RelAbsolute = 0,
                RelHigh = 1,
                RelLow = 2,
                RelHighLow = 3,
                RelHighAdj = 4,
                RelMIPSJmpAddr = 5,
                RelARMMov32 = 5,
                RelRISCVHigh20 = 5,
                RelThumbMov32 = 7,
                RelRISCVLow12I = 7,
                RelRISCVLow12S = 8,
                RelLoongArch32MarkLA = 8,
                RelLoongArch64MarkLA = 8,
                RelMIPSJmpAddr16 = 9,
                RelDir64 = 10,
            };
            relocation_type type;
            uint16_t offset;
            uint16_t parameter = 0;
 
            size_t GetEntryCount(const PEFormat * format) const;
            size_t GetRelocationSize(const PEFormat * format) const;
        };
 
        class BaseRelocationBlock
        {
        public:
            static constexpr uint32_t PAGE_SIZE = 0x1000;
            uint32_t page_rva;
            uint32_t block_size;
            std::vector<BaseRelocation> relocations_list;
            std::map<uint16_t, BaseRelocation> relocations_map;
 
            BaseRelocationBlock(uint32_t page_rva = 0)
                : page_rva(page_rva & ~(PAGE_SIZE - 1))
            {
            }
        };
 
        class BaseRelocationsSection : public Section
        {
        public:
            std::vector<std::shared_ptr<BaseRelocationBlock>> blocks_list;
            std::map<uint32_t, std::shared_ptr<BaseRelocationBlock>> blocks_map;
 
            BaseRelocationsSection()
                : Section(DATA | DISCARDABLE | READ)
            {
                name = ".reloc";
            }
 
            using Section::ReadSectionData;
            using Section::WriteSectionData;
            using Section::ImageSize;
 
            bool IsPresent() const;
            void Generate(PEFormat& fmt);
            void ReadSectionData(const std::shared_ptr<Linker::Reader>& rd, const PEFormat& fmt) override;
            void WriteSectionData(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt) const override;
            uint32_t ImageSize(const PEFormat& fmt) const override;
            uint32_t MemorySize(const PEFormat& fmt) const override;
 
            void ParseDirectoryData(const PEFormat& fmt, uint32_t directory_rva, uint32_t directory_size);
            void DumpDirectory(const PEFormat& fmt, Dumper::Dumper& dump, uint32_t directory_rva, uint32_t directory_size) const;
        };
 
        std::shared_ptr<BaseRelocationsSection> base_relocations = std::make_shared<BaseRelocationsSection>();
 
        void AddBaseRelocation(uint32_t rva, BaseRelocation::relocation_type type, uint16_t low_ref = 0);
 
        // TODO: document
        // TODO: should this be an actual section?
        class CLRHeaderSection : public Section
        {
        public:
            CLRHeaderSection()
                : Section(TEXT | EXECUTE) // TODO: are these the correct flags?
            {
                name = ".cormeta"; // TODO: is this the correct name?
            }
 
            using Section::ReadSectionData;
            using Section::WriteSectionData;
            using Section::ImageSize;
 
            void ReadSectionData(const std::shared_ptr<Linker::Reader>& rd, const PEFormat& fmt) override;
            void WriteSectionData(const std::shared_ptr<Linker::Writer>& wr, const PEFormat& fmt) const override;
            uint32_t ImageSize(const PEFormat& fmt) const override;
            uint32_t MemorySize(const PEFormat& fmt) const override;
 
            void ParseDirectoryData(const PEFormat& fmt, uint32_t directory_rva, uint32_t directory_size);
            void DumpDirectory(const PEFormat& fmt, Dumper::Dumper& dump, uint32_t directory_rva, uint32_t directory_size) const;
        };
 
        // TODO: document
        std::shared_ptr<CLRHeaderSection> clr_header = std::make_shared<CLRHeaderSection>();
 
        mutable MZStubWriter stub;
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
 
        ::EndianType GetMachineEndianType() const;
        void CalculateValues() override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        enum compatibility_type
        {
            CompatibleNone,
            CompatibleWatcom,
            CompatibleMicrosoft,
            CompatibleBorland,
            CompatibleGNU,
        };
 
        compatibility_type compatibility = CompatibleNone;
 
        enum target_type
        {
            TargetWin9x = 1,
            TargetWinNT,
            TargetWinCE,
            TargetMacintosh, // TODO: not supported
            TargetWin32s,
            TargetTNT, // TODO: not supported
            TargetEFI, // TODO: not supported
            TargetDotNET, // TODO: not supported
            TargetXbox, // TODO: not supported
            //TargetBeOS, // TODO: possible target
            //TargetSkyOS, // TODO: possible target
            //TargetHXDOS, // TODO: possible target
        };
        target_type target = target_type(0);
 
        enum output_type
        {
            OUTPUT_EXE,
            OUTPUT_DLL,
            OUTPUT_SYS,
        };
        /*** @brief Whether to generate an executable, library or system file */
        output_type output = OUTPUT_EXE;
 
        PEFormat(target_type target = TargetWinNT, PEOptionalHeader::SubsystemType subsystem = PEOptionalHeader::WindowsGUI, output_type output = OUTPUT_EXE)
            : COFFFormat(WINDOWS, PECOFF, ::LittleEndian), target(target), output(output)
        {
            optional_header = std::make_unique<PEOptionalHeader>();
            GetOptionalHeader().subsystem = subsystem;
        }
 
    public:
        /* * * Writer members * * */
 
        bool option_relocatable = true;
 
        bool option_include_deprecated_flags = false;
 
        bool option_coff_line_numbers = false;
 
        bool option_coff_local_symbols = false;
 
        bool option_debug_info = false;
 
        bool option_import_thunks = false;
 
        std::shared_ptr<Linker::Segment> import_thunk_segment = nullptr;
 
        std::map<std::pair<std::string, std::string>, uint32_t> import_thunks_by_name;
        std::map<std::pair<std::string, uint16_t>, uint32_t> import_thunks_by_ordinal;
 
        class PEOptionCollector : public Linker::OptionCollector
        {
        public:
            class TargetEnumeration : public Linker::Enumeration<target_type>
            {
            public:
                TargetEnumeration()
                    : Enumeration(
                        "WIN9X", TargetWin9x,
                        "WINNT", TargetWinNT,
                        "WINCE", TargetWinCE,
                        "MACINTOSH", TargetMacintosh,
                        "WIN32S", TargetWin32s,
                        "TNT", TargetTNT,
                        "EFI", TargetEFI,
                        "DOTNET", TargetDotNET,
                        "XBOX", TargetXbox)
                {
                    descriptions = {
                        { TargetWin9x, "targets Windows 95/98/ME" },
                        { TargetWinNT, "targets Windows NT" },
                        { TargetWinCE, "targets Windows CE/Windows Phone/Windows Mobile (pre-8)" },
                        { TargetMacintosh, "targets the Windows Portability Library on Macintosh (not implemented)" },
                        { TargetWin32s, "targets the Win32s layer for Windows 3.11" },
                        { TargetTNT, "targets the Phar Lap TNT DOS Extender (not implemented)" },
                        { TargetEFI, "targets EFI/UEFI (not implemented)" },
                        { TargetDotNET, "targets the .NET environment (not implemented)" },
                        { TargetXbox, "targets Xbox (not implemented)" },
                        //{ TargetBeOS, "targets BeOS x86 up to Release 3.2" },
                        //{ TargetSkyOS, "targets SkyOS" },
                        //{ TargetHXDOS, "targets the HX-DOS DOS extender" },
                    };
                }
            };
 
            enum subsystem_determination
            {
                Subsystem_Windows = 1,
                Subsystem_Console,
                Subsystem_Native,
                Subsystem_OS2,
                Subsystem_POSIX,
                Subsystem_EFIApplication,
                Subsystem_EFIBootServiceDriver,
                Subsystem_EFIRuntimeDriver,
                Subsystem_EFI_ROM,
                Subsystem_BootApplication,
            };
 
            class SubsystemEnumeration : public Linker::Enumeration<subsystem_determination>
            {
            public:
                SubsystemEnumeration()
                    : Enumeration(
                        "WINDOWS", Subsystem_Windows,
                        "CONSOLE", Subsystem_Console,
                        "NATIVE", Subsystem_Native,
                        "OS2", Subsystem_OS2,
                        "POSIX", Subsystem_POSIX,
                        "EFI_APPLICATION", Subsystem_EFIApplication,
                        "EFI_BOOT_SERVICE_DRIVER", Subsystem_EFIBootServiceDriver,
                        "EFI_RUNTIME_DRIVER", Subsystem_EFIRuntimeDriver,
                        "EFI_ROM", Subsystem_EFI_ROM,
                        "BOOT_APPLICATION", Subsystem_BootApplication)
                {
                    descriptions = {
                        { Subsystem_Windows, "creates a graphical program" },
                        { Subsystem_Console, "creates a console (text mode) program" },
                        { Subsystem_Native, "creates a native Windows NT kernel program" },
                        { Subsystem_OS2, "creates a program that uses the OS/2 personality" },
                        { Subsystem_POSIX, "creates a program that uses the POSIX personality" },
                        { Subsystem_EFIApplication, "creates an EFI application" },
                        { Subsystem_EFIBootServiceDriver, "creates an EFI boot service driver" },
                        { Subsystem_EFIRuntimeDriver, "creates an EFI run-time driver" },
                        { Subsystem_EFI_ROM, "creates an EFI ROM image" },
                        { Subsystem_BootApplication, "creates a Windows boot application" },
                    };
                }
            };
 
            class OutputTypeEnumeration : public Linker::Enumeration<output_type>
            {
            public:
                OutputTypeEnumeration()
                    : Enumeration(
                        "EXE", OUTPUT_EXE,
                        "DLL", OUTPUT_DLL,
                        "SYS", OUTPUT_SYS)
                {
                    descriptions = {
                        { OUTPUT_EXE, "creates an executable" },
                        { OUTPUT_DLL, "creates a dynamic linking library (DLL)" },
                        { OUTPUT_SYS, "creates a system program" }
                    };
                }
            };
 
            class CompatibilityEnumeration : public Linker::Enumeration<compatibility_type>
            {
            public:
                CompatibilityEnumeration()
                    : Enumeration(
                        "NONE", CompatibleNone,
                        "WATCOM", CompatibleWatcom,
                        "MS", CompatibleMicrosoft,
                        "BORLAND", CompatibleBorland,
                        "GNU", CompatibleGNU)
                {
                    descriptions = {
                        { CompatibleNone, "default operation" },
                        { CompatibleWatcom, "mimics the Watcom linker (not implemented)" },
                        { CompatibleMicrosoft, "mimics the Microsoft linker (not implemented)" },
                        { CompatibleBorland, "mimics the Borland linker (not implemented)" },
                        { CompatibleGNU, "mimics the GNU (MinGW) linker (not implemented)" },
                    };
                }
            };
 
            Linker::Option<std::string> stub{"stub", "Filename for stub that gets prepended to executable"};
            Linker::Option<Linker::ItemOf<TargetEnumeration>> target{"target", "Windows target type"};
            Linker::Option<Linker::ItemOf<SubsystemEnumeration>> subsystem{"subsystem", "Windows subsystem to target"};
            Linker::Option<Linker::ItemOf<OutputTypeEnumeration>> output{"output", "Output types"};
            Linker::Option<Linker::ItemOf<CompatibilityEnumeration>> compat{"compat", "Mimics the behavior of another linker"};
            Linker::Option<offset_t> image_base{"base", "Base address of image, used for calculating relative virtual addresses"};
            Linker::Option<offset_t> section_align{"section_align", "Section alignment"};
            Linker::Option<bool> import_thunks{"import_thunks", "Create thunk procedures for imported names"};
            // TODO: make stack size a parameter
 
            PEOptionCollector()
            {
                InitializeFields(stub, target, subsystem, output, compat, image_base, section_align, import_thunks);
            }
        };
 
        static std::shared_ptr<PEFormat> CreateConsoleApplication(target_type target = TargetWinNT, PEOptionalHeader::SubsystemType subsystem = PEOptionalHeader::WindowsCUI);
 
        static std::shared_ptr<PEFormat> CreateGUIApplication(target_type target = TargetWinNT, PEOptionalHeader::SubsystemType subsystem = PEOptionalHeader::WindowsGUI);
 
        static std::shared_ptr<PEFormat> CreateLibraryModule(target_type target = TargetWinNT);
 
        static std::shared_ptr<PEFormat> CreateDeviceDriver(target_type target = TargetWinNT);
 
        std::shared_ptr<PEFormat> SimulateLinker(compatibility_type compatibility);
 
        bool FormatSupportsLibraries() const override;
 
        bool FormatSupportsResources() const override;
 
        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;
 
        std::shared_ptr<Resource>& AddResource(std::shared_ptr<Resource>& resource);
 
        ImportedLibrary& FetchImportLibrary(std::string library_name, bool create_if_not_present = false);
        void AddImportByName(std::string library_name, std::string entry_name, uint16_t hint);
        void AddImportByOrdinal(std::string library_name, uint16_t ordinal);
 
        static std::vector<Linker::OptionDescription<void> *> ParameterNames;
        std::vector<Linker::OptionDescription<void> *> GetLinkerScriptParameterNames() override;
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
 
        enum
        {
            FLAG_NO_RELOCATIONS = 0x0001, // already defined in COFF
            FLAG_EXECUTABLE = 0x0002, // already defined in COFF
            FLAG_NO_LINE_NUMBERS = 0x0004, // already defined in COFF
            FLAG_NO_SYMBOLS = 0x0008, // already defined in COFF
            FLAG_TRIM_WORKING_SET = 0x0010,
            FLAG_LARGE_ADDRESS = 0x0020,
            FLAG_LITTLE_ENDIAN = 0x0080,
            FLAG_32BIT = 0x0100,
            FLAG_NO_DEBUG = 0x0200,
            FLAG_ON_REMOVABLE = 0x0400,
            FLAG_ON_NETWORK = 0x0800,
            FLAG_SYSTEM = 0x1000,
            FLAG_LIBRARY = 0x2000,
            FLAG_UNIPROCESSOR_ONLY = 0x4000,
            FLAG_BIG_ENDIAN = 0x8000,
        };
 
        void SetOptions(std::map<std::string, std::string>& options) override;
        void AllocateSymbols(Linker::Module& module) const override;
        void OnCallDirective(Linker::Module& module, std::string identifier) override;
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
        std::unique_ptr<Script::List> GetScript(Linker::Module& module);
        void Link(Linker::Module& module);
 
        offset_t GenerateResourceSection(Linker::Module& module, offset_t image_end);
 
        offset_t GenerateImportSection(Linker::Module& module, offset_t image_end);
 
        offset_t GenerateExportSection(Linker::Module& module, offset_t image_end);
 
        offset_t GenerateBaseRelocationSection(Linker::Module& module, offset_t image_end);
 
        void ProcessRelocations(Linker::Module& module);
 
        void FixupImportThunk(Linker::Module& module, offset_t offset, offset_t address);
 
        offset_t GetMemoryImageEnd() const;
        void ProcessModule(Linker::Module& module) override;
        void GenerateFile(std::string filename, Linker::Module& module) override;
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;
 
        class RVADisplay : public Dumper::Display<offset_t>
        {
        public:
            const PEFormat * pe;
            unsigned width;
            RVADisplay(const PEFormat * pe, unsigned width)
                : pe(pe), width(width)
            {
            }
 
            void DisplayValue(Dumper::Dumper& dump, std::tuple<offset_t> values) override;
        };
 
        std::shared_ptr<RVADisplay> MakeRVADisplay(unsigned width = 8) const;
    };
 
    class NTResourceFile : public virtual Linker::Format
    {
    public:
        typedef ResourceFile::Identifier Identifier;
 
        static void ReadIdentifier(const std::shared_ptr<Linker::Reader>& rd, Identifier& id);
        static void WriteIdentifier(const std::shared_ptr<Linker::Writer>& wr, const Identifier& id);
        static offset_t GetIdentifierSize(const Identifier& id);
 
        class Resource : public ResourceFile::Resource
        {
        public:
            uint32_t header_size;
            uint32_t data_version;
            uint16_t language_id;
            uint32_t version;
            uint32_t characteristics;
        };
 
        offset_t file_offset;
        std::vector<Resource> resources;
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd, offset_t size);
        void CalculateValues();
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        typedef ResourceFile::IdDisplay IdDisplay;
    };
}
 
#endif /* PEEXE_H */