cpm86.h

#ifndef CPM86_H
#define CPM86_H
 
#include <array>
#include <map>
#include <set>
#include <vector>
#include "../common.h"
#include "../linker/module.h"
#include "../linker/options.h"
#include "../linker/segment.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
#include "../dumper/dumper.h"
 
namespace DigitalResearch
{
    class CPM86Format : public virtual Linker::SegmentManager
    {
    public:
        /* * * General members * * */
 
        class Descriptor
        {
        public:
            enum group_type
            {
                Undefined,
                Code = 1,
                Data,
                Extra,
                Stack,
                Auxiliary1,
                Auxiliary2,
                Auxiliary3,
                Auxiliary4,
                SharedCode,
 
                Fixups = Auxiliary4, /* FlexOS 286 only */
                FastLoad = 0xFE,
                Libraries = 0xFF,
 
                ActualAuxiliary4 = 0x100 | Auxiliary4,
                ActualFixups = 0x200 | Fixups,
            };
            group_type type = Undefined;
            uint16_t size_paras = 0;
            uint16_t load_segment = 0;
            uint16_t min_size_paras = 0;
            uint16_t max_size_paras = 0;
            uint32_t offset = 0;
            std::shared_ptr<Linker::Contents> image = nullptr;
            bool attach_zero_page = false;
 
            virtual void Clear();
 
            ~Descriptor()
            {
                Clear();
            }
 
            virtual uint16_t GetSizeParas(const CPM86Format& module) const;
 
            void ReadDescriptor(const std::shared_ptr<Linker::Reader>& rd);
 
            void Prepare(CPM86Format& module);
 
            void WriteDescriptor(const std::shared_ptr<Linker::Writer>& wr, const CPM86Format& module) const;
 
            virtual void WriteData(const std::shared_ptr<Linker::Writer>& wr, const CPM86Format& module) const;
 
            std::string GetDefaultName() const;
 
            virtual void ReadData(const std::shared_ptr<Linker::Reader>& rd, const CPM86Format& module);
        };
 
        struct relocation_source
        {
            number_t segment;
            offset_t offset;
 
            relocation_source()
                : segment(0), offset(0)
            {
            }
 
            relocation_source(size_t segment, offset_t offset)
                : segment(segment), offset(offset)
            {
            }
 
            bool operator==(const relocation_source& other) const;
            bool operator<(const relocation_source& other) const;
        };
 
        typedef relocation_source relocation_target;
 
        struct Relocation
        {
            uint8_t source = 0;
            uint16_t paragraph = 0;
            uint8_t offset = 0;
            uint8_t target = 0;
 
            Relocation()
            {
            }
 
            Relocation(uint8_t source, uint16_t paragraph, uint16_t offset, uint8_t target)
                : source(source), paragraph(paragraph), offset(offset), target(target)
            {
            }
 
            Relocation(relocation_source source, uint8_t target = 0)
                : source(source.segment), paragraph(source.offset >> 4), offset(source.offset & 0xF), target(target)
            {
            }
 
            operator bool() const;
 
            void Read(const std::shared_ptr<Linker::Reader>& rd, CPM86Format& module, bool is_library = false);
 
            void Write(const std::shared_ptr<Linker::Writer>& wr) const;
 
            relocation_source GetSource() const;
        };
 
        struct rsx_record
        {
            std::string rsx_file_name;
            std::string name;
            uint16_t offset_record = 0;
            static constexpr uint16_t RSX_TERMINATE = 0xFFFF;
            static constexpr uint16_t RSX_DYNAMIC = 0x0000;
            std::shared_ptr<Linker::Contents> contents;
 
            void Clear();
 
            void Read(const std::shared_ptr<Linker::Reader>& rd);
 
            void ReadModule(const std::shared_ptr<Linker::Reader>& rd);
 
            void Write(const std::shared_ptr<Linker::Writer>& wr) const;
 
            void WriteModule(const std::shared_ptr<Linker::Writer>& wr) const;
 
            offset_t GetFullFileSize() const;
            void SetOffset(offset_t new_offset);
 
            void Dump(Dumper::Dumper& dump) const;
        };
 
        struct library_id
        {
            std::string name;
            uint16_t major_version = 0;
            uint16_t minor_version = 0;
            uint32_t flags = 0x11010000;
 
            library_id() { }
 
            library_id(std::string name, uint16_t major_version, uint16_t minor_version)
                : name(name), major_version(major_version), minor_version(minor_version)
            {
            }
 
            library_id(std::string name, uint16_t major_version, uint16_t minor_version, uint32_t flags)
                : name(name), major_version(major_version), minor_version(minor_version), flags(flags)
            {
            }
 
            library_id(const library_id& lib) = default;
 
            static library_id ParseNameAndVersion(std::string name_and_version);
 
            bool operator ==(const library_id& other) const;
 
            void Write(const std::shared_ptr<Linker::Writer>& wr) const;
 
            void Read(const std::shared_ptr<Linker::Reader>& rd);
        };
 
        struct library : public library_id
        {
            std::vector<Relocation> relocations;
            uint16_t relocation_count = 0;
 
