coff.h

#ifndef COFF_H
#define COFF_H
 
#include <map>
#include "cpm68k.h"
#include "mzexe.h"
#include "../common.h"
#include "../linker/linker.h"
#include "../linker/module.h"
#include "../linker/segment.h"
#include "../linker/writer.h"
 
namespace COFF
{
    class COFFFormat : public virtual Linker::InputFormat, public virtual Linker::OutputFormat, public Linker::LinkerManager, protected Microsoft::MZSimpleStubWriter
    {
        /* * * General members * * */
    public:
        enum cpu
        {
            CPU_UNKNOWN = 0,
            // main supported types
            CPU_I386  = 0x014C,
            CPU_M68K  = 0x0150,
            // GNU binutils output
            CPU_W65   = 0x6500,
            CPU_Z80   = 0x805A,
            CPU_Z8K   = 0x8000,
            // other CPU types, included for completeness sake
            CPU_I86   = 0x0148,
            CPU_NS32K = 0x0154,
            CPU_I370  = 0x0158, // IBM 370
            CPU_MIPS  = 0x0160,
            CPU_M88K  = 0x016D,
            CPU_WE32K = 0x0170,
            CPU_VAX   = 0x0178,
            CPU_AM29K = 0x017A,
            CPU_ALPHA = 0x0183,
            CPU_PPC   = 0x01DF,
            CPU_PPC64 = 0x01F7,
            CPU_SHARC = 0x521C,
            // overloaded values
            // for now, none
        };
 
        struct MachineType
        {
            cpu actual_cpu;
            ::EndianType endian;
        };
 
        static const std::map<uint32_t, MachineType> MACHINE_TYPES;
 
        char signature[2] = { };
 
        ::EndianType GetEndianType() const;
 
        class Relocation
        {
        public:
            virtual ~Relocation();
            virtual offset_t GetAddress() = 0;
            virtual size_t GetSize() = 0;
            virtual void FillEntry(Dumper::Entry& entry) = 0;
        };
 
        class ZilogRelocation : public Relocation
        {
        public:
            // https://github.com/aixoss/binutils/blob/master/include/coff/internal.h
            // https://github.com/aixoss/binutils/blob/master/include/coff/z80.h
            // https://github.com/aixoss/binutils/blob/master/include/coff/z8k.h
 
            static const uint16_t R_Z80_IMM8  = 0x22;
            static const uint16_t R_Z80_IMM16 = 0x01;
            static const uint16_t R_Z80_IMM24 = 0x33;
            static const uint16_t R_Z80_IMM32 = 0x17;
            static const uint16_t R_Z80_OFF8  = 0x32;
            static const uint16_t R_Z80_JR    = 0x02;
 
            static const uint16_t R_Z8K_IMM4L = 0x23;
            static const uint16_t R_Z8K_IMM4H = 0x24;
            static const uint16_t R_Z8K_DISP7 = 0x25; /* djnz */
            static const uint16_t R_Z8K_IMM8  = 0x22;
            static const uint16_t R_Z8K_IMM16 = 0x01;
            static const uint16_t R_Z8K_REL16 = 0x04;
            static const uint16_t R_Z8K_IMM32 = 0x11;
            static const uint16_t R_Z8K_JR    = 0x02; /* jr */
            static const uint16_t R_Z8K_CALLR = 0x05; /* callr */
 
            static const uint16_t R_W65_ABS8     = 0x01;
            static const uint16_t R_W65_ABS16    = 0x02;
            static const uint16_t R_W65_ABS24    = 0x03;
            static const uint16_t R_W65_ABS8S8   = 0x04;
            static const uint16_t R_W65_ABS8S16  = 0x05;
            static const uint16_t R_W65_ABS16S8  = 0x06;
            static const uint16_t R_W65_ABS16S16 = 0x07;
            static const uint16_t R_W65_PCR8     = 0x08;
            static const uint16_t R_W65_PCR16    = 0x09;
            static const uint16_t R_W65_DP       = 0x0A;
 
            cpu cpu_type;
 
            uint32_t address;
            uint32_t symbol_index;
            uint32_t offset;
            uint16_t type;
            uint16_t data;
 
            ZilogRelocation(cpu cpu_type)
                : cpu_type(cpu_type)
            {
            }
 
            void Read(Linker::Reader& in);
 
