leexe.h

#ifndef LEEXE_H
#define LEEXE_H
 
#include <array>
#include <vector>
#include "mzexe.h"
#include "neexe.h"
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/module.h"
#include "../linker/options.h"
#include "../linker/segment.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
 
namespace Microsoft
{
    class LEFormat : public virtual Linker::SegmentManager, public std::enable_shared_from_this<LEFormat>
    {
    public:
        /* * * General members * * */
 
        enum compatibility_type
        {
            CompatibleNone,
            CompatibleWatcom,
            CompatibleMicrosoft,
            CompatibleBorland,
            // /** @brief Attempts to mimic the output of the GNU linker, this is undefined for the LE output */
            // CompatibleGNU,
        };
 
        struct PhysicalPageNumber
        {
            uint32_t number;
            explicit PhysicalPageNumber() : number(0) { }
            explicit PhysicalPageNumber(uint32_t number) : number(number) { }
            operator uint32_t() const { return number; }
            PhysicalPageNumber operator +(int value) const { return PhysicalPageNumber{number + value}; }
            PhysicalPageNumber operator -(int value) const { return PhysicalPageNumber{number - value}; }
            PhysicalPageNumber& operator++(int) { number++; return *this; }
        };
 
        class Object
        {
        public:
            std::shared_ptr<Linker::Contents> image;
            enum flag_type
            {
                Readable = 0x0001,
                Writable = 0x0002,
                Executable = 0x0004,
                Resource = 0x0008,
                Discardable = 0x0010,
                Shared = 0x0020,
                PreloadPages = 0x0040,
                InvalidPages = 0x0080,
                ZeroFilledPages = 0x0100,
                Resident = 0x0200,
                ResidentContiguous = 0x0300,
                ResidentLongLockable = 0x0400,
                Alias16_16 = 0x1000, /* x86 */
                BigSegment = 0x2000, /* x86 */
                Conforming = 0x4000, /* x86 */
                IOPrivilege = 0x8000, /* x86 */
            };
            uint32_t size = 0;
            uint32_t address = 0;
            flag_type flags = flag_type(0);
            uint32_t page_table_index = 0;
            uint32_t page_entry_count = 0;
            uint32_t data_pages_offset = 0;
 
            Object()
            {
            }
 
            Object(std::shared_ptr<Linker::Segment> segment, unsigned flags)
                : image(segment), flags(flag_type(flags))
            {
            }
        };
 
        class PageSet : public Linker::Contents
        {
        public:
            std::shared_ptr<LEFormat> file;
            std::vector<PhysicalPageNumber> pages;
 
            PageSet() = delete;
 
            PageSet(std::shared_ptr<LEFormat> file)
                : file(file)
            {
            }
 
            offset_t ImageSize() const override;
            using Linker::Contents::WriteFile;
            offset_t WriteFile(Linker::Writer& wr, offset_t count, offset_t offset = 0) const override;
        };
 
        class SegmentPage : public Linker::Contents
        {
        public:
            std::shared_ptr<Linker::Contents> image;
            offset_t offset = 0;
            offset_t size = 0;
 
            SegmentPage(std::shared_ptr<Linker::Contents> image, offset_t offset, offset_t size)
                : image(image), offset(offset), size(size)
            {
            }
 
            offset_t ImageSize() const override;
            using Linker::Contents::WriteFile;
            offset_t WriteFile(Linker::Writer& wr, offset_t count, offset_t offset = 0) const override;
            std::shared_ptr<const Linker::Image> AsImage() const override;
        };
 
        class IteratedPage : public Linker::Contents
        {
        public:
            struct IterationRecord
            {
                uint16_t count = 0;
                std::vector<uint8_t> data;
            };
            std::vector<IterationRecord> records;
 
            offset_t ImageSize() const override;
            using Linker::Contents::WriteFile;
            static std::shared_ptr<IteratedPage> ReadFromFile(Linker::Reader& rd, uint16_t size);
            offset_t WriteFile(Linker::Writer& wr, offset_t count, offset_t offset = 0) const override;
 