            uint16_t first_selector = 0;
            uint16_t unknown = 0;
 
            std::set<relocation_source> relocation_targets;
 
            library()
            {
            }
 
            library(std::string name, uint16_t major_version, uint16_t minor_version)
                : library_id(name, major_version, minor_version)
            {
            }
 
            library(std::string name, uint16_t major_version, uint16_t minor_version, uint32_t flags)
                : library_id(name, major_version, minor_version, flags)
            {
            }
 
            library(const library_id& lib)
                : library_id(lib)
            {
            }
 
            void Write(const std::shared_ptr<Linker::Writer>& wr) const;
 
            void WriteExtended(const std::shared_ptr<Linker::Writer>& wr) const;
 
            void Read(const std::shared_ptr<Linker::Reader>& rd);
 
            void ReadExtended(const std::shared_ptr<Linker::Reader>& rd);
        };
 
        class LibraryDescriptor : public Descriptor
        {
        public:
            std::vector<library> libraries;
 
            void Clear() override;
 
            void Prepare(CPM86Format& module);
 
#if 0
            bool IsFastLoadFormat() const;
#endif
 
            library& FetchImportedLibrary(std::string name_dot_version);
 
            library& FetchImportedLibrary(library_id id);
 
            uint16_t GetSizeParas(const CPM86Format& module) const override;
 
            void WriteData(const std::shared_ptr<Linker::Writer>& wr, const CPM86Format& module) const override;
 
            void ReadData(const std::shared_ptr<Linker::Reader>& rd, const CPM86Format& module) override;
        };
 
        class FastLoadDescriptor : public Descriptor
        {
        public:
            uint16_t maximum_entries = 0;
            uint16_t first_free_entry = 0;
            uint16_t index_base = 0;
            uint16_t first_used_index = 0;
 
            struct ldt_descriptor
            {
                uint16_t limit = 0;
                uint32_t address = 0;
                uint8_t group = 0;
                uint16_t reserved = 0;
 
                void Read(const std::shared_ptr<Linker::Reader>& rd);
 
                void Write(const std::shared_ptr<Linker::Writer>& wr) const;
            };
 
            std::vector<ldt_descriptor> ldt;
 
            void Clear() override;
 
            uint16_t GetSizeParas(const CPM86Format& module) const override;
 
            void WriteData(const std::shared_ptr<Linker::Writer>& wr, const CPM86Format& module) const override;
 
            void ReadData(const std::shared_ptr<Linker::Reader>& rd, const CPM86Format& module) override;
        };
 
        std::array<Descriptor, 8> descriptors;
        LibraryDescriptor library_descriptor;
        FastLoadDescriptor fastload_descriptor;
        library_id lib_id;
        std::vector<Relocation> relocations;
        uint32_t relocations_offset = 0;
        std::array<rsx_record, 8> rsx_table;
        uint32_t rsx_table_offset = 0;
        uint8_t flags = 0;
        uint8_t cpm_flags = 0;
 
        uint32_t file_offset = 0;
        mutable offset_t file_size = offset_t(-1);
 
        enum
        {
            FLAG_FIXUPS = 0x80,
            FLAG_OPTIONAL_8087 = 0x40,
            FLAG_REQUIRED_8087 = 0x20,
            FLAG_RSX = 0x10,
            FLAG_DIRECT_VIDEO = 0x08,
            FLAG_MPMLOCK = 0x04,
            FLAG_NO_BANKING = 0x02,
        };
 
        enum
        {
            CPM_FLAG_F1 = 0x01,
            CPM_FLAG_F2 = 0x02,
            CPM_FLAG_F3 = 0x03,
            CPM_FLAG_F4 = 0x04,
        };
 
        void Clear() override;
 
        enum format_type
        {
            FORMAT_UNKNOWN,
            FORMAT_8080,
            FORMAT_SMALL,
            FORMAT_COMPACT,
            FORMAT_FLEXOS,
            FORMAT_FASTLOAD,
        };
        format_type format;
 
        enum application_type
        {
            APPL_UNKNOWN,
            APPL_CMD,
            APPL_RSX,
            APPL_RSP,
            APPL_MPM,
            APPL_CON,
            APPL_OVR,
            APPL_286,
            APPL_SRL,
        };
        application_type application;
 
        CPM86Format(format_type format = FORMAT_UNKNOWN, application_type application = APPL_UNKNOWN)
            : format(format), application(application)
        {
        }
 
        ~CPM86Format()
        {
            Clear();
        }
 
        uint16_t GetRelocationSizeParas() const;
 
        size_t CountValidGroups();
 
        number_t FindSegmentGroup(unsigned group) const;
 
        void CheckValidSegmentGroup(unsigned group);
 
        bool IsFastLoadFormat() const;
        bool IsSharedRunTimeLibrary() const;
 
        void ReadRelocations(const std::shared_ptr<Linker::Reader>& rd);
 
        void WriteRelocations(const std::shared_ptr<Linker::Writer>& wr) const;
 
        offset_t MeasureRelocations();
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
 
        offset_t ImageSize() const override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
 
        offset_t GetFullFileSize() const;
 