            offset_t GetAddress() override;
 
            size_t GetSize() override;
 
            void FillEntry(Dumper::Entry& entry) override;
        };
 
        class Symbol
        {
        public:
            std::string name;
            uint32_t name_index;
            uint32_t value;
            uint16_t section_number;
            uint16_t type;
            uint8_t storage_class;
            uint8_t auxiliary_count;
 
            void Read(Linker::Reader& rd);
 
            bool IsExternal() const;
        };
 
        class Section
        {
        public:
            std::string name;
            uint32_t physical_address = 0;
            uint32_t address = 0;
            uint32_t size = 0;
            uint32_t section_pointer = 0;
            uint32_t relocation_pointer = 0;
            uint32_t line_number_pointer = 0;
            uint16_t relocation_count = 0;
            uint16_t line_number_count = 0;
            uint32_t flags = 0;
 
            std::shared_ptr<Linker::Writable> image;
 
            std::vector<std::unique_ptr<Relocation>> relocations;
 
            enum
            {
                TEXT = 0x0020,
                DATA = 0x0040,
                BSS  = 0x0080,
            };
 
            void Clear();
 
            Section(uint32_t flags = 0, std::shared_ptr<Linker::Writable> image = nullptr)
                : flags(flags), image(image)
            {
            }
 
            ~Section()
            {
                Clear();
            }
 
            void ReadSectionHeader(Linker::Reader& rd);
 
            void WriteSectionHeader(Linker::Writer& wr);
 
            uint32_t ActualDataSize();
        };
 
        std::vector<std::unique_ptr<Section>> sections;
 
        uint16_t section_count = 0;
        uint32_t timestamp = 0;
        uint32_t symbol_table_offset = 0;
        uint32_t symbol_count = 0;
        std::vector<std::unique_ptr<Symbol>> symbols;
        uint32_t optional_header_size = 0;
        uint16_t flags = 0;
 
        class OptionalHeader
        {
        public:
            virtual ~OptionalHeader();
            virtual uint32_t GetSize() = 0;
            virtual void ReadFile(Linker::Reader& rd) = 0;
            virtual void WriteFile(Linker::Writer& wr) = 0;
            virtual void PostReadFile(COFFFormat& coff, Linker::Reader& rd);
            virtual void PostWriteFile(COFFFormat& coff, Linker::Writer& wr);
 
            virtual void Dump(COFFFormat& coff, Dumper::Dumper& dump);
        };
 
        std::unique_ptr<OptionalHeader> optional_header = nullptr;
 
        std::map<uint32_t, size_t> relocations; /* CDOS68K */
 
        class UnknownOptionalHeader : public OptionalHeader
        {
        public:
            std::unique_ptr<Linker::Buffer> buffer = nullptr;
 
            UnknownOptionalHeader(offset_t size)
                : buffer(std::make_unique<Linker::Buffer>(size))
            {
            }
 
            uint32_t GetSize() override;
 
            void ReadFile(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) override;
 
            void Dump(COFFFormat& coff, Dumper::Dumper& dump) override;
        };
 
        class AOutHeader : public OptionalHeader
        {
        public:
            uint16_t magic = 0;
            uint16_t version_stamp = 0;
 
            uint32_t code_size = 0;
            uint32_t data_size = 0;
            uint32_t bss_size = 0;
            uint32_t entry_address = 0;
            uint32_t code_address = 0;
            uint32_t data_address = 0;
 
            AOutHeader(uint16_t magic = 0)
                : magic(magic)
            {
            }
 
            uint32_t GetSize() override;
 
            void ReadFile(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) override;
 
        protected:
            virtual void DumpFields(COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region);
 
        public:
            void Dump(COFFFormat& coff, Dumper::Dumper& dump) override;
        };
 
        class FlexOSAOutHeader : public AOutHeader
        {
        public:
            uint32_t relocations_offset = 0;
            uint32_t stack_size = 0;
 
            /* TODO: magic not needed for CDOS68K? */
 
            uint32_t GetSize() override;
 
            void ReadFile(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) override;
 
            void PostReadFile(COFFFormat& coff, Linker::Reader& rd) override;
 
            void PostWriteFile(COFFFormat& coff, Linker::Writer& wr) override;
 
        protected:
            void DumpFields(COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) override;
        };
 