            class View : public Linker::Image
            {
            public:
                IteratedPage& iterated_page;
                size_t size;
 
                View(IteratedPage& iterated_page, size_t size)
                    : iterated_page(iterated_page), size(size)
                {
                }
 
                size_t ReadData(size_t bytes, offset_t offset, void * buffer) const override;
 
                offset_t ImageSize() const override;
                using Linker::Contents::WriteFile;
                offset_t WriteFile(Linker::Writer& wr, offset_t count, offset_t offset = 0) const override;
            };
        };
 
        class Page
        {
        public:
            enum page_type
            {
                Preload = 0,
                Iterated = 1,
                Invalid = 2,
                ZeroFilled = 3,
                Range = 4,
                Compressed = 5,
            };
 
            uint32_t offset = 0;
 
            uint16_t size = 0;
 
            uint16_t type = 0;
 
            page_type GetPageType(const LEFormat& fmt) const;
 
            uint32_t fixup_offset = 0;
 
            class Relocation : public Linker::Writer
            {
            public:
                enum source_type
                {
                    Offset8 = 0,
                    Selector16 = 2,
                    Pointer32 = 3,
                    Offset16 = 5,
                    Pointer48 = 6,
                    Offset32 = 7,
                    Relative32 = 8,
 
                    SourceTypeMask = 0x0F,
 
                    Alias = 0x10,
                    SourceList = 0x20,
                };
                source_type type = source_type(0);
                enum flag_type
                {
                    Internal = 0,
                    ImportOrdinal = 1,
                    ImportName = 2,
                    Entry = 3,
 
                    FlagTypeMask = 3,
 
                    Additive = 4,
                    Chained = 8,
                    Target32 = 0x10,
                    Additive32 = 0x20,
                    Module16 = 0x40,
                    Ordinal8 = 0x80,
                };
                flag_type flags = flag_type(0);
                uint16_t module = 0;
                uint32_t target = 0;
                uint32_t addition = 0;
 
                // informational purposes
                std::string module_name;
                std::string import_name;
                uint16_t actual_object = 0;
                uint32_t actual_offset = 0;
 
                Relocation()
                    : Writer(::LittleEndian)
                {
                }
 
                Relocation(unsigned type, unsigned flags, uint16_t offset, uint16_t module, uint32_t target = 0, uint32_t addition = 0)
                    : Writer(::LittleEndian), type(source_type(type)), flags(flag_type(flags)), module(module), target(target), addition(addition)
                {
                    sources.push_back(Chain{offset});
                }
 
                static source_type GetType(Linker::Relocation& rel);
 
                bool IsExternal() const;
 
                bool IsSelectorOrOffset() const;
 
                bool ComesBefore() const;
 
                size_t GetSourceSize() const;
 
                struct ChainLink
                {
                    uint32_t target = 0;
                    uint16_t source = 0;
                };
 
                struct Chain
                {
                    uint16_t source = 0;
                    uint32_t base_address = 0;
                    std::vector<ChainLink> chains;
                };
 
                std::vector<Chain> sources;
 
                /* do not call this */
                void DecrementSingleSourceOffset(size_t amount);
 
                bool IsSelector() const;
                bool IsSourceList() const;
                bool IsAdditive() const;
                size_t GetTargetSize() const;
                size_t GetAdditiveSize() const;
                size_t GetModuleSize() const;
                size_t GetOrdinalSize() const;
 
                uint16_t GetFirstSource() const;
 
                void CalculateSizes(compatibility_type compatibility);
 
                size_t GetSize() const;
 
                static Relocation ReadFile(Linker::Reader& rd, Page& page);
                void WriteFile(Linker::Writer& wr) const;
            };
            std::map<uint16_t, Relocation> relocations;
            uint32_t checksum = 0;
            std::shared_ptr<Linker::Contents> image;
 
            Page()
            {
            }
 
            static Page LEPage(uint8_t type);
 