        void Dump(Dumper::Dumper& dump) const override;
 
        void CalculateValues() override;
 
        /* * * Writer members * * */
 
        class CPM86OptionCollector : public Linker::OptionCollector
        {
        public:
            enum system_type
            {
                System_CPM86,
                System_FlexOS286,
            };
 
            class SystemEnumeration : public Linker::Enumeration<system_type>
            {
            public:
                SystemEnumeration()
                    : Enumeration(
                        "CPM", System_CPM86,
                        "CPM86", System_CPM86,
                        "FLEXOS", System_FlexOS286,
                        "FLEXOS286", System_FlexOS286)
                {
                    descriptions = {
                        { System_CPM86, "Digital Research CP/M-86" },
                        { System_FlexOS286, "Digital Research FlexOS 286" },
                    };
                }
            };
 
            enum format_type
            {
                Format_8080,
                Format_Small,
                Format_Compact,
            };
 
            class FormatEnumeration : public Linker::Enumeration<format_type>
            {
            public:
                FormatEnumeration()
                    : Enumeration(
                        "8080", Format_8080,
                        "TINY", Format_8080,
                        "T", Format_8080,
                        "SMALL", Format_Small,
                        "S", Format_Small,
                        "COMPACT", Format_Compact,
                        "COMP", Format_Compact,
                        "C", Format_Compact)
                {
                    descriptions = {
                        { Format_8080, "8080 model, a single segment group is generated" },
                        { Format_Small, "Small model, a single code and separate data group is generated" },
                        { Format_Compact, "Compact model, a single code and multiple data groups are generated" },
                    };
                }
            };
 
            Linker::Option<Linker::ItemOf<SystemEnumeration>> system{"system", "Target operating system"};
            Linker::Option<Linker::ItemOf<FormatEnumeration>> format{"format", "File format"};
            Linker::Option<bool> postlink{"postlink", "Generate fast load (POSTLINK) format (only for FlexOS)"};
            Linker::Option<bool> noreloc{"noreloc", "Suppress generating relocations"};
            Linker::Option<bool> sharedcode{"sharedcode", "Make the code segment shared (descriptor type 9)"};
            Linker::Option<std::optional<std::vector<std::string>>> rsx_file_names{"rsx", "List of filenames to append as Resident System Extensions (CP/M)"};
            Linker::Option<bool> fixupgroup{"fixupgroup", "Generates group descriptor for fixups (FlexOS)"};
            Linker::Option<std::optional<std::string>> srtl{"srtl", "Generate shared run-time library, parameter: <library name>.<major version>.<minor version>[.<optional flags as hexadecimal value>]"};
            Linker::Option<std::string> x87{"8087", "Sets 8087 usage, valid values: off/on/auto", "off"};
            Linker::Option<bool> directvideo{"directvideo", "Direct video access"};
            Linker::Option<bool> mpmlock{"mpmlock", "MP/M-style record handling (Concurrent DOS)"};
            Linker::Option<bool> nobank{"nobank", "Cannot run in banked memory"};
            Linker::Option<bool> f1{"f1", "CP/M F1 flag (Concurrent DOS)"};
            Linker::Option<bool> f2{"f2", "CP/M F2 flag (Concurrent DOS)"};
            Linker::Option<bool> f3{"f3", "CP/M F3 flag (Concurrent DOS)"};
            Linker::Option<bool> f4{"f4", "CP/M F4 flag (Concurrent DOS)"};
            // TODO: make stack size a parameter (for FlexOS)
 
            CPM86OptionCollector()
            {
                InitializeFields(system, format, postlink, noreloc, sharedcode, rsx_file_names, fixupgroup, srtl, x87, directvideo, mpmlock, nobank, f1, f2, f3, f4);
            }
        };
 
        bool option_shared_code = false;
        bool option_no_relocation = false;
        bool option_generate_fixup_group = false;
 
        enum memory_model_t
        {
            MODEL_DEFAULT,
            MODEL_TINY,
            MODEL_SMALL,
            MODEL_COMPACT,
        };
        memory_model_t memory_model = MODEL_SMALL;
 
        bool FormatSupportsSegmentation() const override;
 
        bool FormatIs16bit() const override;
 
        bool FormatIsProtectedMode() const override;
 
        bool FormatSupportsLibraries() const override;
 
        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;
 
        std::vector<std::shared_ptr<Linker::Segment>>& Segments();
 
        std::map<std::shared_ptr<Linker::Segment>, Descriptor::group_type> segment_types;
 
        void AssignSegmentTypes();
 
        unsigned GetSegmentNumber(std::shared_ptr<Linker::Segment> segment);
 
        static std::vector<Linker::OptionDescription<void>> MemoryModelNames;
 
        std::vector<Linker::OptionDescription<void>> GetMemoryModelNames() override;
 
        void SetModel(std::string model) override;
 
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
 
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        std::unique_ptr<Script::List> GetScript(Linker::Module& module);
 
        void Link(Linker::Module& module);
 
        void BuildLDTImage(Linker::Module& module);
 
        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;
    };
 
}
 
#endif /* CPM86_H */