        class GNUAOutHeader : public OptionalHeader
        {
        public:
            /* Note: untested */
            uint32_t info = 0;
            uint32_t code_size = 0;
            uint32_t data_size = 0;
            uint32_t bss_size = 0;
            uint32_t symbol_table_size = 0;
            uint32_t entry_address = 0;
            uint32_t code_relocation_size = 0;
            uint32_t data_relocation_size = 0;
 
            uint32_t GetSize() override;
 
            void ReadFile(Linker::Reader& wr) override;
 
            void WriteFile(Linker::Writer& wr) override;
 
            void Dump(COFFFormat& coff, Dumper::Dumper& dump) override;
        };
 
        class MIPSAOutHeader : public AOutHeader
        {
        public:
            // https://web.archive.org/web/20140723105157/http://www-scf.usc.edu/~csci402/ncode/coff_8h-source.html
            /* bss_start */
            uint32_t bss_address;
            /* gpr_mask */
            uint32_t gpr_mask;
            /* cprmask */
            uint32_t cpr_mask[4];
            /* gp_value */
            uint32_t gp_value;
            /* TODO */
 
        protected:
            void DumpFields(COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) override;
        };
 
        void Clear() override;
 
        void AssignMagicValue();
 
        cpu cpu_type = CPU_UNKNOWN;
 
        ::EndianType endiantype = ::EndianType(0);
 
        bool DetectCpuType(::EndianType expected);
 
        void DetectCpuType();
 
        void ReadFile(Linker::Reader& rd) override;
 
        void WriteFile(Linker::Writer& wr) override;
 
        void Dump(Dumper::Dumper& dump) override;
 
        /* * * Reader members * * */
 
        void SetupOptions(std::shared_ptr<Linker::OutputFormat> format) override;
 
        bool option_segmentation = false;
 
        bool FormatRequiresDataStreamFix() const override;
 
    private:
        /* symbols */
        std::string segment_prefix();
 
        std::string segment_of_prefix();
 
        std::string segmented_address_prefix();
 
#if 0
        // TODO: can this be used?
        std::string segment_difference_prefix();
#endif
 
        enum
        {
            /* section number */
            N_UNDEF = 0,
            N_ABS = 0xFFFF,
            N_DEBUG = 0xFFFE,
 
            /* storage class */
            C_EXT = 2,
            C_STAT = 3,
            C_LABEL = 6,
        };
 
        void GenerateModule(Linker::Module& module) const;
 
    public:
        void ProduceModule(Linker::Module& module, Linker::Reader& rd) override;
 
        /* * * Writer members * * */
 
    public:
        enum format_type
        {
            GENERIC,
            DJGPP,
            CDOS68K,
            CDOS386,
        };
        format_type type = GENERIC;
 
        bool option_no_relocation = false;
 
        uint32_t stub_size = 0;
 
        std::shared_ptr<Linker::Segment> stack;
        uint32_t entry_address = 0; /* TODO */
        uint32_t relocations_offset = 0;
 
        COFFFormat(format_type type = GENERIC)
            : type(type)
        {
        }
 
        ~COFFFormat()
        {
            Clear();
        }
 
        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;
 
        static std::shared_ptr<COFFFormat> CreateWriter(format_type type);
 
        using LinkerManager::SetLinkScript;
 
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        enum
        {
            FLAG_NO_RELOCATIONS = 0x0001,
            FLAG_EXECUTABLE = 0x0002,
            FLAG_NO_LINE_NUMBERS = 0x0004,
            FLAG_NO_SYMBOLS = 0x0008,
            FLAG_32BIT_LITTLE_ENDIAN = 0x0100,
            FLAG_32BIT_BIG_ENDIAN = 0x0200,
 
            ZMAGIC = 0x010B,
        };
 
        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);
 
        std::shared_ptr<Linker::Segment> GetSegment(std::unique_ptr<Section>& section);
 
        std::shared_ptr<Linker::Segment> GetCodeSegment();
 
        std::shared_ptr<Linker::Segment> GetDataSegment();
 
        std::shared_ptr<Linker::Segment> GetBssSegment();
 
        void ProcessModule(Linker::Module& module) override;
 
        void CalculateValues() override;
 
        void GenerateFile(std::string filename, Linker::Module& module) override;
 
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) override;
    };
 
}
 
#endif /* COFF_H */