omf.h

#ifndef OMF_H
#define OMF_H
 
#include <array>
#include <variant>
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/format.h"
#include "../linker/reader.h"
#include "../linker/symbol_definition.h"
#include "../linker/target.h"
#include "../linker/writer.h"
 
/* TODO: incomplete */
 
/* Intel Object Module format (input only) */
 
namespace OMF
{
    class ChecksumWriter : public Linker::Writer
    {
    public:
        std::shared_ptr<Linker::Writer> wr;
        uint8_t checksum = 0;
 
        ChecksumWriter(const std::shared_ptr<Linker::Writer>& wr)
            : Linker::Writer(::LittleEndian), wr(wr)
        {
        }
 
        using Linker::Writer::WriteData;
        void WriteData(size_t count, const void * data) override;
        void Seek(offset_t offset) override;
        void Skip(relative_offset_t offset) override;
        void SeekEnd(relative_offset_t offset = 0) override;
        offset_t Tell() override;
    };
 
    class OMFFormat : public virtual Linker::Format
    {
    public:
        virtual ~OMFFormat() = default;
 
        static std::string ReadString(const std::shared_ptr<Linker::Reader>& rd, size_t max_bytes = size_t(-1));
 
        static void WriteString(const std::shared_ptr<ChecksumWriter>& wr, std::string text);
 
        typedef uint16_t index_t;
 
        static index_t ReadIndex(const std::shared_ptr<Linker::Reader>& rd);
 
        static void WriteIndex(const std::shared_ptr<ChecksumWriter>& wr, index_t index);
 
        static size_t IndexSize(index_t index);
 
        template <typename RecordTypeByte, typename FormatType, typename ModuleType>
            class Record
        {
        public:
            offset_t record_offset;
            uint16_t record_length;
            RecordTypeByte record_type;
 
            Record(RecordTypeByte record_type = RecordTypeByte(0))
                : record_type(record_type)
            {
            }
 
            virtual ~Record() = default;
 
            offset_t RecordEnd() const
            {
                return record_offset + record_length + 2;
            }
 
            virtual void ReadRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Reader>& rd) = 0;
 
            virtual uint16_t GetRecordSize(FormatType * omf, ModuleType * mod) const = 0;
 
            virtual void WriteRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<ChecksumWriter>& wr) const = 0;
 
            virtual void WriteRecord(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Writer>& wr) const
            {
                auto ckswr = std::make_shared<ChecksumWriter>(wr);
                ckswr->WriteWord(1, record_type);
                ckswr->WriteWord(2, GetRecordSize(omf, mod));
                WriteRecordContents(omf, mod, ckswr);
                wr->WriteWord(1, ckswr->checksum);
            }
 
            virtual void CalculateValues(FormatType * omf, ModuleType * mod)
            {
                record_offset = omf->file_size;
                record_length = GetRecordSize(omf, mod);
                record_offset += record_length;
            }
 
            virtual void ResolveReferences(FormatType * omf, ModuleType * mod)
            {
            }
 
            virtual void DumpAddFields(Dumper::Dumper& dump, Dumper::Region& region, const FormatType * omf, const ModuleType * mod, size_t record_index, Dumper::display_option& options) const
            {
            }
 
            virtual void Dump(Dumper::Dumper& dump, const FormatType * omf, const ModuleType * mod, size_t record_index) const
            {
                Dumper::Region record_region("Record", record_offset, RecordEnd() + 1 - record_offset, 8);
                record_region.InsertField(0, "Index", Dumper::DecDisplay::Make(), offset_t(record_index + 1));
                record_region.AddField("Record type", Dumper::HexDisplay::Make(2), offset_t(record_type));
                Dumper::display_option options = Dumper::Control;
                FormatType::DumpAddFields(this, dump, record_region, omf, mod, record_index, options);
                DumpAddFields(dump, record_region, omf, mod, record_index, options);
                record_region.Display(dump, options);
            }
 
            bool Is32Bit(FormatType * omf) const
            {
                return (record_type & 1) != 0;
            }
 
