coff.h

#ifndef COFF_H
#define COFF_H
 
#include <map>
#include "cpm68k.h"
#include "mzexe.h"
#include "../common.h"
#include "../linker/module.h"
#include "../linker/options.h"
#include "../linker/segment.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
 
namespace COFF
{
    class COFFFormat : public virtual Linker::InputFormat, public virtual Linker::SegmentManager
    {
    public:
        /* * * General members * * */
 
        enum cpu
        {
            CPU_UNKNOWN = 0,
 
 
            CPU_I386  = 0x014C,
 
            CPU_M68K  = 0x0150,
 
 
            CPU_W65   = 0x6500,
 
            CPU_Z80   = 0x805A,
 
            CPU_Z8K   = 0x8000,
 
 
            CPU_I86   = 0x0148,
 
            CPU_NS32K = 0x0154,
 
            CPU_I370  = 0x0158,
 
            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,
 
 
            CPU_C5400 = 0x0098,
            CPU_C6000 = 0x0099,
            CPU_C5500 = 0x009C,
            CPU_MSP430 = 0x00A0,
 
 
            CPU_I860  = 0x014D,
 
            CPU_SH    = 0x01A2,
 
            CPU_ARM   = 0x01C0,
 
            CPU_AM33  = 0x01D3,
 
            CPU_IA64  = 0x0200,
 
            CPU_HPPA  = 0x0290,
 
            CPU_EFI   = 0x0EBC,
 
            CPU_RISCV32 = 0x5032,
 
            CPU_RISCV64 = 0x5064,
 
            CPU_RISCV128 = 0x5128,
 
            CPU_AMD64 = 0x8664,
 
            CPU_M32R  = 0x9041,
 
            CPU_ARM64 = 0xAA64,
 
            // for now, there are no overloaded values
        };
 
        enum COFFVariantType
        {
            COFF = 1,
            ECOFF = 2,
            XCOFF32 = 3,
            XCOFF64 = 4,
            PECOFF = 5,
            TICOFF = 6,
            TICOFF1 = 7,
        };
 
        static constexpr COFFVariantType AnyCOFFVariant = COFFVariantType(0);
 
        struct MachineType
        {
            cpu actual_cpu;
            ::EndianType endian;
            COFFVariantType coff_variant = AnyCOFFVariant;
        };
 
        static const std::map<uint32_t, MachineType> MACHINE_TYPES;
 
        offset_t file_size;
 
        char signature[2] = { };
 
        ::EndianType GetEndianType() const;
 
        class Relocation
        {
        public:
            virtual ~Relocation();
            virtual offset_t GetAddress() const = 0;
            virtual size_t GetSize() const = 0;
            virtual size_t GetEntrySize() const = 0;
            virtual void WriteFile(Linker::Writer& wr) const = 0;
            virtual void FillEntry(Dumper::Entry& entry) const = 0;
        };
 
        class UNIXRelocation : public Relocation
        {
        public:
            static constexpr uint16_t R_ABS = 0;
            static constexpr uint16_t R_DIR16 = 1;
            static constexpr uint16_t R_REL16 = 2;
            static constexpr uint16_t R_DIR32 = 6;
            static constexpr uint16_t R_DIR32NB = 7;
            static constexpr uint16_t R_SEG12 = 9;
            static constexpr uint16_t R_SECTION = 10;
            static constexpr uint16_t R_SECREL = 11;
            static constexpr uint16_t R_TOKEN = 12;
            static constexpr uint16_t R_SECREL7 = 13;
            static constexpr uint16_t R_REL32 = 20;
 
            COFFVariantType coff_variant;
            cpu cpu_type;
 
            offset_t address = 0;
            uint32_t symbol_index = 0;
            uint16_t type = 0;
            uint32_t information = 0;
 
            UNIXRelocation(COFFVariantType coff_variant, cpu cpu_type)
                : coff_variant(coff_variant), cpu_type(cpu_type)
            {
            }
 
            void Read(Linker::Reader& rd);
 
            offset_t GetAddress() const override;
 
            size_t GetSize() const override;
 
            size_t GetEntrySize() const override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            void FillEntry(Dumper::Entry& entry) const override;
        };
 
        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 constexpr uint16_t R_Z80_IMM8  = 0x22;
            static constexpr uint16_t R_Z80_IMM16 = 0x01;
            static constexpr uint16_t R_Z80_IMM24 = 0x33;
            static constexpr uint16_t R_Z80_IMM32 = 0x17;
            static constexpr uint16_t R_Z80_OFF8  = 0x32;
            static constexpr uint16_t R_Z80_JR    = 0x02;
 
