peexe.h

#ifndef PEEXE_H
#define PEEXE_H
 
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/segment_manager.h"
#include "coff.h"
#include "mzexe.h"
 
/* TODO: unimplemented */
 
namespace Microsoft
{
    class PEFormat : public COFF::COFFFormat
    {
    public:
        char pe_signature[4];
 
        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;
            offset_t image_base = 0;
            uint32_t section_align = 0;
            uint32_t file_align = 0;
            struct version_type
            {
                uint16_t major, minor;
            };
            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(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            offset_t CalculateValues(COFFFormat& coff) override;
 
        protected:
            void DumpFields(const COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) const override;
        };
 
        mutable MZStubWriter stub;
 
        void ReadFile(Linker::Reader& rd) override;
        void CalculateValues() override;
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
        /* TODO */
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;
 
    protected:
        void ReadOptionalHeader(Linker::Reader& rd);
    };
}
 
#endif /* PEEXE_H */