cpm68k.h

#ifndef CPM68K_H
#define CPM68K_H
 
#include <map>
#include <set>
#include <string>
#include "../common.h"
#include "../linker/module.h"
#include "../linker/options.h"
#include "../linker/reader.h"
#include "../linker/segment.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
#include "../dumper/dumper.h"
 
namespace DigitalResearch
{
    namespace CDOS
    {
        template <typename SizeType>
            offset_t MeasureRelocations(const std::map<uint32_t, SizeType>& relocations)
        {
            /* TODO: test */
            offset_t count = 0;
            offset_t last_relocation = 0;
            for(auto it : relocations)
            {
                offset_t difference = it.first - last_relocation;
                if(difference != 0 && difference <= 0x7C)
                {
                    count += 1;
                }
                else if(difference < 0x100)
                {
                    count += 2;
                }
                else if(difference < 0x10000)
                {
                    count += 3;
                }
                else
                {
                    count += 5;
                }
            }
            return count;
        }
 
        template <typename SizeType>
            void WriteRelocations(const std::shared_ptr<Linker::Writer>& wr, const std::map<uint32_t, SizeType>& relocations)
        {
            /* TODO: test */
            offset_t last_relocation = 0;
            for(auto it : relocations)
            {
                offset_t difference = it.first - last_relocation;
                uint8_t highbit = it.second/*.size*/ == 2 ? 0x80 : 0x00;
                if(difference != 0 && difference <= 0x7C)
                {
                    wr->WriteWord(1, highbit | difference);
                }
                else if(difference < 0x100)
                {
                    wr->WriteWord(1, highbit | 0x7D);
                    wr->WriteWord(1, difference);
                }
                else if(difference < 0x10000)
                {
                    wr->WriteWord(1, highbit | 0x7E);
                    wr->WriteWord(2, difference);
                }
                else
                {
                    wr->WriteWord(1, highbit | 0x7F);
                    wr->WriteWord(4, difference);
                }
                last_relocation = it.first;
            }
            wr->WriteWord(1, 0);
        }
 
        template <typename SizeType, typename Format>
            void ReadRelocations(const std::shared_ptr<Linker::Reader>& rd, std::map<uint32_t, SizeType>& relocations, const Format& format)
        {
            /* TODO: test */
            offset_t offset = 0;
            while(true)
            {
                uint8_t byte = rd->ReadUnsigned(1);
                size_t size = (byte & 0x80) ? 2 : 4;
                byte &= 0x7F;
                if(byte == 0)
                {
                    break;
                }
                else if(byte <= 0x7C)
                {
                    offset += byte;
                }
                else if(byte == 0x7D)
                {
                    offset += rd->ReadUnsigned(1);
                }
                else if(byte == 0x7E)
                {
                    offset += rd->ReadUnsigned(2);
                }
                else /*if(byte == 0x7F)*/
                {
                    offset += rd->ReadUnsigned(4);
                }
                relocations[offset] = SizeType::Create(size, offset, format);
            }
        }
    }
 
    class CPM68KFormat : public virtual Linker::SegmentManager
    {
    public:
        /* * * General members * * */
 
        enum magic_type
        {
            MAGIC_CONTIGUOUS = 1,
            MAGIC_NONCONTIGUOUS,
            MAGIC_CRUNCHED, /* Concurrent DOS 68K only */
        };
 
        char signature[2] = { 0x60, 0x1A };
 
        uint32_t code_size = 0;
        uint32_t data_size = 0;
        uint32_t bss_size = 0;
        uint32_t symbol_table_size = 0;
        uint32_t stack_size = 0;
 
        uint32_t code_address = 0;
        uint32_t program_flags = 0; /* TODO: make parameter */
 
        uint16_t relocations_suppressed = 1;
        uint32_t data_address = 0;
        uint32_t bss_address = 0;
        offset_t file_size = 0;
 
        std::shared_ptr<Linker::Contents> code = nullptr;
        std::shared_ptr<Linker::Contents> data = nullptr;
 
        /* filled in automatically */
        struct Relocation
        {
            size_t size;
            unsigned segment;
            operator size_t() const;
 
            static Relocation Create(size_t size, uint32_t offset, const CPM68KFormat& format);
        };
        std::map<uint32_t, Relocation> relocations;
 
        struct Symbol
        {
            std::string name;
            enum symbol_type
            {
                LIBRARY_START = 0x0040,
                OBJECT_START = 0x0080,
                BSS_BASED = 0x0100,
                TEXT_BASED = 0x0200,
                DATA_BASED = 0x0400,
                EXTERNAL = 0x0800,
                REGISTER = 0x1000,
                GLOBAL = 0x2000,
                EQUATED = 0x4000,
                DEFINED = 0x8000,
            };
            uint16_t type;
            uint32_t value;
 
            static Symbol ReadFile(const std::shared_ptr<Linker::Reader>& rd);
            void WriteFile(const std::shared_ptr<Linker::Writer>& wr) const;
        };
        std::vector<Symbol> symbols;
 
        magic_type GetSignature() const;
 
        void SetSignature(magic_type magic);
 
        enum system_type
        {
            SYSTEM_UNKNOWN,
            SYSTEM_CPM68K,
            SYSTEM_GEMDOS_EARLY, /* TODO: parametrize this type */
            SYSTEM_GEMDOS,
            SYSTEM_HUMAN68K,
            SYSTEM_CDOS68K
        };
 
        system_type system;
 
        void Clear() override;
 
        CPM68KFormat(system_type system = SYSTEM_UNKNOWN)
            : system(system)
        {
        }
 
        CPM68KFormat(system_type system, magic_type magic)
            : system(system)
        {
            SetSignature(magic);
        }
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
 
        offset_t MeasureRelocations() const;
 
        offset_t ImageSize() const override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
 
        void Dump(Dumper::Dumper& dump) const override;
 
        void CalculateValues() override;
 
        /* * * Writer members * * */
 
        class CPM68KOptionCollector : public Linker::OptionCollector
        {
        public:
            Linker::Option<bool> noreloc{"noreloc", "Suppress generating relocations"};
            Linker::Option<bool> reloc{"reloc", "Force relocation generation"};
            // TODO: make stack size a parameter (for Concurrent DOS 68K)
            // TODO: make parameters for system and format type
 
            CPM68KOptionCollector()
            {
                InitializeFields(noreloc, reloc);
            }
        };
 
        bool option_no_relocation = true;
 
        std::shared_ptr<Linker::Segment> bss_segment;
        std::shared_ptr<Linker::Segment> stack_segment;
 
        std::shared_ptr<Linker::Segment> CodeSegment();
        std::shared_ptr<const Linker::Segment> CodeSegment() const;
 
        std::shared_ptr<Linker::Segment> DataSegment();
        std::shared_ptr<const Linker::Segment> DataSegment() const;
 
        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;
 
        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;
 
        void CreateDefaultSegments();
 
        std::unique_ptr<Script::List> GetScript(Linker::Module& module);
 
        void Link(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 /* CPM68K_H */