            static constexpr uint16_t R_Z8K_IMM4L = 0x23;
            static constexpr uint16_t R_Z8K_IMM4H = 0x24;
            static constexpr uint16_t R_Z8K_DISP7 = 0x25; /* djnz */
            static constexpr uint16_t R_Z8K_IMM8  = 0x22;
            static constexpr uint16_t R_Z8K_IMM16 = 0x01;
            static constexpr uint16_t R_Z8K_REL16 = 0x04;
            static constexpr uint16_t R_Z8K_IMM32 = 0x11;
            static constexpr uint16_t R_Z8K_JR    = 0x02; /* jr */
            static constexpr uint16_t R_Z8K_CALLR = 0x05; /* callr */
 
            static constexpr uint16_t R_W65_ABS8     = 0x01;
            static constexpr uint16_t R_W65_ABS16    = 0x02;
            static constexpr uint16_t R_W65_ABS24    = 0x03;
            static constexpr uint16_t R_W65_ABS8S8   = 0x04;
            static constexpr uint16_t R_W65_ABS8S16  = 0x05;
            static constexpr uint16_t R_W65_ABS16S8  = 0x06;
            static constexpr uint16_t R_W65_ABS16S16 = 0x07;
            static constexpr uint16_t R_W65_PCR8     = 0x08;
            static constexpr uint16_t R_W65_PCR16    = 0x09;
            static constexpr 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& rd);
 
            offset_t GetAddress() const override;
 
            size_t GetSize() const override;
 
            size_t GetEntrySize() const override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            void FillEntry(Dumper::Entry& entry) const 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;
            offset_t physical_address = 0;
            offset_t address = 0;
            offset_t size = 0;
            offset_t section_pointer = 0;
            offset_t relocation_pointer = 0;
            offset_t line_number_pointer = 0;
            uint32_t relocation_count = 0;
            uint32_t line_number_count = 0;
            uint32_t flags = 0;
            uint16_t memory_page_number = 0;
 
