neexe.h

#ifndef NEEXE_H
#define NEEXE_H
 
#include <array>
#include "mzexe.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
{
    namespace Windows
    {
        enum
        {
            RT_CURSOR = 0x0001,
            RT_BITMAP = 0x0002,
            RT_ICON = 0x0003,
            RT_MENU = 0x0004,
            RT_DIALOG = 0x0005,
            RT_STRING = 0x0006,
            RT_FONTDIR = 0x0007,
            RT_FONT = 0x0008,
            RT_ACCELERATOR = 0x0009,
            RT_RCDATA = 0x000A,
            RT_MESSAGETABLE = 0x000B,
            RT_GROUP_CURSOR = 0x000C,
            RT_GROUP_ICON = 0x000E,
            RT_VERSION = 0x0010,
            RT_DLGINCLUDE = 0x0011,
            RT_PLUGPLAY = 0x0013,
            RT_VXD = 0x0014,
            RT_ANICURSOR = 0x0015,
            RT_ANIICON = 0x0016,
            RT_HTML = 0x0017,
            RT_MANIFEST = 0x0018,
        };
 
        extern const std::map<offset_t, std::string> resource_type_id_descriptions;
    }
 
    namespace OS2
    {
        // based on OpenWatcom sources
 
        enum
        {
            // cursor
            RT_POINTER = 0x0001,
            RT_BITMAP = 0x0002,
            RT_MENU = 0x0003,
            RT_DIALOG = 0x0004,
            RT_STRING = 0x0005,
            RT_FONTDIR = 0x0006,
            RT_FONT = 0x0007,
            RT_ACCELERATOR = 0x0008,
            // binary data
            RT_RCDATA = 0x0009,
            // error message
            RT_MESSAGE = 0x000A,
            RT_DLGINCLUDE = 0x000B,
            RT_VKEYTBL = 0x000C,
            RT_KEYTBL = 0x000D,
            RT_CHARTBL = 0x000E,
            RT_DISPLAYINFO = 0x000F,
            // function key area
            RT_FKASHORT = 0x0010,
            RT_FKALONG = 0x0011,
            RT_HELPTABLE = 0x0012,
            RT_HELPSUBTABLE = 0x0013,
            RT_FDDIR = 0x0014,
            RT_FD = 0x0015,
        };
 
        extern const std::map<offset_t, std::string> resource_type_id_descriptions;
    }
 
    class NEFormat : public virtual Linker::SegmentManager, public std::enable_shared_from_this<NEFormat>
    {
    public:
        /* * * General members * * */
 
        struct Name
        {
        public:
            std::string name;
            uint16_t ordinal = 0;
        };
 
        class Segment
        {
        public:
            std::shared_ptr<Linker::Contents> image;
            offset_t data_offset = 0;
            offset_t image_size = 0;
            enum flag_type : uint16_t
            {
                Data = 1, Code = 0,
                Allocated = 2,
                Loaded = 4, /* RealMode = 4 */ /* TODO */
                Iterated = 8, /* TODO */
                Movable = 0x10, Fixed = 0,
                Shareable = 0x20,
                Preload = 0x40, LoadOnCall = 0,
                ExecuteOnly = 0x80|Code, ReadOnly = 0x80|Data,
                Relocations = 0x0100,
                DebugInfo = 0x0200,
                Discardable = 0x1000,
            };
            flag_type flags = flag_type(0);
            uint32_t total_size = 0;
            uint16_t movable_entry_index = 0;
 
            Segment()
            {
            }
 
            Segment(std::shared_ptr<Linker::Segment> segment, unsigned flags)
                : image(segment), flags(flag_type(flags))
            {
            }
 
            enum
            {
                PrivilegeLevelShift = 10,
            };
 
            class Relocation
            {
            public:
                enum source_type
                {
                    Offset8 = 0,
                    Selector16 = 2,
                    Pointer32 = 3,
                    Offset16 = 5,
                    Pointer48 = 11,
                    Offset32 = 13,
                };
                source_type type = source_type(0);
                enum flag_type
                {
                    TargetTypeMask = 3,
                    Internal = 0,
                    ImportOrdinal = 1,
                    ImportName = 2,
                    OSFixup = 3,
                    Additive = 4,
                };
                flag_type flags = flag_type(0);
                std::vector<uint16_t> offsets;
                uint16_t module = 0;
                enum
                {
                    FIARQQ = 1, FJARQQ = 1,
                    FISRQQ = 2, FJSRQQ = 2,
                    FICRQQ = 3, FJCRQQ = 3,
                    FIERQQ = 4,
                    FIDRQQ = 5,
                    FIWRQQ = 6,
                };
                uint16_t target = 0;
 
                std::string module_name;
                std::string import_name;
                uint8_t actual_segment = 0;
                uint16_t actual_offset = 0;
 
                Relocation() = default;
 
                Relocation(unsigned type, unsigned flags, uint16_t offset, uint16_t module, uint16_t target)
                    : type(source_type(type)), flags(flag_type(flags)), module(module), target(target)
                {
                    offsets.push_back(offset);
                }
 
                static source_type GetType(Linker::Relocation& rel);
                size_t GetSize() const;
            };
            std::vector<Relocation> relocations;
            std::map<uint16_t, Relocation> relocations_map;
 
            void AddRelocation(const Relocation& rel);
            void Dump(Dumper::Dumper& dump, unsigned index, bool isos2) const;
        };
 
        class Resource : public Segment
        {
        public:
            typedef std::variant<std::string, uint16_t> Identifier;
 
            static Identifier ConvertIdentifier(Linker::ResourceIdentifier identifier);
 
            uint16_t type_id = 0;
            std::optional<std::string> type_id_name;
            uint16_t id = 0;
            std::optional<std::string> id_name;
            uint16_t handle = 0;
            uint16_t usage = 0;
 
            Resource() = default;
 
            Resource(const Identifier& type, const Identifier& name, std::shared_ptr<Linker::Segment> segment, unsigned flags)
                : Segment(segment, flags)
            {
                if(auto name_p = std::get_if<std::string>(&type))
                {
                    type_id_name = *name_p;
                }
                else if(auto id_p = std::get_if<uint16_t>(&type))
                {
                    type_id = *id_p;
                }
 
                if(auto name_p = std::get_if<std::string>(&name))
                {
                    id_name = *name_p;
                }
                else if(auto id_p = std::get_if<uint16_t>(&name))
                {
                    id = *id_p;
                }
            }
 
            Resource(const Linker::ResourceIdentifier& type, const Linker::ResourceIdentifier& name, std::shared_ptr<Linker::Segment> segment, unsigned flags)
                : Resource(ConvertIdentifier(type), ConvertIdentifier(name), segment, flags)
            {
            }
 
            Identifier GetTypeIdentifier() const
            {
                if(type_id_name)
                {
                    return Identifier(type_id_name.value());
                }
                else
                {
                    return Identifier(uint16_t(type_id & 0x7FFF));
                }
            }
 
            Identifier GetNameIdentifier() const
            {
                if(id_name)
                {
                    return Identifier(id_name.value());
                }
                else
                {
                    return Identifier(uint16_t(id & 0x7FFF));
                }
            }
 
            void Dump(Dumper::Dumper& dump, unsigned index, bool isos2) const;
        };
 
        class ResourceType
        {
        public:
            virtual ~ResourceType() = default;
 
            uint16_t type_id = 0;
            std::optional<std::string> type_id_name;
            std::vector<std::shared_ptr<Resource>> resources;
 
            ResourceType() = default;
 
            ResourceType(const Resource::Identifier& type)
            {
                if(auto name_p = std::get_if<std::string>(&type))
                {
                    type_id_name = *name_p;
                }
                else if(auto id_p = std::get_if<uint16_t>(&type))
                {
                    type_id = *id_p;
                }
            }
        };
 
        class Entry
        {
        public:
            enum entry_type
            {
                Unused,
                Fixed,
                Movable,
            };
            entry_type type = Unused;
            uint8_t segment = 0;
            static constexpr uint8_t CONSTANT_VALUE = 0xFE;
            enum flag_type : uint8_t
            {
                Exported = 1,
                SharedData = 2,
            };
            flag_type flags = flag_type(0);
            uint16_t offset = 0;
 
            // informational purposes
            enum export_type
            {
                NotExported,
                ExportByName,
                ExportByOrdinal,
            };
            export_type export_state = NotExported;
            std::string entry_name;
 
            enum
            {
                WordCountShift = 3,
 
                INT_3Fh = 0x3FCD,
            };
 
            mutable bool same_bundle = false; // mutable because this isn't actually part of the entry state but the entire entry table
 
            Entry() = default;
 
            Entry(unsigned type, uint8_t segment, unsigned flags, uint16_t offset)
                : type(entry_type(type)), segment(segment), flags(flag_type(flags)), offset(offset)
            {
            }
 
            offset_t GetEntrySize() const;
 
            uint8_t GetIndicatorByte() const;
 
            static Entry ReadEntry(Linker::Reader& rd, uint8_t indicator_byte);
            void WriteEntry(Linker::Writer& wr) const;
        };
 
        class ModuleReference
        {
        public:
            uint16_t name_offset = 0;
            std::string name;
 
            ModuleReference(uint16_t name_offset, std::string name = "")
                : name_offset(name_offset), name(name)
            {
            }
        };
 
        std::array<char, 2> signature{'N', 'E'};
 
        struct version
        {
            uint8_t major, minor;
        };
        version linker_version{1, 0};
 
        uint32_t crc32 = 0;
 
        enum program_flag_type : uint8_t
        {
            NODATA = 0,
            SINGLEDATA = 1,
            MULTIPLEDATA = 2,
 
            GLOBAL_INITIALIZATION = 4,
            PROTECTED_MODE_ONLY = 8,
            CPU_8086 = 0x10, /* this is not how all systems handle this */
            CPU_80286 = 0x20,
            CPU_80386 = 0x40,
            CPU_8087 = 0x80,
        };
        program_flag_type program_flags = program_flag_type(0);
 
        enum application_flag_type : uint8_t
        {
            FULLSCREEN = 1,
            GUI_AWARE = 2,
            GUI = 3,
 
            FAMILY_APPLICATION = 8, /* first segment loads application */
            ERROR_IN_IMAGE = 0x20,
 
            LIBRARY = 0x80,
        };
        application_flag_type application_flags = application_flag_type(0);
 
        uint16_t automatic_data = 0;
 
        uint16_t stack_size = 0;
        uint16_t heap_size = 0;
 
        uint16_t ip = 0, cs = 0, sp = 0, ss = 0;
 
        // The following fields are listed in the order the parts appearing in the binary instead of the fields in the header
 
        uint32_t segment_table_offset = 0;
 
        std::vector<std::shared_ptr<Segment>> segments;
 
        uint32_t resource_table_offset = 0;
 
        uint16_t resource_count = 0;
 
        uint16_t resource_shift = 0;
 
        std::vector<std::shared_ptr<Resource>> resources;
 
        std::vector<std::shared_ptr<ResourceType>> resource_types;
 
        std::vector<std::string> resource_strings;
 
        uint32_t resident_name_table_offset = 0;
 
        std::vector<Name> resident_names;
 
        uint32_t module_reference_table_offset = 0;
 
        std::vector<ModuleReference> module_references;
 
        uint32_t imported_names_table_offset = 0;
 
        std::vector<std::string> imported_names;
 
        uint32_t nonresident_name_table_offset = 0;
        uint32_t nonresident_name_table_length = 0;
 
        std::vector<Name> nonresident_names;
 
        uint32_t entry_table_offset = 0;
 
        uint32_t entry_table_length = 0;
 
        uint16_t movable_entry_count = 0;
 
        std::vector<Entry> entries;
 
        uint16_t sector_shift = 9;
 
        enum system_type : uint8_t
        {
            OS2 = 1,
            Windows = 2,
            MSDOS4 = 3,
            Windows386 = 4,
            BorlandOSS = 5,
            PharLap = 0x80,
        };
        system_type system = system_type(0);
 
        enum additional_flag_type : uint8_t
        {
            SUPPORT_LONGFILENAME = 1,
            WIN20_PROTECTED_MODE = 2,
            WIN20_PROPORTIONAL_FONTS = 4,
            FAST_LOAD_AREA = 8,
        };
        additional_flag_type additional_flags = additional_flag_type(0);
 
        union
        {
            /* Windows */
            uint16_t fast_load_area_offset;
            /* OS/2 ? */
            uint16_t return_thunks_offset;
        };
        union
        {
            /* Windows */
            uint16_t fast_load_area_length;
            /* OS/2 ? */
            uint16_t segment_reference_thunks_offset;
        };
        uint16_t code_swap_area_length = 0;
 
        version windows_version{0, 0};
 
        offset_t file_size = offset_t(-1);
 
        bool IsLibrary() const;
 
        bool IsOS2() 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;
 
        enum output_type
        {
            OUTPUT_GUI,
            OUTPUT_CON,
            OUTPUT_DLL,
        };
        /*** @brief Whether to generate an executable or a library */
        output_type output;
 
        void SetTargetDefaults();
 
        explicit NEFormat()
        {
        }
 
        NEFormat(system_type system, output_type output)
            : system(system), fast_load_area_offset(0), fast_load_area_length(0), output(output)
        {
        }
 
        /* * * Writer members * * */
 
        enum compatibility_type
        {
            CompatibleNone,
            CompatibleWatcom,
            CompatibleMicrosoft,
            CompatibleBorland,
            // /** @brief Attempts to mimic the output of the GNU (MinGW) linker, this is undefined for the NE output */
            // CompatibleGNU,
        };
        compatibility_type compatibility = CompatibleNone;
 
        class NEOptionCollector : public Linker::OptionCollector
        {
        public:
            class SystemEnumeration : public Linker::Enumeration<system_type>
            {
            public:
                SystemEnumeration()
                    : Enumeration(
                        "OS2", OS2,
                        "WIN", Windows,
                        "WINDOWS", Windows,
                        "DOS", MSDOS4,
                        "MSDOS", MSDOS4,
                        "DOS4", MSDOS4,
                        "MSDOS4", MSDOS4,
                        "WIN386", Windows386,
                        "WINDOWS386", Windows386,
                        "BOSS", BorlandOSS,
                        "BORLAND", BorlandOSS,
                        "OS2+PHARLAP", system_type(OS2 + PharLap),
                        "WIN+PHARLAP", system_type(Windows + PharLap))
                {
                    descriptions = {
                        { OS2, "OS/2 1.0 - 1.3" },
                        { Windows, "Windows 1.0 - 3.11" },
                        { MSDOS4, "Multitasking MS-DOS 4.0" },
                        { Windows386, "Windows 386 (not supported)" },
                        { BorlandOSS, "Borland Operating System Services (not supported)" },
                        { system_type(OS2 + PharLap), "Phar Lap 286|DOS-Extender, OS/2 personality (not supported)" },
                        { system_type(Windows + PharLap), "Phar Lap 286|DOS-Extender, Windows personality (not supported)" },
                    };
                }
            };
 
            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)
                {
                    descriptions = {
                        { OUTPUT_GUI, "creates a graphical executable (for Windows, or Presentation Manager for OS/2)" },
                        { OUTPUT_CON, "creates a console (text mode) executable (for OS/2 or Multitasking MS-DOS 4.0)" },
                        { OUTPUT_DLL, "creates a dynamic linking library (DLL)" },
                    };
                }
            };
 
            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"};
            // TODO: make heap, target windows version, font/memory support parameters
 
            NEOptionCollector()
            {
                InitializeFields(stub, system, type, compat, stack);
            }
        };
 
        mutable MZStubWriter stub;
        std::shared_ptr<Linker::Segment> stack, heap;
        std::map<std::shared_ptr<Linker::Segment>, size_t> segment_index;
        std::map<std::string, uint16_t> module_reference_offsets;
        std::map<std::string, uint16_t> imported_name_offsets;
        uint16_t imported_names_length = 0;
        std::map<std::string, uint16_t> resource_name_offsets;
        uint16_t resource_table_size = 4; // alignment + resource type table terminator (without string table terminator 0 byte)
 
        /*std::string stub_file;*/
        std::string module_name;
        std::string program_name;
 
        bool option_capitalize_names = false; /* TODO: parametrize */
        enum memory_model_t
        {
            MODEL_SMALL,
            MODEL_LARGE,
        };
        memory_model_t memory_model = MODEL_SMALL;
 
        bool FormatSupportsSegmentation() const override;
 
        bool FormatIs16bit() const override;
 
        bool FormatIsProtectedMode() const override;
 
        bool FormatSupportsLibraries() const override;
 
        bool FormatSupportsResources() const override;
 
        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;
 
        std::shared_ptr<NEFormat> SimulateLinker(compatibility_type compatibility);
 
        static std::shared_ptr<NEFormat> CreateConsoleApplication(system_type system = Windows);
 
        static std::shared_ptr<NEFormat> CreateGUIApplication(system_type system = Windows);
 
        static std::shared_ptr<NEFormat> CreateLibraryModule(system_type system = Windows);
 
        std::map<std::tuple<Resource::Identifier, Resource::Identifier>, std::shared_ptr<Resource>> resources_map;
 
        unsigned GetCodeSegmentFlags() const;
        unsigned GetDataSegmentFlags() const;
        unsigned GetResourceFlags() const;
        void AddResource(std::shared_ptr<Resource> resource);
        void AddSegment(std::shared_ptr<Segment> segment);
        uint16_t FetchModule(std::string name);
        uint16_t FetchImportedName(std::string name);
        uint16_t FetchResourceName(std::string name);
        std::string MakeProcedureName(std::string name);
        uint16_t MakeEntry(Linker::Position value);
        uint16_t MakeEntry(uint16_t ordinal, Linker::Position value);
        uint8_t CountBundles(size_t entry_index) const;
 
        void SetModel(std::string model) 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;
    };
 
    class ResourceFile : public virtual Linker::Format
    {
    public:
        enum system_type
        {
            System_Unspecified,
            System_Windows,
            System_Windows_1x,
            System_Windows_3x,
            System_OS2,
        };
        system_type system;
 
        ResourceFile(system_type system = System_Unspecified)
            : system(system)
        {
        }
 
        typedef std::variant<uint16_t, std::string> Identifier;
 
        static void ReadIdentifier(Linker::Reader& rd, Identifier& id);
        static void WriteIdentifier(Linker::Writer& wr, const Identifier& id);
        static offset_t GetIdentifierSize(const Identifier& id);
 
        class Resource
        {
        public:
            Identifier type;
            Identifier name;
            uint16_t flags;
            std::shared_ptr<Linker::Contents> image;
        };
 
        offset_t file_offset;
        std::vector<Resource> resources;
 
        void ReadFile(Linker::Reader& rd) override;
        void ReadFile(Linker::Reader& rd, offset_t size);
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        class IdDisplay : public Dumper::Display<Identifier>
        {
        public:
            std::map<offset_t, std::string> names;
 
            IdDisplay()
            {
            }
 
            IdDisplay(const std::map<offset_t, std::string>& names)
                : names(names)
            {
            }
 
            void DisplayValue(Dumper::Dumper& dump, std::tuple<Identifier> values) override;
            static std::shared_ptr<IdDisplay> Make();
            static std::shared_ptr<IdDisplay> Make(const std::map<offset_t, std::string>& names);
        };
    };
}
 
#endif /* NEEXE_H */