            static Page LXPage(uint32_t offset, uint16_t size, uint8_t type);
 
        protected:
            void FillDumpRegion(Dumper::Dumper& dump, Dumper::Region& page_region, const LEFormat& fmt, uint32_t object_number, PhysicalPageNumber page_index) const;
            void FillDumpRelocations(Dumper::Dumper& dump, Dumper::Block& page_block, const LEFormat& fmt) const;
            void DumpPhysicalPage(Dumper::Dumper& dump, const LEFormat& fmt, uint32_t object_number, PhysicalPageNumber page_index) const;
            void DumpIteratedPage(Dumper::Dumper& dump, const LEFormat& fmt, uint32_t object_number, PhysicalPageNumber page_index) const;
            void DumpInvalidPage(Dumper::Dumper& dump, const LEFormat& fmt, uint32_t object_number, PhysicalPageNumber page_index) const;
            void DumpZeroFilledPage(Dumper::Dumper& dump, const LEFormat& fmt, uint32_t object_number, PhysicalPageNumber page_index) const;
            void DumpPageRange(Dumper::Dumper& dump, const LEFormat& fmt, uint32_t object_number, PhysicalPageNumber page_index) const;
            void DumpCompressedPage(Dumper::Dumper& dump, const LEFormat& fmt, uint32_t object_number, PhysicalPageNumber page_index) const;
            void DumpUnknownPage(Dumper::Dumper& dump, const LEFormat& fmt, uint32_t object_number, PhysicalPageNumber page_index) const;
 
        public:
            void Dump(Dumper::Dumper& dump, const LEFormat& fmt, PhysicalPageNumber page_index) const;
        };
 
        class Resource
        {
        public:
            uint16_t type_id = 0, name_id = 0;
            uint32_t size = 0;
            uint16_t object = 0;
            uint32_t offset = 0;
 
            Resource() = default;
 
            Resource(uint16_t type_id, uint16_t name_id, uint32_t size, uint16_t object = 0, uint32_t offset = 0)
                : type_id(type_id), name_id(name_id), size(size), object(object), offset(offset)
            {
            }
        };
 
        struct Name
        {
        public:
            std::string name;
            uint16_t ordinal = 0;
        };
 
        class Entry : public Linker::Writer
        {
        public:
            enum entry_type
            {
                Unused,
                Entry16,
                CallGate286,
                Entry32,
                Forwarder,
            };
            entry_type type = Unused;
            uint16_t object = 0;
            enum flag_type
            {
                Exported = 1,
                SharedData = 2,
 
                ForwarderByOrdinal = 1,
            };
            flag_type flags = flag_type(0);
            uint32_t offset = 0;
 
            // informational purposes
            enum export_type
            {
                NotExported,
                ExportByName,
                ExportByOrdinal,
            };
            export_type export_state = NotExported;
            std::string entry_name;
            std::string module_name;
            std::string import_name;
 
            Entry()
                : Writer(::LittleEndian)
            {
            }
 
            Entry(unsigned type)
                : Writer(::LittleEndian), type(entry_type(type))
            {
            }
 
            Entry(unsigned type, uint16_t object, unsigned flags, uint32_t offset)
                : Writer(::LittleEndian), type(entry_type(type)), object(object), flags(flag_type(flags)), offset(offset)
            {
            }
 
            mutable bool same_bundle = false; // mutable because this isn't actually part of the entry state but the entire entry table
 
            bool SameBundle(const Entry& other) const;
 
            offset_t GetEntryHeadSize() const;
 
            offset_t GetEntryBodySize() const;
 
            static Entry ReadEntryHead(Linker::Reader& rd, uint8_t type);
            static Entry ReadEntry(Linker::Reader& rd, uint8_t type, LEFormat::Entry& head);
 
            void WriteEntryHead(Linker::Writer& wr) const;
 
            void WriteEntryBody(Linker::Writer& wr) const;
        };
 