            std::shared_ptr<Linker::Image> 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::Image> image = nullptr)
                : flags(flags), image(image)
            {
            }
 
            ~Section()
            {
                Clear();
            }
 
            void ReadSectionHeader(Linker::Reader& rd, COFFVariantType coff_variant);
 
            void WriteSectionHeader(Linker::Writer& wr, COFFVariantType coff_variant);
 
            uint32_t ImageSize() const;
        };
 
        std::vector<std::unique_ptr<Section>> sections;
 
        uint16_t section_count = 0;
        uint32_t timestamp = 0;
        offset_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;
        uint16_t target = 0;
 
        class OptionalHeader
        {
        public:
            virtual ~OptionalHeader();
            virtual uint32_t GetSize() const = 0;
            virtual void ReadFile(Linker::Reader& rd) = 0;
            virtual void WriteFile(Linker::Writer& wr) const = 0;
            virtual offset_t CalculateValues(COFFFormat& coff) = 0;
            virtual void PostReadFile(COFFFormat& coff, Linker::Reader& rd);
            virtual void PostWriteFile(const COFFFormat& coff, Linker::Writer& wr) const;
 
            virtual void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const;
        };
 
        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() const override;
 
            void ReadFile(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            offset_t CalculateValues(COFFFormat& coff) override;
 
            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const 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() const override;
 
            void ReadFile(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            offset_t CalculateValues(COFFFormat& coff) override;
 
        protected:
            virtual void DumpFields(const COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) const;
 
        public:
            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const 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() const override;
 
            void ReadFile(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            offset_t CalculateValues(COFFFormat& coff) override;
 
            void PostReadFile(COFFFormat& coff, Linker::Reader& rd) override;
 
            void PostWriteFile(const COFFFormat& coff, Linker::Writer& wr) const override;
 
        protected:
            void DumpFields(const COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) const 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() const override;
 
            void ReadFile(Linker::Reader& wr) override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            offset_t CalculateValues(COFFFormat& coff) override;
 
            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const 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;
 
            MIPSAOutHeader(uint16_t magic = 0)
                : AOutHeader(magic)
            {
            }
 
            uint32_t GetSize() const override;
 
            void ReadFile(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            offset_t CalculateValues(COFFFormat& coff) override;
 
        protected:
            void DumpFields(const COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) const override;
        };
 
        class ECOFFAOutHeader : public OptionalHeader
        {
        public:
            static constexpr uint16_t OMAGIC = 0x0107;
            static constexpr uint16_t NMAGIC = 0x0108;
            static constexpr uint16_t ZMAGIC = 0x010B;
            uint16_t magic = 0;
            static constexpr uint16_t SYM_STAMP = 0x030D;
            uint16_t version_stamp = SYM_STAMP;
            uint16_t build_revision = 0;
 
            uint64_t code_size = 0;
            uint64_t data_size = 0;
            uint64_t bss_size = 0;
            uint64_t entry_address = 0;
            uint64_t code_address = 0;
            uint64_t data_address = 0;
            uint64_t bss_address = 0;
            uint32_t gpr_mask = 0;
            uint32_t fpr_mask = 0;
            uint64_t global_pointer = 0;
 
            ECOFFAOutHeader(uint16_t magic = 0)
                : magic(magic)
            {
            }
 
            uint32_t GetSize() const override;
 
            void ReadFile(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            offset_t CalculateValues(COFFFormat& coff) override;
 
            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const override;
        };
 
        class XCOFFAOutHeader : public OptionalHeader
        {
        public:
            bool is64 = false;
            uint16_t magic = 0;
            uint16_t version_stamp = 0;
            uint64_t code_size = 0;
            uint64_t data_size = 0;
            uint64_t bss_size = 0;
            uint64_t entry_address = 0;
            uint64_t code_address = 0;
            uint64_t data_address = 0;
            uint64_t toc_address = 0;
            uint16_t entry_section = 0;
            uint16_t code_section = 0;
            uint16_t data_section = 0;
            uint16_t toc_section = 0;
            uint16_t loader_section = 0;
            uint16_t bss_section = 0;
            uint16_t code_align = 0;
            uint16_t data_align = 0;
            uint16_t module_type = 0;
            uint8_t cpu_flags = 0;
            uint8_t cpu_type = 0;
            uint64_t maximum_stack_size = 0;
            uint64_t maximum_data_size = 0;
            uint32_t debugger_data = 0;
            uint8_t code_page_size = 0;
            uint8_t text_page_size = 0;
            uint8_t stack_page_size = 0;
            uint8_t flags = 0;
            uint16_t tdata_section = 0;
            uint16_t tbss_section = 0;
            uint32_t xcoff64_flags = 0;
#if 0
            uint8_t shared_memory_page = 0;
#endif
 
            XCOFFAOutHeader(bool is64, uint16_t magic = 0)
                : is64(is64), magic(magic)
            {
            }
 
            uint32_t GetSize() const override;
 
            void ReadFile(Linker::Reader& rd) override;
 
            void WriteFile(Linker::Writer& wr) const override;
 
            offset_t CalculateValues(COFFFormat& coff) override;
 
            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const override;
        };
 
        void Clear() override;
 
        void AssignMagicValue();
 
        COFFVariantType coff_variant = AnyCOFFVariant;
 
        cpu cpu_type = CPU_UNKNOWN;
 
        ::EndianType endiantype = ::UndefinedEndian;
 
        bool DetectCpuType(::EndianType expected);
 
        void DetectCpuType();
 
        void ReadFile(Linker::Reader& rd) override;
 
    protected:
        void ReadCOFFHeader(Linker::Reader& rd);
        void ReadOptionalHeader(Linker::Reader& rd);
        void ReadRestOfFile(Linker::Reader& rd);
 
    public:
        offset_t ImageSize() const override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
 
    protected:
        offset_t WriteFileContents(Linker::Writer& wr) const;
 
    public:
        void Dump(Dumper::Dumper& dump) const 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,
        };
 
    public:
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
 
        /* * * Writer members * * */
 
        class COFFOptionCollector : public Linker::OptionCollector
        {
        public:
            Linker::Option<std::string> stub{"stub", "Filename for stub that gets prepended to executable"};
 
            COFFOptionCollector()
            {
                InitializeFields(stub);
            }
        };
 
        // for DJGPP binaries
        mutable Microsoft::MZSimpleStubWriter stub;
 
        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, COFFVariantType coff_variant = COFF, EndianType endiantype = ::UndefinedEndian)
            : coff_variant(coff_variant), endiantype(endiantype), type(type)
        {
        }
 
        ~COFFFormat()
        {
            Clear();
        }
 
        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;
 
        enum
        {
            FLAG_NO_RELOCATIONS = 0x0001,
            FLAG_EXECUTABLE = 0x0002,
            FLAG_NO_LINE_NUMBERS = 0x0004,
            FLAG_NO_SYMBOLS = 0x0008,
            FLAG_PDP11_ENDIAN = 0x0080,
            FLAG_32BIT_LITTLE_ENDIAN = 0x0100,
            FLAG_32BIT_BIG_ENDIAN = 0x0200,
 
            OMAGIC = 0x0107,
            NMAGIC = 0x0108,
            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;
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;
    };
 
}
 
#endif /* COFF_H */