            size_t GetOffsetSize(FormatType * omf) const
            {
                return Is32Bit(omf) ? 4 : 2;
            }
        };
 
        template <typename RecordTypeByte, typename FormatType, typename ModuleType>
            class UnknownRecord : public Record<RecordTypeByte, FormatType, ModuleType>
        {
        public:
            std::vector<uint8_t> data;
 
            UnknownRecord(RecordTypeByte record_type = RecordTypeByte(0))
                : Record<RecordTypeByte, FormatType, ModuleType>(record_type)
            {
            }
 
            void ReadRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Reader>& rd) override
            {
                data.resize(Record<RecordTypeByte, FormatType, ModuleType>::record_length - 1);
                rd->ReadData(data);
            }
 
            uint16_t GetRecordSize(FormatType * omf, ModuleType * mod) const override
            {
                return data.size() + 1;
            }
 
            void WriteRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<ChecksumWriter>& wr) const override
            {
                wr->WriteData(data);
            }
        };
 
        template <typename RecordTypeByte, typename FormatType, typename ModuleType>
            class EmptyRecord : public Record<RecordTypeByte, FormatType, ModuleType>
        {
        public:
            EmptyRecord(RecordTypeByte record_type = RecordTypeByte(0))
                : Record<RecordTypeByte, FormatType, ModuleType>(record_type)
            {
            }
 
            void ReadRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Reader>& rd) override
            {
            }
 
            uint16_t GetRecordSize(FormatType * omf, ModuleType * mod) const override
            {
                return 1;
            }
 
            void WriteRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<ChecksumWriter>& wr) const override
            {
            }
        };
 
        template <typename RecordTypeByte, typename FormatType, typename ModuleType>
            class ContentRecord : public Record<RecordTypeByte, FormatType, ModuleType>
        {
        public:
            uint8_t segment_id = 0;
            uint16_t offset = 0;
            std::vector<uint8_t> data;
 
            ContentRecord(RecordTypeByte record_type = RecordTypeByte(0))
                : Record<RecordTypeByte, FormatType, ModuleType>(record_type)
            {
            }
 
            void ReadRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(FormatType * omf, ModuleType * mod) const override;
            void WriteRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        template <typename RecordTypeByte, typename FormatType, typename ModuleType>
            class LineNumbersRecord : public Record<RecordTypeByte, FormatType, ModuleType>
        {
        public:
            class LineNumber
            {
            public:
                uint16_t line_number = 0;
                uint16_t offset = 0;
 
                static LineNumber Read(FormatType * omf, const std::shared_ptr<Linker::Reader>& rd);
                void Write(FormatType * omf, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            uint8_t segment_id = 0;
            std::vector<LineNumber> line_numbers;
 
            LineNumbersRecord(RecordTypeByte record_type = RecordTypeByte(0))
                : Record<RecordTypeByte, FormatType, ModuleType>(record_type)
            {
            }
 
            void ReadRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(FormatType * omf, ModuleType * mod) const override;
            void WriteRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        template <typename RecordTypeByte, typename FormatType, typename ModuleType>
            class LibraryHeaderRecord : public Record<RecordTypeByte, FormatType, ModuleType>
        {
        public:
            uint16_t module_count;
            uint16_t block_number;
            uint16_t byte_number;
 
            LibraryHeaderRecord(RecordTypeByte record_type = RecordTypeByte(0))
                : Record<RecordTypeByte, FormatType, ModuleType>(record_type)
            {
            }
 
            void ReadRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(FormatType * omf, ModuleType * mod) const override;
            void WriteRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        template <typename RecordTypeByte, typename FormatType, typename ModuleType>
            class LibraryModuleNamesRecord : public Record<RecordTypeByte, FormatType, ModuleType>
        {
        public:
            std::vector<std::string> names;
 
            LibraryModuleNamesRecord(RecordTypeByte record_type = RecordTypeByte(0))
                : Record<RecordTypeByte, FormatType, ModuleType>(record_type)
            {
            }
 
            void ReadRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(FormatType * omf, ModuleType * mod) const override;
            void WriteRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        template <typename RecordTypeByte, typename FormatType, typename ModuleType>
            class LibraryModuleLocationsRecord : public Record<RecordTypeByte, FormatType, ModuleType>
        {
        public:
            struct Location
            {
            public:
                uint16_t block_number;
                uint16_t byte_number;
 
                static Location Read(const std::shared_ptr<Linker::Reader>& rd);
                void Write(const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            std::vector<Location> locations;
 
            LibraryModuleLocationsRecord(RecordTypeByte record_type = RecordTypeByte(0))
                : Record<RecordTypeByte, FormatType, ModuleType>(record_type)
            {
            }
 
            void ReadRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(FormatType * omf, ModuleType * mod) const override;
            void WriteRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        template <typename RecordTypeByte, typename FormatType, typename ModuleType>
            class LibraryDictionaryRecord : public Record<RecordTypeByte, FormatType, ModuleType>
        {
        public:
            class Group
            {
            public:
                std::vector<std::string> names;
 
                void Read(const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size() const;
                void Write(const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            std::vector<Group> groups;
 
            LibraryDictionaryRecord(RecordTypeByte record_type = RecordTypeByte(0))
                : Record<RecordTypeByte, FormatType, ModuleType>(record_type)
            {
            }
 
            void ReadRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(FormatType * omf, ModuleType * mod) const override;
            void WriteRecordContents(FormatType * omf, ModuleType * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        static std::shared_ptr<OMFFormat> ReadOMFFile(const std::shared_ptr<Linker::Reader>& rd);
 
        offset_t file_size = 0;
    };
 
    class OMF86Format : public virtual OMFFormat, public virtual Linker::InputFormat
    {
    public:
        class Module;
        class SegmentDefinitionRecord;
        class GroupDefinitionRecord;
 
        /* * * General members * * */
 
        ::EndianType endian_type = ::LittleEndian;
 
        enum omf_version_t
        {
            OMF_VERSION_INTEL_40 = 1,
            OMF_VERSION_PHARLAP,
            OMF_VERSION_MICROSOFT,
            OMF_VERSION_IBM,
            OMF_VERSION_TIS_11,
        };
 
        omf_version_t omf_version;
 
        OMF86Format(omf_version_t omf_version = OMF_VERSION_MICROSOFT)
            : omf_version(omf_version)
        {
        }
 
        static constexpr unsigned int FlagIntel = 0x10;
        static constexpr unsigned int FlagPharLap = 0x20;
        static constexpr unsigned int FlagTIS = 0x30;
 
        enum
        {
            MethodSegment = 0,
            MethodGroup = 1,
            MethodExternal = 2,
            MethodFrame = 3,
            MethodSource = 4,
            MethodTarget = 5,
            MethodAbsolute = 6,
        };
 
        typedef uint16_t FrameNumber;
 
        struct UsesSource { };
 
        struct UsesTarget { };
 
        struct UsesAbsolute { };
 
        class NameIndex
        {
        public:
            index_t index;
            std::string text;
 
            NameIndex(index_t index = 0)
                : index(index)
            {
            }
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class SegmentIndex
        {
        public:
            index_t index;
            std::shared_ptr<SegmentDefinitionRecord> record;
 
            SegmentIndex(index_t index = 0)
                : index(index)
            {
            }
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class GroupIndex
        {
        public:
            index_t index;
            std::shared_ptr<GroupDefinitionRecord> record;
 
            GroupIndex(index_t index = 0)
                : index(index)
            {
            }
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class TypeDefinitionRecord;
        class BlockDefinitionRecord;
        class OverlayDefinitionRecord;
 
        class TypeIndex
        {
        public:
            index_t index;
            std::shared_ptr<TypeDefinitionRecord> record;
 
            TypeIndex(index_t index = 0)
                : index(index)
            {
            }
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class BlockIndex
        {
        public:
            index_t index;
            std::shared_ptr<BlockDefinitionRecord> record;
 
            BlockIndex(index_t index = 0)
                : index(index)
            {
            }
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class OverlayIndex
        {
        public:
            index_t index;
            std::shared_ptr<OverlayDefinitionRecord> record;
 
            OverlayIndex(index_t index = 0)
                : index(index)
            {
            }
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class ExternalName
        {
        public:
            enum common_type_t : uint8_t
            {
                External,
 
                SegmentIndexCommon,
 
                FarCommon = 0x61,
 
                NearCommon = 0x62,
            };
 
            bool local = false;
            bool name_is_index = false;
            NameIndex name;
            TypeIndex type;
            common_type_t common_type = External;
 
            union
            {
                uint8_t segment_index;
                struct
                {
                    uint32_t length;
                } near;
                struct
                {
                    uint32_t number;
                    uint32_t element_size;
                } far;
            } value;
 
            ExternalName()
            {
                value.far.number = value.far.element_size = 0;
            }
 
            static uint32_t ReadValue(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd);
            static uint32_t ValueSize(OMF86Format * omf, uint32_t length);
            static void WriteValue(OMF86Format * omf, const std::shared_ptr<ChecksumWriter>& wr, uint32_t length);
 
            static ExternalName ReadExternalName(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd, bool local);
            static ExternalName ReadCommonName(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd, bool local);
            static ExternalName ReadComdatExternalName(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd);
 
            uint16_t GetExternalNameSize(OMF86Format * omf) const;
            void WriteExternalName(OMF86Format * omf, const std::shared_ptr<ChecksumWriter>& wr) const;
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class ExternalIndex
        {
        public:
            index_t index;
            ExternalName name;
 
            ExternalIndex(index_t index = 0)
                : index(index)
            {
            }
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class BaseSpecification
        {
        public:
            struct Location
            {
                GroupIndex group;
                SegmentIndex segment;
            };
 
            std::variant<Location, FrameNumber> location;
 
            void Read(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd);
            uint16_t Size(OMF86Format * omf) const;
            void Write(OMF86Format * omf, const std::shared_ptr<ChecksumWriter>& wr) const;
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class SymbolDefinition
        {
        public:
            bool local;
            std::string name;
            uint32_t offset;
            TypeIndex type;
 
            static SymbolDefinition Read(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd, bool local, bool is32bit);
            uint16_t Size(OMF86Format * omf, bool is32bit) const;
            void Write(OMF86Format * omf, const std::shared_ptr<ChecksumWriter>& wr, bool is32bit) const;
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class LineNumber
        {
        public:
            uint16_t number;
            uint32_t offset;
 
            static LineNumber Read(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd, bool is32bit);
            void Write(OMF86Format * omf, const std::shared_ptr<ChecksumWriter>& wr, bool is32bit) const;
        };
 
        class DataBlock
        {
        public:
            uint16_t repeat_count;
 
            typedef std::vector<std::shared_ptr<DataBlock>> Blocks;
            typedef std::vector<uint8_t> Data;
 
            std::variant<Data, Blocks> content;
 
            static std::shared_ptr<DataBlock> ReadEnumeratedDataBlock(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd, uint16_t data_length);
            uint16_t GetEnumeratedDataBlockSize(OMF86Format * omf) const;
            void WriteEnumeratedDataBlock(OMF86Format * omf, const std::shared_ptr<ChecksumWriter>& wr) const;
 
            static std::shared_ptr<DataBlock> ReadIteratedDataBlock(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd, bool is32bit);
            uint16_t GetIteratedDataBlockSize(OMF86Format * omf, bool is32bit) const;
            void WriteIteratedDataBlock(OMF86Format * omf, const std::shared_ptr<ChecksumWriter>& wr, bool is32bit) const;
        };
 
        class Reference
        {
        public:
            typedef unsigned ThreadNumber;
 
            std::variant<ThreadNumber, SegmentIndex, GroupIndex, ExternalIndex, FrameNumber> target = ThreadNumber(0);
            std::variant<ThreadNumber, SegmentIndex, GroupIndex, ExternalIndex, FrameNumber, UsesSource, UsesTarget, UsesAbsolute> frame = ThreadNumber(0);
            uint32_t displacement;
 
            void Read(OMF86Format * omf, const std::shared_ptr<Linker::Reader>& rd, size_t displacement_size);
            uint16_t Size(OMF86Format * omf, bool is32bit) const;
            void Write(OMF86Format * omf, const std::shared_ptr<ChecksumWriter>& wr, bool is32bit) const;
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
 
            static Linker::Target GetTarget(SegmentIndex segment_index);
            static Linker::Target GetTarget(GroupIndex group_index);
            static Linker::Target GetTarget(ExternalIndex external_index);
            static Linker::Target GetTarget(FrameNumber frame_number);
 
            static Linker::Target GetFrame(Linker::Location source, Linker::Target target, SegmentIndex segment_index);
            static Linker::Target GetFrame(Linker::Location source, Linker::Target target, GroupIndex group_index);
            static Linker::Target GetFrame(Linker::Location source, Linker::Target target, ExternalIndex external_index);
            static Linker::Target GetFrame(Linker::Location source, Linker::Target target, FrameNumber frame_number);
            static Linker::Target GetFrame(Linker::Location source, Linker::Target target, UsesSource _);
            static Linker::Target GetFrame(Linker::Location source, Linker::Target target, UsesTarget _);
            static Linker::Target GetFrame(Linker::Location source, Linker::Target target, UsesAbsolute _);
        };
 
        enum record_type_t : uint8_t
        {
            RHEADR = 0x6E, // Intel 4.0
            REGINT = 0x70, // Intel 4.0
            REDATA = 0x72, // Intel 4.0
            RIDATA = 0x74, // Intel 4.0
            OVLDEF = 0x76, // Intel 4.0
            ENDREC = 0x78, // Intel 4.0
            BLKDEF = 0x7A, // Intel 4.0
            BLKEND = 0x7C, // Intel 4.0
            DEBSYM = 0x7E, // Intel 4.0
            THEADR = 0x80,
            LHEADR = 0x82,
            PEDATA = 0x84, // Intel 4.0
            PIDATA = 0x86, // Intel 4.0
            COMENT = 0x88,
            MODEND16 = 0x8A,
            MODEND = 0x8A,
            MODEND32 = 0x8B, // TIS 1.1
            EXTDEF = 0x8C,
            TYPDEF = 0x8E, // Intel 4.0
            PUBDEF16 = 0x90,
            PUBDEF = 0x90,
            PUBDEF32 = 0x91, // TIS 1.1
            LOCSYM = 0x92, // Intel 4.0
            LINNUM = 0x94, // Intel 4.0
            LNAMES = 0x96,
            SEGDEF = 0x98, // Intel 4.0
            GRPDEF = 0x9A, // Intel 4.0
            FIXUPP16 = 0x9C,
            FIXUPP = 0x9C,
            FIXUPP32 = 0x9D, // TIS 1.1
            LEDATA16 = 0xA0,
            LEDATA = 0xA0,
            LEDATA32 = 0xA1, // TIS 1.1
            LIDATA16 = 0xA2,
            LIDATA = 0xA2,
            LIDATA32 = 0xA3, // TIS 1.1
            LIBHED = 0xA4, // Intel 4.0
            LIBNAM = 0xA6, // Intel 4.0
            LIBLOC = 0xA8, // Intel 4.0
            LIBDIC = 0xAA, // Intel 4.0
            COMDEF = 0xB0, // TIS 1.1, since Microsoft LINK 3.5
            BAKPAT16 = 0xB2, // TIS 1.1, since Microsoft QuickC 1.0
            BAKPAT = 0xB2, // TIS 1.1
            BAKPAT32 = 0xB3, // TIS 1.1
            LEXTDEF16 = 0xB4, // TIS 1.1, since Microsoft C 5.0
            LEXTDEF = 0xB4, // TIS 1.1
            LEXTDEF32 = 0xB5, // TIS 1.1
            LPUBDEF16 = 0xB6, // TIS 1.1, since Microsoft C 5.0
            LPUBDEF = 0xB6, // TIS 1.1
            LPUBDEF32 = 0xB7, // TIS 1.1
            LCOMDEF = 0xB8, // TIS 1.1, since Microsoft C 5.0
            CEXTDEF = 0xBC, // TIS 1.1, since Microsoft C 7.0
            COMDAT16 = 0xC2, // TIS 1.1, since Microsoft C 7.0
            COMDAT = 0xC2, // TIS 1.1
            COMDAT32 = 0xC3, // TIS 1.1
            LINSYM16 = 0xC4, // TIS 1.1, since Microsoft C 7.0
            LINSYM = 0xC4, // TIS 1.1
            LINSYM32 = 0xC5, // TIS 1.1
            ALIAS = 0xC6, // TIS 1.1, since Microsoft LINK 5.13
            NBKPAT16 = 0xC8, // TIS 1.1, since Microsoft C 7.0
            NBKPAT = 0xC8, // TIS 1.1
            NBKPAT32 = 0xC9, // TIS 1.1
            LLNAMES = 0xCA, // TIS 1.1, since Microsoft C 7.0
            VERNUM = 0xCC, // TIS 1.1
            VENDEXT = 0xCE, // TIS 1.1
            LibraryHeader = 0xF0, // TIS 1.1
            LibraryEnd = 0xF1, // TIS 1.1
        };
 
        static const std::map<offset_t, std::string> RecordTypeNames;
 
        using Record = OMFFormat::Record<record_type_t, OMF86Format, Module>;
        using UnknownRecord = OMFFormat::UnknownRecord<record_type_t, OMF86Format, Module>;
        using EmptyRecord = OMFFormat::EmptyRecord<record_type_t, OMF86Format, Module>;
        using LibraryHeaderRecord = OMFFormat::LibraryHeaderRecord<record_type_t, OMF86Format, Module>;
        using LibraryModuleNamesRecord = OMFFormat::LibraryModuleNamesRecord<record_type_t, OMF86Format, Module>;
        using LibraryModuleLocationsRecord = OMFFormat::LibraryModuleLocationsRecord<record_type_t, OMF86Format, Module>;
        using LibraryDictionaryRecord = OMFFormat::LibraryDictionaryRecord<record_type_t, OMF86Format, Module>;
 
        std::shared_ptr<Record> ReadRecord(const std::shared_ptr<Linker::Reader>& rd);
 
        class ModuleHeaderRecord : public Record
        {
        public:
            std::string name;
 
            ModuleHeaderRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class RModuleHeaderRecord : public ModuleHeaderRecord
        {
        public:
            Module * mod;
 
            enum module_type_t : uint8_t
            {
                AbsoluteModule = 0,
                RelocatableModule = 1,
                PICModule = 2,
                LTLModule = 3,
            };
 
            module_type_t module_type;
            uint16_t segment_record_count;
            uint16_t group_record_count;
            uint16_t overlay_record_count;
            uint32_t overlay_record_offset; // TODO: resolve record index
 
            uint32_t static_size;
            uint32_t maximum_static_size;
            uint32_t dynamic_storage;
            uint32_t maximum_dynamic_storage;
 
            RModuleHeaderRecord()
                : ModuleHeaderRecord()
            {
            }
 
            RModuleHeaderRecord(record_type_t record_type = record_type_t(0))
                : ModuleHeaderRecord(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class ListOfNamesRecord : public Record
        {
        public:
            std::vector<std::string> names;
            index_t first_lname;
            uint16_t lname_count = 0;
 
            ListOfNamesRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class SegmentDefinitionRecord : public Record, public std::enable_shared_from_this<SegmentDefinitionRecord>
        {
        public:
            uint64_t segment_length;
            enum alignment_t : uint8_t
            {
                AlignAbsolute = 0,
                Align1 = 1,
                Align2 = 2,
                Align16 = 3,
                AlignPage = 4,
                AlignLTL16 = 6,
 
                Align256 = FlagIntel | AlignPage,
                Align4096 = FlagTIS | AlignPage,
                AlignUnnamed = FlagIntel | 5,
                Align4 = FlagTIS | 5,
            };
 
            alignment_t alignment;
 
            typedef uint32_t Absolute;
 
            struct Relocatable { };
 
            class LoadTimeLocatable
            {
            public:
                bool group_member;
                uint16_t maximum_segment_length;
                uint16_t group_offset;
            };
 
            std::variant<Relocatable, Absolute, LoadTimeLocatable> location = Relocatable{};
 
            enum combination_t : uint8_t
            {
                Combination_Private = 0,
                Combination_Merge_Highest = 1,
                Combination_Append = 2,
                Combination_Public = Combination_Append,
                Combination_Join_Low = 4,
                Combination_Public4 = FlagTIS | 4,
                Combination_Join_High = FlagIntel | 5,
                Combination_Stack = FlagTIS | 5,
                Combination_Merge_Low = FlagIntel | 6,
                Combination_Common = FlagTIS | 6,
                Combination_Merge_High = 7,
                Combination_Public7 = FlagTIS | 7,
            };
 
            combination_t combination;
 
            bool page_resident = false; // Intel
            bool use32 = false;
 
            NameIndex segment_name;
            NameIndex class_name;
            NameIndex overlay_name;
 
            enum access_t : uint8_t
            {
                AccessReadOnly = 0,
                AccessExecuteOnly = 1,
                AccessExecuteRead = 2,
                AccessReadWrite = 3,
            };
 
            std::optional<access_t> access;
 
            std::shared_ptr<Linker::Section> linker_section = nullptr;
 
            SegmentDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
 
            std::shared_ptr<Linker::Section> GenerateLinkerSection();
        };
 
        class GroupDefinitionRecord : public Record, public std::enable_shared_from_this<GroupDefinitionRecord>
        {
        public:
            class Component
            {
            public:
                class SegmentClassOverlayNames
                {
                public:
                    NameIndex segment_name;
                    NameIndex class_name;
                    NameIndex overlay_name;
                };
 
                class LoadTimeLocatable
                {
                public:
                    uint32_t maximum_group_length;
                    uint32_t group_length;
                };
 
                typedef uint32_t Absolute;
 
                static constexpr uint8_t Absolute_type = 0xFA;
                static constexpr uint8_t LoadTimeLocatable_type = 0xFB;
                static constexpr uint8_t SegmentClassOverlayNames_type = 0xFD;
                static constexpr uint8_t ExternalIndex_type = 0xFE;
                static constexpr uint8_t SegmentIndex_type = 0xFF;
 
                std::variant<ExternalIndex, SegmentIndex, SegmentClassOverlayNames, LoadTimeLocatable, Absolute> component = ExternalIndex();
 
                static Component Read(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF86Format * omf, Module * mod) const;
                void Write(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
 
                void CalculateValues(OMF86Format * omf, Module * mod);
                void ResolveReferences(OMF86Format * omf, Module * mod);
            };
 
            NameIndex name;
            std::vector<Component> components;
 
            GroupDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class TypeDefinitionRecord : public Record, public std::enable_shared_from_this<TypeDefinitionRecord>
        {
        public:
            class LeafDescriptor
            {
            public:
                bool nice;
 
                struct Null { };
                struct Repeat { };
 
                std::variant<uint32_t, int32_t, std::string, TypeIndex, Null, Repeat> leaf = Null();
 
                static constexpr uint8_t NullLeaf = 0x80;
                static constexpr uint8_t StringLeaf = 0x82;
                static constexpr uint8_t IndexLeaf = 0x83;
                static constexpr uint8_t RepeatLeaf = 0x85;
                static constexpr uint8_t NumericLeaf16 = 0x81;
                static constexpr uint8_t NumericLeaf24 = 0x84;
                static constexpr uint8_t SignedNumericLeaf8 = 0x86;
                static constexpr uint8_t SignedNumericLeaf16 = 0x87;
                static constexpr uint8_t SignedNumericLeaf32 = 0x88;
 
                static LeafDescriptor Read(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF86Format * omf, Module * mod) const;
                void Write(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
 
                void CalculateValues(OMF86Format * omf, Module * mod);
                void ResolveReferences(OMF86Format * omf, Module * mod);
            };
 
            std::string name;
            std::vector<LeafDescriptor> leafs;
 
            enum
            {
                Far = 0x61, // Far(Array(...)) - Microsoft
                Near = 0x62, // Near(Array | Structure | Scalar, length in bits) - Microsoft
                Interrupt = 0x63,
                File = 0x64,
                Packed = 0x65,
                Unpacked = 0x66,
                Set = 0x67,
                Chameleon = 0x69,
                Boolean = 0x6A,
                True = 0x6B,
                False = 0x6C,
                Char = 0x6D,
                Integer = 0x6E,
                Const = 0x6F,
                Label = 0x71, // Label(nil, Short | Long)
                Long = 0x72,
                Short = 0x73,
                Procedure = 0x74, // Procedure(nil, @type, Short | Long, parameter count, @List(...))
                Parameter = 0x75, // Parameter(@type)
                Dimension = 0x76,
                Array = 0x77, // Array(length, @type)
                Structure = 0x79, // Structure(length, component count, @List(...))
                Pointer = 0x7A,
                Scalar = 0x7B, // Scalar(length, UnsignedInteger | SignedInteger | Real | @Pointer)
                UnsignedInteger = 0x7C,
                SignedInteger = 0x7D,
                Real = 0x7E,
                List = 0x7F, // List(...)
            };
 
            TypeDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class SymbolsDefinitionRecord : public Record
        {
        public:
            BaseSpecification base;
 
            std::vector<SymbolDefinition> symbols;
 
            SymbolsDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class ExternalNamesDefinitionRecord : public Record
        {
        public:
            ExternalIndex first_extdef;
            uint16_t extdef_count = 0;
 
            ExternalNamesDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class LineNumbersRecord : public Record
        {
        public:
            BaseSpecification base;
 
            std::vector<LineNumber> lines;
 
            LineNumbersRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class BlockDefinitionRecord : public Record, public std::enable_shared_from_this<BlockDefinitionRecord>
        {
        public:
            BaseSpecification base;
            std::string name;
            uint16_t offset;
            uint16_t length;
            enum block_type_t : uint8_t
            {
                NotProcedure = 0x00,
                NearProcedure = 0x80,
                FarProcedure = 0xC0,
            };
            block_type_t procedure;
            uint16_t return_address_offset; // only for procedures
            TypeIndex type;
 
            BlockDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class DebugSymbolsRecord : public Record
        {
        public:
            enum frame_type_t : uint8_t
            {
                Location = 0x00,
                Frame16 = 0x80,
                Frame32 = 0xC0,
            };
            frame_type_t frame_type;
 
            static constexpr uint8_t SymbolBaseMethod = 0x00;
            static constexpr uint8_t ExternalMethod = 0x01;
            static constexpr uint8_t BlockMethod = 0x02;
 
            std::variant<BaseSpecification, ExternalIndex, BlockIndex> base = ExternalIndex();
 
            std::vector<SymbolDefinition> names;
 
            DebugSymbolsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class RelocatableDataRecord : public Record
        {
        public:
            BaseSpecification base;
            uint16_t offset;
            std::shared_ptr<DataBlock> data;
 
            RelocatableDataRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class PhysicalDataRecord : public Record
        {
        public:
            uint32_t address;
            std::shared_ptr<DataBlock> data;
 
            PhysicalDataRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class LogicalDataRecord : public Record
        {
        public:
            SegmentIndex segment;
            uint32_t offset;
            std::shared_ptr<DataBlock> data;
 
            LogicalDataRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class FixupRecord : public Record
        {
        public:
            typedef std::variant<SegmentIndex, GroupIndex, ExternalIndex, FrameNumber> target_reference_type;
            typedef std::variant<SegmentIndex, GroupIndex, ExternalIndex, FrameNumber, UsesSource, UsesTarget, UsesAbsolute> frame_reference_type;
 
            class Thread
            {
            public:
                unsigned thread_number;
                bool frame;
                frame_reference_type reference = FrameNumber(0);
 
                static Thread Read(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint8_t leading_data_byte);
                uint16_t Size(OMF86Format * omf, Module * mod) const;
                void Write(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
 
                void CalculateValues(OMF86Format * omf, Module * mod);
                void ResolveReferences(OMF86Format * omf, Module * mod);
            };
 
            class Fixup
            {
            public:
                bool segment_relative;
 
                enum relocation_type_t
                {
                    RelocationLowByte = 0,
                    RelocationOffset16 = 1,
                    RelocationSegment = 2,
                    RelocationPointer32 = 3,
                    RelocationHighByte = 4,
                    RelocationOffset16_LoaderResolved = FlagTIS | 5,
                    RelocationOffset32_PharLap = FlagPharLap | 5,
                    RelocationPointer48_PharLap = 6,
                    RelocationOffset32 = 9,
                    RelocationPointer48 = 11,
                    RelocationOffset32_LoaderResolved = 13,
                };
 
                relocation_type_t type;
                uint16_t offset;
                Reference ref;
 
                static Fixup Read(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint8_t leading_data_byte, bool is32bit);
                uint16_t Size(OMF86Format * omf, Module * mod, bool is32bit) const;
                void Write(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr, bool is32bit) const;
 
                void CalculateValues(OMF86Format * omf, Module * mod);
                void ResolveReferences(OMF86Format * omf, Module * mod);
            };
 
            std::vector<std::variant<Thread, Fixup>> fixup_data;
 
            FixupRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class OverlayDefinitionRecord : public Record, public std::enable_shared_from_this<OverlayDefinitionRecord>
        {
        public:
            std::string name;
            uint32_t location;
            size_t first_data_record_index;
            std::optional<OverlayIndex> shared_overlay;
            std::optional<OverlayIndex> adjacent_overlay;
 
            OverlayDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class EndRecord : public Record
        {
        public:
            enum block_type_t : uint8_t
            {
                Overlay = 0,
                Block = 1,
            };
            block_type_t block_type;
 
            EndRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class RegisterInitializationRecord : public Record
        {
        public:
            class Register
            {
            public:
                enum register_t : uint8_t
                {
                    CS_IP,
                    SS_SP,
                    DS,
                    ES,
                };
 
                class InitialValue
                {
                public:
                    BaseSpecification base;
                    uint16_t offset;
                };
                register_t reg_id;
                std::variant<Reference, InitialValue> value = Reference();
 
                static Register Read(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF86Format * omf, Module * mod) const;
                void Write(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
 
                void CalculateValues(OMF86Format * omf, Module * mod);
                void ResolveReferences(OMF86Format * omf, Module * mod);
            };
 
            std::vector<Register> registers;
 
            RegisterInitializationRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class ModuleEndRecord : public Record
        {
        public:
            bool main_module;
            std::optional<std::variant<Reference, std::tuple<uint16_t, uint16_t>>> start_address;
 
            ModuleEndRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class BackpatchRecord : public Record
        {
        public:
            class OffsetValuePair
            {
            public:
                uint32_t offset;
                uint32_t value;
            };
 
            SegmentIndex segment;
            enum location_type_t : uint8_t
            {
                Location8bit = 0,
                Location16bit = 1,
                Location32bit = 2,
                Location32bit_IBM = 9,
            };
            uint8_t type;
            std::vector<OffsetValuePair> offset_value_pairs;
 
            BackpatchRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class NamedBackpatchRecord : public Record
        {
        public:
            using OffsetValuePair = BackpatchRecord::OffsetValuePair;
            using location_type_t = BackpatchRecord::location_type_t;
 
            uint8_t type;
            NameIndex name;
            std::vector<OffsetValuePair> offset_value_pairs;
 
            NamedBackpatchRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class InitializedCommunalDataRecord : public Record
        {
        public:
            bool continued;
            bool iterated;
            bool local;
            bool code_segment;
 
            // TODO: document further
 
            enum selection_criterion_t : uint8_t
            {
                SelectNoMatch = 0x00,
                SelectPickAny = 0x10,
                SelectSameSize = 0x20,
                SelectExactMatch = 0x30,
            };
            static constexpr uint8_t SelectionCriterionMask = 0xF0;
            selection_criterion_t selection_criterion;
 
            enum allocation_type_t : uint8_t
            {
                AllocateExplicit = 0x00,
                AllocateFarCode = 0x01,
                AllocateFarData = 0x02,
                AllocateCode32 = 0x03,
                AllocateData32 = 0x04,
            };
            static constexpr uint8_t AllocationTypeMask = 0x0F;
            allocation_type_t allocation_type;
 
            SegmentDefinitionRecord::alignment_t alignment;
            static constexpr SegmentDefinitionRecord::alignment_t UseSegment = SegmentDefinitionRecord::alignment_t(0);
 
            uint32_t offset;
            TypeIndex type;
            BaseSpecification base;
            NameIndex name;
            std::shared_ptr<DataBlock> data;
 
            InitializedCommunalDataRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class SymbolLineNumbersRecord : public Record
        {
        public:
            bool continued;
            NameIndex name;
            std::vector<LineNumber> line_numbers;
 
            SymbolLineNumbersRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class AliasDefinitionRecord : public Record
        {
        public:
            class AliasDefinition
            {
            public:
                std::string alias_name;
                std::string substitute_name;
 
                static AliasDefinition Read(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF86Format * omf, Module * mod) const;
                void Write(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
            std::vector<AliasDefinition> alias_definitions;
 
            AliasDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class OMFVersionNumberRecord : public Record
        {
        public:
            std::string version;
 
            OMFVersionNumberRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class VendorExtensionRecord : public Record
        {
        public:
            uint16_t vendor_number;
            std::vector<uint8_t> extension;
 
            VendorExtensionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        // TODO: document
 
        class CommentRecord : public Record
        {
        public:
            bool no_purge;
            bool no_list;
            enum comment_class_t : uint8_t
            {
                Translator = 0x00,
                IntelCopyright = 0x01,
                LibrarySpecifier = 0x81,
                MSDOSVersion = 0x9C,
                MemoryModel = 0x9D,
                DOSSEG = 0x9E,
                DefaultLibrarySearchName = 0x9F,
                OMFExtension = 0xA0,
                NewOMFExtension = 0xA1,
                LinkPassSeparator = 0xA2,
                LIBMOD = 0xA3,
                EXESTR = 0xA4,
                INCERR = 0xA6,
                NOPAD = 0xA7,
                WKEXT = 0xA8,
                LZEXT = 0xA9,
                Comment = 0xDA,
                Compiler = 0xDB,
                Date = 0xDC,
                TimeStamp = 0xDD,
                User = 0xDF,
                DependencyFile = 0xE9,
                CommandLine = 0xFF,
            };
            comment_class_t comment_class;
 
            CommentRecord()
                : Record(COMENT)
            {
            }
 
            CommentRecord(comment_class_t comment_class = comment_class_t(0))
                : Record(COMENT), comment_class(comment_class)
            {
            }
 
            virtual void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) = 0;
            virtual uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const = 0;
            virtual void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const = 0;
 
            static std::shared_ptr<CommentRecord> ReadCommentRecord(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t record_length);
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            class GenericCommentRecord;
            class EmptyCommentRecord;
            class TextCommentRecord;
        };
 
        class NoSegmentPaddingRecord : public CommentRecord
        {
        public:
            std::vector<SegmentIndex> segments;
 
            NoSegmentPaddingRecord()
                : CommentRecord(NOPAD)
            {
            }
 
            void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
            void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class ExternalAssociationRecord : public CommentRecord
        {
        public:
            class ExternalAssociation
            {
            public:
                ExternalIndex definition;
                ExternalIndex default_resolution;
 
                static ExternalAssociation Read(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF86Format * omf, Module * mod) const;
                void Write(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
 
                void CalculateValues(OMF86Format * omf, Module * mod);
                void ResolveReferences(OMF86Format * omf, Module * mod);
            };
 
            std::vector<ExternalAssociation> associations;
 
            ExternalAssociationRecord(comment_class_t comment_class = comment_class_t(0))
                : CommentRecord(comment_class)
            {
            }
 
            void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
            void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class OMFExtensionRecord : public CommentRecord
        {
        public:
            enum extension_type_t : uint8_t
            {
                IMPDEF = 0x01,
                EXPDEF = 0x02,
                INCDEF = 0x03,
                ProtectedModeLibrary = 0x04,
                LNKDIR = 0x05,
                BigEndian = 0x06,
                PRECOMP = 0x07,
            };
            extension_type_t subtype;
 
            OMFExtensionRecord(extension_type_t subtype = extension_type_t(0))
                : CommentRecord(OMFExtension), subtype(subtype)
            {
            }
 
            class GenericOMFExtensionRecord;
            class EmptyOMFExtensionRecord;
        };
 
        class ImportDefinitionRecord : public OMFExtensionRecord
        {
        public:
            std::string internal_name;
            std::string module_name;
            std::variant<std::string, uint16_t> entry_ident;
 
            ImportDefinitionRecord()
                : OMFExtensionRecord(IMPDEF)
            {
            }
 
            void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
            void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class ExportDefinitionRecord : public OMFExtensionRecord
        {
        public:
            bool resident_name;
            bool no_data;
            uint8_t parameter_count;
            std::string exported_name;
            std::string internal_name;
            std::optional<uint16_t> ordinal;
 
            ExportDefinitionRecord()
                : OMFExtensionRecord(EXPDEF)
            {
            }
 
            void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
            void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class IncrementalCompilationRecord : public OMFExtensionRecord
        {
        public:
            uint16_t extdef_delta;
            uint16_t linnum_delta;
            uint16_t padding_byte_count;
 
            IncrementalCompilationRecord()
                : OMFExtensionRecord(INCDEF)
            {
            }
 
            void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
            void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class LinkerDirectivesRecord : public OMFExtensionRecord
        {
        public:
            bool new_executable;
            bool omit_codeview_publics;
            bool run_mpc;
            uint8_t pseudocode_version;
            uint8_t codeview_version;
 
            static constexpr uint8_t FlagNewExecutable = 0x01;
            static constexpr uint8_t FlagOmitCodeViewPublics = 0x02;
            static constexpr uint8_t FlagRunMPC = 0x04;
 
            LinkerDirectivesRecord()
                : OMFExtensionRecord(LNKDIR)
            {
            }
 
            void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
            void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class TISLibraryHeaderRecord : public Record
        {
        public:
            uint32_t dictionary_offset;
            uint16_t dictionary_size;
            bool case_sensitive;
 
            TISLibraryHeaderRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void WriteRecord(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Writer>& wr) const override;
        };
 
        class TISLibraryEndRecord : public Record
        {
        public:
            TISLibraryEndRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF86Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void WriteRecord(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Writer>& wr) const override;
        };
 
        class Module
        {
        public:
            size_t first_record = 0;
            size_t record_count = 0;
 
            std::vector<std::string> lnames;
            std::vector<std::shared_ptr<SegmentDefinitionRecord>> segdefs;
            std::vector<std::shared_ptr<GroupDefinitionRecord>> grpdefs;
            std::vector<std::shared_ptr<TypeDefinitionRecord>> typdefs;
            std::vector<std::shared_ptr<BlockDefinitionRecord>> blkdefs;
            std::vector<std::shared_ptr<OverlayDefinitionRecord>> ovldefs;
            std::vector<ExternalName> extdefs; // also includes comdefs and cextdefs
            // TODO: CalculateValue/etc. for ExternalName
        };
 
        std::vector<std::shared_ptr<Record>> records;
 
        std::vector<Module> modules;
 
        // TIS library fields
        uint16_t page_size;
 
        static std::shared_ptr<OMF86Format> ReadOMFFile(const std::shared_ptr<Linker::Reader>& rd);
 
        static void DumpAddFields(const Record * record, Dumper::Dumper& dump, Dumper::Region& region, const OMF86Format * omf, const Module * mod, size_t record_index, Dumper::display_option& options);
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        static uint32_t FillSectionData(std::shared_ptr<Linker::Section> section, uint32_t offset, std::shared_ptr<OMF86Format::DataBlock> data);
 
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
        /* TODO */
    };
 
    class OMF86Format::CommentRecord::GenericCommentRecord : public CommentRecord
    {
    public:
        std::vector<uint8_t> data;
 
        GenericCommentRecord(comment_class_t comment_class = comment_class_t(0))
            : CommentRecord(comment_class)
        {
        }
 
        void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
        uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
        void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
    };
 
    class OMF86Format::CommentRecord::EmptyCommentRecord : public CommentRecord
    {
    public:
        EmptyCommentRecord(comment_class_t comment_class = comment_class_t(0))
            : CommentRecord(comment_class)
        {
        }
 
        void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
        uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
        void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
    };
 
    class OMF86Format::CommentRecord::TextCommentRecord : public CommentRecord
    {
    public:
        std::string name;
 
        TextCommentRecord(comment_class_t comment_class = comment_class_t(0))
            : CommentRecord(comment_class)
        {
        }
 
        void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
        uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
        void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
    };
 
    class OMF86Format::OMFExtensionRecord::GenericOMFExtensionRecord : public OMFExtensionRecord
    {
    public:
        std::vector<uint8_t> data;
 
        GenericOMFExtensionRecord(extension_type_t extension_type = extension_type_t(0))
            : OMFExtensionRecord(extension_type)
        {
        }
 
        void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
        uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
        void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
    };
 
    class OMF86Format::OMFExtensionRecord::EmptyOMFExtensionRecord : public OMFExtensionRecord
    {
    public:
        EmptyOMFExtensionRecord(extension_type_t extension_type = extension_type_t(0))
            : OMFExtensionRecord(extension_type)
        {
        }
 
        void ReadComment(OMF86Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd, uint16_t comment_length) override;
        uint16_t GetCommentSize(OMF86Format * omf, Module * mod) const override;
        void WriteComment(OMF86Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
    };
 
    class OMF80Format : public virtual OMFFormat, public virtual Linker::InputFormat
    {
    public:
        class Module;
 
        enum record_type_t : uint8_t
        {
            ModuleHeader = 0x02,
            ModuleEnd = 0x04,
            Content = 0x06,
            LineNumbers = 0x08,
            EndOfFile = 0x0E,
            ModuleAncestor = 0x10,
            LocalSymbols = 0x12,
            PublicDefinitions = 0x16,
            ExternalDefinitions = 0x18,
            ExternalReferences = 0x20,
            Relocations = 0x22,
            InterSegmentReferences = 0x24,
            LibraryModuleLocations = 0x26,
            LibraryModuleNames = 0x28,
            LibraryDictionary = 0x2A,
            LibraryHeader = 0x2C,
            NamedCommonDefinitions = 0x2E,
        };
 
        static const std::map<offset_t, std::string> RecordTypeNames;
 
        using Record = OMFFormat::Record<record_type_t, OMF80Format, Module>;
        using UnknownRecord = OMFFormat::UnknownRecord<record_type_t, OMF80Format, Module>;
        using EmptyRecord = OMFFormat::EmptyRecord<record_type_t, OMF80Format, Module>;
        using ContentRecord = OMFFormat::ContentRecord<record_type_t, OMF80Format, Module>;
        using LineNumbersRecord = OMFFormat::LineNumbersRecord<record_type_t, OMF80Format, Module>;
        using LibraryHeaderRecord = OMFFormat::LibraryHeaderRecord<record_type_t, OMF80Format, Module>;
        using LibraryModuleNamesRecord = OMFFormat::LibraryModuleNamesRecord<record_type_t, OMF80Format, Module>;
        using LibraryModuleLocationsRecord = OMFFormat::LibraryModuleLocationsRecord<record_type_t, OMF80Format, Module>;
        using LibraryDictionaryRecord = OMFFormat::LibraryDictionaryRecord<record_type_t, OMF80Format, Module>;
 
        std::shared_ptr<Record> ReadRecord(const std::shared_ptr<Linker::Reader>& rd);
 
        typedef uint8_t segment_id_t;
 
        static constexpr segment_id_t AbsoluteSegment = 0;
        static constexpr segment_id_t CodeSegment = 1;
        static constexpr segment_id_t DataSegment = 2;
        static constexpr segment_id_t StackSegment = 3;
        static constexpr segment_id_t MemorySegment = 4;
        static constexpr segment_id_t FirstNamedCommonSegment = 6;
        static constexpr segment_id_t LastNamedCommonSegment = 254;
        static constexpr segment_id_t UnnamedCommonSegment = 255;
 
        // TODO: document
 
        enum alignment_t : uint8_t
        {
            // page is 256 bytes
            AlignFitsPage = 1,
            AlignPage = 2,
            AlignByte = 3,
        };
 
        class ExternalNameIndex
        {
        public:
            uint16_t index;
            std::string external_name;
 
            void CalculateValues(OMF80Format * omf, Module * mod);
            void ResolveReferences(OMF80Format * omf, Module * mod);
        };
 
        class ModuleHeaderRecord : public Record
        {
        public:
            class SegmentDefinition
            {
            public:
                segment_id_t segment_id = 0;
                uint16_t length = 0;
                alignment_t alignment = AlignByte;
 
                static SegmentDefinition Read(OMF80Format * omf, const std::shared_ptr<Linker::Reader>& rd);
                void Write(OMF80Format * omf, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            std::string name;
            std::vector<SegmentDefinition> segment_definitions;
 
            ModuleHeaderRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF80Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF80Format * omf, Module * mod) override;
            void ResolveReferences(OMF80Format * omf, Module * mod) override;
        };
 
        class ModuleEndRecord : public Record
        {
        public:
            bool main;
            segment_id_t start_segment_id;
            uint16_t start_offset;
            std::vector<uint8_t> info;
 
            ModuleEndRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF80Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF80Format * omf, Module * mod) override;
            void ResolveReferences(OMF80Format * omf, Module * mod) override;
        };
 
        class NamedCommonDefinitionsRecord : public Record
        {
        public:
            class NamedCommonDefinition
            {
            public:
                segment_id_t segment_id;
                std::string common_name;
 
                static NamedCommonDefinition ReadNamedCommonDefinition(OMF80Format * omf, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t GetNamedCommonDefinitionSize(OMF80Format * omf) const;
                void WriteNamedCommonDefinition(OMF80Format * omf, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            std::vector<NamedCommonDefinition> named_common_definitions;
 
            NamedCommonDefinitionsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF80Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF80Format * omf, Module * mod) override;
            void ResolveReferences(OMF80Format * omf, Module * mod) override;
        };
 
        class ExternalDefinitionsRecord : public Record
        {
        public:
            Module * mod;
 
            std::vector<std::string> external_names; // only used for generation
            uint16_t first_external_name;
            uint16_t external_name_count;
 
            ExternalDefinitionsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF80Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF80Format * omf, Module * mod) override;
            void ResolveReferences(OMF80Format * omf, Module * mod) override;
        };
 
        class SymbolDefinitionsRecord : public Record
        {
        public:
            class SymbolDefinition
            {
            public:
                uint16_t offset;
                std::string name;
 
                static SymbolDefinition Read(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF80Format * omf, Module * mod) const;
                void Write(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            uint8_t segment_id;
            std::vector<SymbolDefinition> public_definitions;
 
            SymbolDefinitionsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF80Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF80Format * omf, Module * mod) override;
            void ResolveReferences(OMF80Format * omf, Module * mod) override;
        };
 
        enum relocation_type_t : uint8_t
        {
            RelocationLowByte = 1,
            RelocationHighByte = 2,
            RelocationWord = 3,
        };
 
        class RelocationsRecord : public Record
        {
        public:
            relocation_type_t relocation_type;
            std::vector<uint16_t> offsets;
 
            RelocationsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF80Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF80Format * omf, Module * mod) override;
            void ResolveReferences(OMF80Format * omf, Module * mod) override;
        };
 
        class InterSegmentReferencesRecord : public RelocationsRecord
        {
        public:
            segment_id_t segment_id;
 
            InterSegmentReferencesRecord(record_type_t record_type = record_type_t(0))
                : RelocationsRecord(record_type)
            {
            }
 
            void ReadRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF80Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF80Format * omf, Module * mod) override;
            void ResolveReferences(OMF80Format * omf, Module * mod) override;
        };
 
        class ExternalReferencesRecord : public Record
        {
        public:
            class ExternalReference
            {
            public:
                ExternalNameIndex name_index;
                uint16_t offset;
            };
 
            relocation_type_t relocation_type;
            std::vector<ExternalReference> external_references;
 
            ExternalReferencesRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF80Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF80Format * omf, Module * mod) override;
            void ResolveReferences(OMF80Format * omf, Module * mod) override;
        };
 
        class ModuleAncestorRecord : public Record
        {
        public:
            std::string name;
 
            ModuleAncestorRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF80Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF80Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF80Format * omf, Module * mod) override;
            void ResolveReferences(OMF80Format * omf, Module * mod) override;
        };
 
        class SegmentDefinition : public ModuleHeaderRecord::SegmentDefinition
        {
        public:
            segment_id_t segment_id = 0;
            uint16_t length = 0;
            alignment_t alignment = AlignByte;
            std::string common_name;
 
            SegmentDefinition()
            {
            }
 
            SegmentDefinition(const ModuleHeaderRecord::SegmentDefinition& segment_definition)
                : segment_id(segment_definition.segment_id), length(segment_definition.length), alignment(segment_definition.alignment)
            {
            }
        };
 
        class Module
        {
        public:
            size_t first_record = 0;
            size_t record_count = 0;
 
            std::map<segment_id_t, SegmentDefinition> segment_definitions;
            std::vector<std::string> external_names;
        };
 
        std::vector<std::shared_ptr<Record>> records;
 
        std::vector<Module> modules;
 
        static std::shared_ptr<OMF80Format> ReadOMFFile(const std::shared_ptr<Linker::Reader>& rd);
 
        static void DumpAddFields(const Record * record, Dumper::Dumper& dump, Dumper::Region& region, const OMF80Format * omf, const Module * mod, size_t record_index, Dumper::display_option& options);
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
        /* TODO */
    };
 
    class OMF51Format : public virtual OMFFormat, public virtual Linker::InputFormat
    {
    public:
        class Module;
 
        enum record_type_t : uint8_t
        {
            ModuleHeader = OMF80Format::ModuleHeader,
            ModuleEnd = OMF80Format::ModuleEnd,
            Content = OMF80Format::Content,
            Fixups = 0x08,
            SegmentDefinitions = 0x0E,
            ScopeDefinition = 0x10,
            DebugItems = 0x12,
            PublicDefinitions = OMF80Format::PublicDefinitions,
            ExternalDefinitions = OMF80Format::ExternalDefinitions,
            LibraryModuleLocations = OMF80Format::LibraryModuleLocations,
            LibraryModuleNames = OMF80Format::LibraryModuleNames,
            LibraryDictionary = OMF80Format::LibraryDictionary,
            LibraryHeader = OMF80Format::LibraryHeader,
        };
 
        static const std::map<offset_t, std::string> RecordTypeNames;
 
        using Record = OMFFormat::Record<record_type_t, OMF51Format, Module>;
        using UnknownRecord = OMFFormat::UnknownRecord<record_type_t, OMF51Format, Module>;
        using EmptyRecord = OMFFormat::EmptyRecord<record_type_t, OMF51Format, Module>;
        using ContentRecord = OMFFormat::ContentRecord<record_type_t, OMF51Format, Module>;
        using LibraryHeaderRecord = OMFFormat::LibraryHeaderRecord<record_type_t, OMF51Format, Module>;
        using LibraryModuleNamesRecord = OMFFormat::LibraryModuleNamesRecord<record_type_t, OMF51Format, Module>;
        using LibraryModuleLocationsRecord = OMFFormat::LibraryModuleLocationsRecord<record_type_t, OMF51Format, Module>;
        using LibraryDictionaryRecord = OMFFormat::LibraryDictionaryRecord<record_type_t, OMF51Format, Module>;
 
        std::shared_ptr<Record> ReadRecord(const std::shared_ptr<Linker::Reader>& rd);
 
        // TODO: document record types
 
        static constexpr uint8_t SegmentAbsolute = 0;
 
        enum segment_type_t : uint8_t
        {
            SegmentCode = 0,
            SegmentXData = 1,
            SegmentData = 2,
            SegmentIData = 3,
            SegmentBit = 4,
            SegmentNone = 5,
        };
 
        enum alignment_t : uint8_t
        {
            AlignAbsolute = 0,
            AlignUnit = 1,
            AlignBitAddressable = 2,
            AlignFitsPage = 3,
            AlignFitsBlock = 4,
            AlignPage = 5,
        };
 
        class SegmentInfo
        {
        public:
            bool overlayable;
            uint8_t register_bank;
            segment_type_t segment_type;
 
            static constexpr uint8_t MaskSegmentType = 0x07;
            static constexpr uint8_t MaskRegisterBank = 0x18;
            static constexpr uint8_t ShiftRegisterBank = 3;
            static constexpr uint8_t FlagOverlayable = 0x20;
            static constexpr uint8_t FlagSegmentEmpty = 0x80;
 
            void ReadSegmentInfo(OMF51Format * omf, Module * mod, uint8_t segment_info);
            uint8_t WriteSegmentInfo(OMF51Format * omf, Module * mod) const;
        };
 
        class SegmentDefinition
        {
        public:
            uint8_t segment_id;
            SegmentInfo info;
            alignment_t alignment;
            uint16_t base;
            uint32_t size;
            std::string name;
 
            static SegmentDefinition Read(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
            uint16_t Size(OMF51Format * omf, Module * mod) const;
            void Write(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
        };
 
        class SymbolInfo
        {
        public:
            bool indirectly_callable;
            bool variable;
            std::optional<unsigned> register_bank;
            segment_type_t usage;
 
            static constexpr uint8_t MaskSegmentType = 0x07;
            static constexpr uint8_t MaskRegisterBank = 0x18;
            static constexpr uint8_t ShiftRegisterBank = 3;
            static constexpr uint8_t FlagRegisterBank = 0x20;
            static constexpr uint8_t FlagVariable = 0x40;
            static constexpr uint8_t FlagIndirectlyCallable = 0x80;
 
            void Read(OMF51Format * omf, Module * mod, uint8_t segment_info);
            uint8_t Write(OMF51Format * omf, Module * mod) const;
        };
 
        class SymbolDefinition
        {
        public:
            uint8_t segment_id;
            SymbolInfo info;
            uint16_t offset;
            std::string name;
 
            static SymbolDefinition Read(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
            uint16_t Size(OMF51Format * omf, Module * mod) const;
            void Write(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
        };
 
        class ExternalDefinition
        {
        public:
            uint8_t block_id = 2;
            uint8_t external_id;
            SymbolInfo info;
            std::string name;
 
            static ExternalDefinition Read(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
            uint16_t Size(OMF51Format * omf, Module * mod) const;
            void Write(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
        };
 
        class ModuleHeaderRecord : public Record
        {
        public:
            std::string name;
            enum translator_id_t : uint8_t
            {
                Assembler = 0xFD,
                PLMCompiler = 0xFE,
                Linker = 0xFF,
            };
            translator_id_t translator_id;
 
            ModuleHeaderRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF51Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class ModuleEndRecord : public Record
        {
        public:
            std::string name;
            std::array<bool, 4> banks;
 
            ModuleEndRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF51Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class SegmentDefinitionsRecord : public Record
        {
        public:
            std::vector<SegmentDefinition> segment_definitions;
 
            SegmentDefinitionsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF51Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF51Format * omf, Module * mod) override;
            void ResolveReferences(OMF51Format * omf, Module * mod) override;
        };
 
        class PublicSymbolsRecord : public Record
        {
        public:
            std::vector<SymbolDefinition> symbol_definitions;
 
            PublicSymbolsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF51Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF51Format * omf, Module * mod) override;
            void ResolveReferences(OMF51Format * omf, Module * mod) override;
        };
 
        class ExternalDefinitionsRecord : public Record
        {
        public:
            std::vector<ExternalDefinition> external_definitions;
 
            ExternalDefinitionsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF51Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF51Format * omf, Module * mod) override;
            void ResolveReferences(OMF51Format * omf, Module * mod) override;
        };
 
        class ScopeDefinitionRecord : public Record
        {
        public:
            enum block_type_t : uint8_t
            {
                ModuleBlock = 0,
                DoBlock = 1,
                ProcedureBlock = 2,
                EndModuleBlock = 3,
                EndDoBlock = 4,
                EndProcedureBlock = 5,
            };
 
            block_type_t block_type;
            std::string name;
 
            ScopeDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF51Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF51Format * omf, Module * mod) override;
            void ResolveReferences(OMF51Format * omf, Module * mod) override;
        };
 
        class DebugItemsRecord : public Record
        {
        public:
            class Symbol
            {
            public:
                uint8_t segment_id;
                SymbolInfo info;
                uint16_t offset;
                std::string name;
 
                static Symbol Read(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF51Format * omf, Module * mod) const;
                void Write(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            class LocalSymbols
            {
            public:
                std::vector<Symbol> symbols;
            };
 
            class PublicSymbols
            {
            public:
                std::vector<Symbol> symbols;
            };
 
            class SegmentSymbol
            {
            public:
                uint8_t segment_id;
                SegmentInfo info;
                uint16_t offset;
                std::string name;
 
                static SegmentSymbol Read(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF51Format * omf, Module * mod) const;
                void Write(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            class SegmentSymbols
            {
            public:
                std::vector<SegmentSymbol> symbols;
            };
 
            class LineNumber
            {
            public:
                uint8_t segment_id;
                uint16_t offset;
                uint16_t line_number;
 
                static LineNumber Read(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                void Write(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            class LineNumbers
            {
            public:
                std::vector<LineNumber> symbols;
            };
 
            static constexpr uint8_t Type_LocalSymbols = 0;
            static constexpr uint8_t Type_PublicSymbols = 1;
            static constexpr uint8_t Type_SegmentSymbols = 2;
            static constexpr uint8_t Type_LineNumbers = 3;
 
            std::variant<LocalSymbols, PublicSymbols, SegmentSymbols, LineNumbers> contents;
 
            DebugItemsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF51Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF51Format * omf, Module * mod) override;
            void ResolveReferences(OMF51Format * omf, Module * mod) override;
        };
 
        class FixupRecord : public Record
        {
        public:
            enum relocation_type_t : uint8_t
            {
                RelocationLow8 = 0,
                RelocationByte8 = 1,
                RelocationRelative8 = 2,
                RelocationHigh8 = 3,
                RelocationWord16 = 4,
                RelocationAbsolute11 = 5,
                RelocationBit7 = 6,
                RelocationConv7 = 7,
            };
 
            enum reference_type_t : uint8_t
            {
                ReferenceSegmentBase = 0,
                ReferenceSegmentStart = 1,
                ReferenceExternal = 2,
            };
 
            class Fixup
            {
            public:
                uint16_t location;
                relocation_type_t relocation;
                reference_type_t reference;
                uint8_t id;
                uint16_t offset;
 
                static Fixup Read(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                void Write(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            std::vector<Fixup> fixups;
 
            FixupRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF51Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF51Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF51Format * omf, Module * mod) override;
            void ResolveReferences(OMF51Format * omf, Module * mod) override;
        };
 
        class Module
        {
        public:
            size_t first_record = 0;
            size_t record_count = 0;
 
            std::map<uint8_t, SegmentDefinition> segment_definitions;
            std::map<uint8_t, ExternalDefinition> external_definitions;
        };
 
        std::vector<std::shared_ptr<Record>> records;
 
        std::vector<Module> modules;
 
        static std::shared_ptr<OMF51Format> ReadOMFFile(const std::shared_ptr<Linker::Reader>& rd);
 
        static void DumpAddFields(const Record * record, Dumper::Dumper& dump, Dumper::Region& region, const OMF51Format * omf, const Module * mod, size_t record_index, Dumper::display_option& options);
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
        /* TODO */
    };
 
    class OMF96Format : public virtual OMFFormat, public virtual Linker::InputFormat
    {
    public:
        class Module;
 
        typedef uint16_t index_t;
 
        enum record_type_t : uint8_t
        {
            ModuleHeader = OMF80Format::ModuleHeader,
            ModuleEnd = OMF80Format::ModuleEnd,
            Content = OMF80Format::Content,
            LineNumbers = OMF80Format::LineNumbers,
            BlockDefinition = 0x0A,
            BlockEnd = 0x0C,
            EndOfFile = OMF80Format::EndOfFile,
            ModuleAncestor = OMF80Format::ModuleAncestor,
            LocalSymbols = OMF80Format::LocalSymbols,
            TypeDefinition = 0x14,
            PublicDefinitions = OMF80Format::PublicDefinitions,
            ExternalDefinitions = OMF80Format::ExternalDefinitions,
            SegmentDefinitions = 0x20, // different from OMF51 number
            Relocations = OMF80Format::Relocations,
            LibraryModuleLocations = OMF80Format::LibraryModuleLocations,
            LibraryModuleNames = OMF80Format::LibraryModuleNames,
            LibraryDictionary = OMF80Format::LibraryDictionary,
            LibraryHeader = 0x2E, // different from OMF80 number
        };
 
        static const std::map<offset_t, std::string> RecordTypeNames;
 
        using Record = OMFFormat::Record<record_type_t, OMF96Format, Module>;
        using UnknownRecord = OMFFormat::UnknownRecord<record_type_t, OMF96Format, Module>;
        using EmptyRecord = OMFFormat::EmptyRecord<record_type_t, OMF96Format, Module>;
        using ContentRecord = OMFFormat::ContentRecord<record_type_t, OMF96Format, Module>;
        using LineNumbersRecord = OMFFormat::LineNumbersRecord<record_type_t, OMF96Format, Module>;
        using LibraryHeaderRecord = OMFFormat::LibraryHeaderRecord<record_type_t, OMF96Format, Module>;
        using LibraryModuleNamesRecord = OMFFormat::LibraryModuleNamesRecord<record_type_t, OMF96Format, Module>;
        using LibraryModuleLocationsRecord = OMFFormat::LibraryModuleLocationsRecord<record_type_t, OMF96Format, Module>;
        using LibraryDictionaryRecord = OMFFormat::LibraryDictionaryRecord<record_type_t, OMF96Format, Module>;
 
        std::shared_ptr<Record> ReadRecord(const std::shared_ptr<Linker::Reader>& rd);
 
        typedef uint8_t segment_id_t;
 
        static constexpr segment_id_t CodeSegment = 0;
        static constexpr segment_id_t DataSegment = 1;
        static constexpr segment_id_t RegisterSegment = 2;
        static constexpr segment_id_t OverlaySegment = 3;
        static constexpr segment_id_t StackSegment = 4;
        static constexpr segment_id_t DynamicSymbol = 5;
        static constexpr segment_id_t NullSegment = 6;
        static constexpr segment_id_t SegmentTypeMask = 7;
 
        static constexpr segment_id_t FlagBasedVariable = 0x40;
 
        static constexpr segment_id_t FlagRelocatableSegment = 0x80;
 
        enum alignment_t
        {
            AlignByte = 0,
            AlignWord = 1,
            AlignLong = 2,
        };
 
        class SegmentDefinition
        {
        public:
            segment_id_t segment_id;
        private:
            union
            {
                alignment_t alignment; // for RelocatableSegment
                uint16_t base_address;
            };
        public:
            uint16_t size;
 
            bool IsRelocatable() const
            {
                return segment_id & FlagRelocatableSegment;
            }
 
            bool IsAbsolute() const
            {
                return !IsRelocatable();
            }
 
            alignment_t GetAlignment() const
            {
                return IsRelocatable() ? alignment : alignment_t(-1);
            }
 
            uint16_t GetBaseAddress() const
            {
                return IsAbsolute() ? base_address : 0;
            }
 
            void MakeRelocatable(alignment_t rel_alignment)
            {
                segment_id |= FlagRelocatableSegment;
                alignment = rel_alignment;
            }
 
            void MakeAbsolute(uint16_t address)
            {
                segment_id &= ~FlagRelocatableSegment;
                base_address = address;
            }
 
            static SegmentDefinition Read(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
            uint16_t Size(OMF96Format * omf, Module * mod) const;
            void Write(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
        };
 
        class TypeDefinitionRecord;
 
        class TypeIndex
        {
        public:
            index_t index;
            std::shared_ptr<TypeDefinitionRecord> record;
 
            TypeIndex(index_t index = 0)
                : index(index)
            {
            }
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class ExternalDefinition
        {
        public:
            std::string name;
            TypeIndex type;
 
            static ExternalDefinition Read(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
            uint16_t Size(OMF96Format * omf, Module * mod) const;
            void Write(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
 
            void CalculateValues(OMF96Format * omf, Module * mod);
            void ResolveReferences(OMF96Format * omf, Module * mod);
        };
 
        class SymbolDefinition
        {
        public:
            uint16_t offset;
            std::string name;
            TypeIndex type;
 
            static SymbolDefinition Read(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
            uint16_t Size(OMF96Format * omf, Module * mod) const;
            void Write(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
 
            void CalculateValues(OMF96Format * omf, Module * mod);
            void ResolveReferences(OMF96Format * omf, Module * mod);
        };
 
        class ModuleHeaderRecord : public Record
        {
        public:
            std::string name;
            uint8_t translator_id;
            std::string date_time;
 
            static constexpr uint8_t Version14 = 0xE0;
            static constexpr uint8_t Version20 = 0xE4;
            static constexpr uint8_t Translator = 0x00;
            static constexpr uint8_t Linker = 0x01;
 
            ModuleHeaderRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF96Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class ModuleEndRecord : public Record
        {
        public:
            bool main;
            bool valid;
 
            static constexpr uint8_t MainModule = 0x01;
            static constexpr uint8_t OtherModule = 0x00;
 
            static constexpr uint8_t ValidModule = 0x00;
            static constexpr uint8_t ErroneousModule = 0x01;
 
            ModuleEndRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF96Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
        };
 
        class SegmentDefinitionsRecord : public Record
        {
        public:
            std::vector<SegmentDefinition> segment_definitions;
 
            SegmentDefinitionsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF96Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF96Format * omf, Module * mod) override;
            void ResolveReferences(OMF96Format * omf, Module * mod) override;
        };
 
        class TypeDefinitionRecord : public Record, public std::enable_shared_from_this<TypeDefinitionRecord>
        {
        public:
            class LeafDescriptor
            {
            public:
                bool nice; // easy if false
 
                struct Null { };
                struct Repeat { };
                // TODO: document
                struct EndOfBranch { };
 
                std::variant<Null, int32_t, std::string, TypeIndex, Repeat, EndOfBranch> leaf = Null();
 
                static constexpr uint8_t NullLeaf = 0x64;
                static constexpr uint8_t SignedNumericLeaf16 = 0x65;
                static constexpr uint8_t SignedNumericLeaf32 = 0x66;
                static constexpr uint8_t StringLeaf = 0x67;
                static constexpr uint8_t IndexLeaf = 0x68;
                static constexpr uint8_t RepeatLeaf = 0x69;
                static constexpr uint8_t EndOfBranchLeaf = 0x6A;
 
                static LeafDescriptor Read(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF96Format * omf, Module * mod) const;
                void Write(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
 
                void CalculateValues(OMF96Format * omf, Module * mod);
                void ResolveReferences(OMF96Format * omf, Module * mod);
            };
 
            std::vector<LeafDescriptor> leafs;
 
            TypeDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF96Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF96Format * omf, Module * mod) override;
            void ResolveReferences(OMF96Format * omf, Module * mod) override;
        };
 
        class SymbolDefinitionsRecord : public Record
        {
        public:
            segment_id_t segment_id;
            std::vector<SymbolDefinition> symbol_definitions;
 
            SymbolDefinitionsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF96Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF96Format * omf, Module * mod) override;
            void ResolveReferences(OMF96Format * omf, Module * mod) override;
        };
 
        class ExternalDefinitionsRecord : public Record
        {
        public:
            segment_id_t segment_id;
            std::vector<ExternalDefinition> external_definitions;
 
            ExternalDefinitionsRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF96Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF96Format * omf, Module * mod) override;
            void ResolveReferences(OMF96Format * omf, Module * mod) override;
        };
 
        class RelocationRecord : public Record
        {
        public:
            class Relocation
            {
            public:
                typedef segment_id_t LocalReference;
                typedef uint16_t ExternalReference;
 
                enum reference_type_t
                {
                    RegisterSimple = 0,
                    RegisterAutoIncrement = 1,
                    ShiftCountImmediate = 2,
                    ShiftCountRegister = 3,
                    ByteConstant = 4,
                    ShortJump = 6,
                    MediumJump = 7,
                    MediumCall = 8,
                    LongJumpCall = 9,
                    LongDirect = 10,
                };
 
                static constexpr uint8_t FlagAddendInCode = 0x40;
                static constexpr uint8_t FlagExternal = 0x80;
 
                uint16_t offset;
                std::variant<LocalReference, ExternalReference> reference = LocalReference(0);
                std::optional<uint16_t> addend;
                reference_type_t reference_type;
                alignment_t alignment;
 
                static Relocation Read(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd);
                uint16_t Size(OMF96Format * omf, Module * mod) const;
                void Write(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const;
            };
 
            std::vector<Relocation> relocations;
 
            RelocationRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF96Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF96Format * omf, Module * mod) override;
            void ResolveReferences(OMF96Format * omf, Module * mod) override;
        };
 
        class ModuleAncestorRecord : public Record
        {
        public:
            std::string name;
            std::optional<SegmentDefinition> segment_definition;
 
            ModuleAncestorRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF96Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF96Format * omf, Module * mod) override;
            void ResolveReferences(OMF96Format * omf, Module * mod) override;
        };
 
        class BlockDefinitionRecord : public Record
        {
        public:
            class BlockNameAndType
            {
            public:
                std::string name;
                TypeIndex type;
            };
 
            typedef segment_id_t LocalReference;
            typedef uint16_t ExternalReference;
 
            class ProcedureInformation
            {
            public:
                std::variant<LocalReference, ExternalReference> frame_pointer = LocalReference(0);
                uint16_t return_offset;
                uint8_t prologue_size;
            };
 
            segment_id_t segment_id;
            uint16_t offset;
            uint16_t size;
            std::optional<BlockNameAndType> name_and_type;
            std::optional<ProcedureInformation> procedure_info;
 
            BlockDefinitionRecord(record_type_t record_type = record_type_t(0))
                : Record(record_type)
            {
            }
 
            static constexpr uint8_t FlagProcedure = 0x40;
            static constexpr uint8_t FlagExternal = 0x80;
 
            void ReadRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<Linker::Reader>& rd) override;
            uint16_t GetRecordSize(OMF96Format * omf, Module * mod) const override;
            void WriteRecordContents(OMF96Format * omf, Module * mod, const std::shared_ptr<ChecksumWriter>& wr) const override;
 
            void CalculateValues(OMF96Format * omf, Module * mod) override;
            void ResolveReferences(OMF96Format * omf, Module * mod) override;
        };
 
        class Module
        {
        public:
            size_t first_record = 0;
            size_t record_count = 0;
 
            std::map<segment_id_t, SegmentDefinition> segment_definitions;
            std::vector<std::shared_ptr<TypeDefinitionRecord>> type_definitions;
        };
 
        std::vector<std::shared_ptr<Record>> records;
 
        std::vector<Module> modules;
 
        static std::shared_ptr<OMF96Format> ReadOMFFile(const std::shared_ptr<Linker::Reader>& rd);
 
        static void DumpAddFields(const Record * record, Dumper::Dumper& dump, Dumper::Region& region, const OMF96Format * omf, const Module * mod, size_t record_index, Dumper::display_option& options);
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
        /* TODO */
    };
 
    class OMFFormatContainer : public virtual Linker::InputFormat
    {
    public:
        std::shared_ptr<OMFFormat> contents;
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
 
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
 
        offset_t ImageSize() const override;
 
        void Dump(Dumper::Dumper& dump) const override;
    };
}
 
#endif /* OMF_H */