        class ModuleDirective
        {
        public:
            enum directive_number : uint16_t
            {
                VerifyRecordDirective = 0x8001,
                LanguageInformationDirective = 0x0002,
                CoProcessorRequiredSupportTable = 0x0003,
                ThreadStateInitializationDirective = 0x0004,
                CSetBrowseInformation = 0x0005,
            };
            static constexpr uint16_t ResidentFlagMask = 0x8000;
            directive_number directive = directive_number(0);
            uint16_t length = 0;
            offset_t offset = 0;
 
            bool IsResident() const;
        };
 
        ::EndianType endiantype = ::LittleEndian;
 
        std::array<char, 2> signature{'L', 'E'};
 
        bool IsExtendedFormat() const;
 
        uint32_t format_level = 0;
 
        /* https://faydoc.tripod.com/formats/exe-LE.htm */
        enum cpu_type
        {
            I286 = 0x01,
            I386 = 0x02, /* only value used */
            I486 = 0x03,
            I586 = 0x04,
            I860_N10 = 0x20,
            I860_N11 = 0x21,
            MIPS1 = 0x40,
            MIPS2 = 0x41,
            MIPS3 = 0x42,
        };
        cpu_type cpu = I386;
 
        enum system_type
        {
            OS2 = 1,
            Windows,
            MSDOS4,
            Windows386,
            Neutral,
 
            DOS4G = 0x10001,
        };
        system_type system = system_type(0);
 
        enum output_type
        {
            OUTPUT_GUI,
            OUTPUT_CON,
            OUTPUT_DLL,
            OUTPUT_PDD,
            OUTPUT_VDD,
        };
        /*** @brief Whether to generate an executable or a library */
        output_type output;
 
        uint32_t module_version = 0;
 
        enum
        {
            PreProcessInitialization = 0x00000004,
            NoInternalFixup = 0x00000010,
            NoExternalFixup = 0x00000020,
            FullScreen = 0x00000100,
            GUIAware = 0x00000200,
            GUI = 0x00000300,
            ErrorInImage = 0x00002000,
            Library = 0x00008000,
            ProtectedMemoryLibrary = 0x00018000,
            PhysicalDriver = 0x00020000,
            VirtualDriver = 0x00028000,
            PerProcessTermination = 0x40000000,
        };
        uint32_t module_flags = 0;
 
        uint32_t page_count = 0, page_size = 0x1000;
        uint32_t eip_object = 0, eip_value = 0, esp_object = 0, esp_value = 0;
        union
        {
            uint32_t last_page_size; /* LE */
            uint32_t page_offset_shift; /* LX */
        };
        uint32_t fixup_section_size = 0, fixup_section_checksum = 0;
        uint32_t loader_section_size = 0, loader_section_checksum = 0;
        uint32_t object_table_offset = 0, object_page_table_offset = 0, object_iterated_pages_offset = 0;
        uint32_t resource_table_offset = 0, resource_table_entry_count = 0, resident_name_table_offset = 0;
        uint32_t entry_table_offset = 0, module_directives_offset = 0, fixup_page_table_offset = 0, fixup_record_table_offset = 0;
        uint32_t imported_module_table_offset = 0, imported_procedure_table_offset = 0;
        uint32_t per_page_checksum_offset = 0;
        uint32_t data_pages_offset = 0, preload_page_count = 0;
        uint32_t nonresident_name_table_offset = 0, nonresident_name_table_size = 0, nonresident_name_table_checksum = 0;
        uint32_t automatic_data = 0;
        uint32_t debug_info_offset = 0, debug_info_size = 0, instance_preload_page_count = 0, instance_demand_page_count = 0;
        uint32_t stack_size = 0, heap_size = 0;
 
        uint32_t vxd_version_info_resource_offset = 0;
        uint32_t vxd_version_info_resource_length = 0;
        ResourceFile vxd_version_info_resource = ResourceFile(ResourceFile::System_Windows_3x);
        uint16_t vxd_device_id = 0;
        uint16_t vxd_ddk_version = 0;
 
        std::vector<Object> objects;
        std::vector<ModuleDirective> module_directives;
 
        class PhysicalPages
        {
        private:
            std::vector<Page> pages;
        public:
            typedef std::vector<Page>::iterator iterator;
            typedef std::vector<Page>::const_iterator const_iterator;
            typedef std::vector<Page>::reference reference;
            typedef std::vector<Page>::const_reference const_reference;
            typedef PhysicalPageNumber size_type;
 
            Page& operator[](PhysicalPageNumber physical_page_number);
            const Page& operator[](PhysicalPageNumber physical_page_number) const;
 
            iterator begin();
            const_iterator begin() const;
            iterator end();
            const_iterator end() const;
 
            reference front();
            const_reference front() const;
            reference back();
            const_reference back() const;
 
            void push_back(const Page& page);
 
            size_type size() const;
        };
 
        PhysicalPages pages;
 
        std::vector<std::tuple<PhysicalPageNumber, Page::page_type>> page_map_table;
 
        PhysicalPageNumber ObjectPageToPhysicalPage(uint32_t index) const;
 
        std::map<std::tuple<uint16_t, uint16_t>, Resource> resources;
        std::vector<Name> resident_names, nonresident_names;
        std::vector<Entry> entries;
        std::vector<std::string> imported_modules, imported_procedures;
 
        offset_t file_size = offset_t(-1);
 
        void SetTargetDefaults();
 
        explicit LEFormat()
            : last_page_size(0)
        {
        }
 
        LEFormat(bool extended_format)
            : last_page_size(0)
        {
            if(extended_format)
                signature[1] = 'X';
        }
 
        LEFormat(system_type system, output_type output)
            : system(system_type(system)), output(output), last_page_size(0)
        {
        }
 
        LEFormat(system_type system, output_type output, bool extended_format)
            : system(system_type(system)), output(output), last_page_size(0)
        {
            if(extended_format)
                signature[1] = 'X';
        }
 
        bool IsLibrary() const;
 
        bool IsDriver() const;
 
        bool IsOS2() const;
 
        bool MayHaveStack() const;
 
        void ReadFile(Linker::Reader& rd) override;
 
        offset_t ImageSize() const override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        offset_t GetPageOffset(PhysicalPageNumber physical_page_number) const;
        offset_t GetPageSize(PhysicalPageNumber physical_page_number) const;
 
        /* * * Writer members * * */
 
        class LEOptionCollector : public Linker::OptionCollector
        {
        public:
            class SystemEnumeration : public Linker::Enumeration<system_type>
            {
            public:
                SystemEnumeration()
                    : Enumeration(
                        "OS2", OS2,
                        "WINDOWS", Windows,
                        "DOS", MSDOS4,
                        "WIN386", Windows386,
                        "WINDOWS386", Windows386,
                        "VXD", Windows386,
                        "IBM", Neutral,
                        "DOS4G", DOS4G,
                        "DOS4GW", DOS4G)
                {
                    descriptions = {
                        { OS2, "OS/2 2.0+" },
                        { Windows, "Reserved for Windows (not supported)" },
                        { MSDOS4, "Reserved for Multitasking MS-DOS 4.0 (not supported)" },
                        { Windows386, "Windows 386 (virtual device driver only)" },
                        { Neutral, "IBM Microkernel Personality Neutral (not supported)" },
                        { DOS4G, "Rational Systems (Tenberry Software) DOS/4G or DOS/4GW executable" },
                    };
                }
            };
 
            class OutputTypeEnumeration : public Linker::Enumeration<output_type>
            {
            public:
                OutputTypeEnumeration()
                    : Enumeration(
                        "GUI", OUTPUT_GUI,
                        "PM", OUTPUT_GUI,
                        "WINDOWS", OUTPUT_GUI,
                        "CONSOLE", OUTPUT_CON,
                        "DLL", OUTPUT_DLL,
                        "PDD", OUTPUT_PDD,
                        "SYS", OUTPUT_PDD,
                        "VDD", OUTPUT_VDD,
                        "VXD", OUTPUT_VDD)
                {
                    descriptions = {
                        { OUTPUT_GUI, "creates a graphical executable (Presentation Manager for OS/2)" },
                        { OUTPUT_CON, "creates a console (text mode) executable" },
                        { OUTPUT_DLL, "creates a dynamic linking library (DLL)" },
                        { OUTPUT_PDD, "creates a physical device driver" },
                        { OUTPUT_VDD, "creates a virtual device driver" },
                    };
                }
            };
 
            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 linker (not implemented)" },*/
                    };
                }
            };
 
            Linker::Option<std::string> stub{"stub", "Filename for stub that gets prepended to executable"};
            Linker::Option<Linker::ItemOf<SystemEnumeration>> system{"system", "Target system type"};
            Linker::Option<Linker::ItemOf<OutputTypeEnumeration>> type{"type", "Type of binary"};
            Linker::Option<Linker::ItemOf<CompatibilityEnumeration>> compat{"compat", "Mimics the behavior of another linker"};
            Linker::Option<std::optional<offset_t>> stack{"stack", "Specify the stack size"};
            Linker::Option<offset_t> heap{"heap", "Specify the heap size"};
            Linker::Option<bool> le{"le", "Original linear executable (LE)"};
            Linker::Option<bool> lx{"lx", "Extended linear executable (LX)"};
 
            LEOptionCollector()
            {
                InitializeFields(stub, system, type, compat, stack, heap, le, lx);
            }
        };
 
        static std::shared_ptr<LEFormat> CreateConsoleApplication(system_type system = OS2);
 
        static std::shared_ptr<LEFormat> CreateGUIApplication(system_type system = OS2);
 
        static std::shared_ptr<LEFormat> CreateLibraryModule(system_type system = OS2);
 
        static std::shared_ptr<LEFormat> CreateDeviceDriver(system_type system = OS2, bool virtual_device_driver = true);
 
        std::shared_ptr<LEFormat> SimulateLinker(compatibility_type compatibility);
 
        mutable MZStubWriter stub;
 
        compatibility_type compatibility = CompatibleNone;
 
        /*std::string stub_file;*/
        std::string program_name, module_name;
 
        bool FormatSupportsSegmentation() const override;
 
        bool FormatSupportsLibraries() const override;
 
        bool FormatSupportsResources() const override;
 
        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;
 
        Resource& AddResource(Resource resource);
 
        void GetRelocationOffset(Object& object, size_t offset, PhysicalPageNumber& page_index, uint16_t& page_offset);
        void AddRelocation(Object& object, unsigned type, unsigned flags, size_t offset, uint16_t module, uint32_t target = 0, uint32_t addition = 0);
 
        std::shared_ptr<Linker::Segment> stack, heap;
        std::map<std::shared_ptr<Linker::Segment>, size_t> object_index;
        std::map<std::string, uint32_t> imported_procedure_name_offsets;
        offset_t imported_procedure_names_length = 0;
 
        unsigned GetDefaultObjectFlags() const;
        void AddObject(const Object& object);
        uint16_t FetchImportedModuleName(std::string name);
        uint16_t FetchImportedProcedureName(std::string name);
        uint16_t MakeEntry(Linker::Position value);
        uint16_t MakeEntry(uint16_t index, Linker::Position value);
        uint8_t CountBundles(size_t entry_index) const;
 
        static std::vector<Linker::OptionDescription<void> *> ParameterNames;
        std::vector<Linker::OptionDescription<void> *> GetLinkerScriptParameterNames() override;
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
        void SetOptions(std::map<std::string, std::string>& options) override;
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
        std::unique_ptr<Script::List> GetScript(Linker::Module& module);
        void Link(Linker::Module& module);
        void ProcessModule(Linker::Module& module) override;
        void CalculateValues() 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;
 
    };
 
}
 
#endif /* LEEXE_H */