omf.h

#ifndef OMF_H
#define OMF_H
 
#include <variant>
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/format.h"
#include "../linker/reader.h"
#include "../linker/writer.h"
 
/* TODO: unimplemented */
 
/* Intel Object Module format (input only) */
 
namespace OMF
{
    class ChecksumWriter
    {
    public:
        Linker::Writer * wr;
        uint8_t checksum = 0;
 
        ChecksumWriter(Linker::Writer& wr)
            : wr(&wr)
        {
        }
 
        void WriteWord(size_t bytes, uint64_t value)
        {
            wr->WriteWord(bytes, value);
            for(size_t offset = 0; offset < bytes; offset++, value >>= 8)
            {
                checksum -= value;
            }
        }
 
        size_t WriteData(const std::vector<uint8_t>& data)
        {
            size_t bytes = wr->WriteData(data);
            for(size_t offset = 0; offset < bytes; offset++)
            {
                checksum -= data[offset];
            }
            return bytes;
        }
 
        size_t WriteData(std::string text)
        {
            wr->WriteData(text);
            for(size_t offset = 0; offset < text.size(); offset++)
            {
                checksum -= text[offset];
            }
            return text.size();
        }
 
        void Skip(offset_t count)
        {
            wr->Skip(count);
        }
    };
 
    class OMFFormat : public virtual Linker::Format
    {
    public:
        virtual ~OMFFormat() = default;
 
        static std::string ReadString(Linker::Reader& rd, size_t max_bytes = size_t(-1));
 
        static void WriteString(ChecksumWriter& wr, std::string text);
 
        class Record
        {
        public:
            offset_t record_offset;
            uint16_t record_length;
            uint8_t record_type;
 
            Record(uint8_t record_type = 0)
                : record_type(record_type)
            {
            }
 
            virtual ~Record() = default;
 
            virtual void ReadRecordContents(OMFFormat * omf, Linker::Reader& rd) = 0;
 
            virtual uint16_t GetRecordSize(OMFFormat * omf) const = 0;
 
            virtual void WriteRecordContents(OMFFormat * omf, ChecksumWriter& wr) const = 0;
 
            virtual void WriteRecord(OMFFormat * omf, Linker::Writer& wr) const;
        };
 
        class UnknownRecord : public Record
        {
        public:
            std::vector<uint8_t> data;
 
            UnknownRecord(uint8_t record_type = 0)
                : Record(record_type)
            {
            }
 
            void ReadRecordContents(OMFFormat * omf, Linker::Reader& rd) override;
            uint16_t GetRecordSize(OMFFormat * omf) const override;
            void WriteRecordContents(OMFFormat * omf, ChecksumWriter& wr) const override;
        };
 
        std::vector<std::shared_ptr<Record>> records;
    };
 
    class OMF86Format : public virtual OMFFormat, public virtual Linker::InputFormat
    {
    public:
        class Module;
        class SegmentDefinitionRecord;
        class GroupDefinitionRecord;
 
        /* * * General members * * */
 
        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 = OMF_VERSION_TIS_11;
 
        static constexpr unsigned int FlagIntel = 0x10;
        static constexpr unsigned int FlagPharLap = 0x20;
        static constexpr unsigned int FlagTIS = 0x30;
 
        typedef uint16_t index_t;
 
        static index_t ReadIndex(Linker::Reader& rd);
 
        static void WriteIndex(ChecksumWriter& wr, index_t index);
 
        static size_t IndexSize(index_t index);
 
        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
            {
                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 ReadLength(OMF86Format * omf, Linker::Reader& rd);
            static uint32_t GetLengthSize(OMF86Format * omf, uint32_t length);
            static void WriteLength(OMF86Format * omf, ChecksumWriter& wr, uint32_t length);
 
            static ExternalName ReadExternalName(OMF86Format * omf, Linker::Reader& rd, bool local);
            static ExternalName ReadCommonName(OMF86Format * omf, Linker::Reader& rd, bool local);
            static ExternalName ReadComdatExternalName(OMF86Format * omf, Linker::Reader& rd);
 
            uint16_t GetExternalNameSize(OMF86Format * omf) const;
            void WriteExternalName(OMF86Format * omf, 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, Linker::Reader& rd);
            uint16_t GetSize(OMF86Format * omf) const;
            void Write(OMF86Format * omf, 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 ReadSymbol(OMF86Format * omf, Linker::Reader& rd, bool local, bool is32bit);
            uint16_t GetSymbolSize(OMF86Format * omf, bool is32bit) const;
            void WriteSymbol(OMF86Format * omf, 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 ReadLineNumber(OMF86Format * omf, Linker::Reader& rd, bool is32bit);
            void WriteLineNumber(OMF86Format * omf, 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, Linker::Reader& rd, uint16_t data_length);
            uint16_t GetEnumeratedDataBlockSize(OMF86Format * omf) const;
            void WriteEnumeratedDataBlock(OMF86Format * omf, ChecksumWriter& wr) const;
 
            static std::shared_ptr<DataBlock> ReadIteratedDataBlock(OMF86Format * omf, Linker::Reader& rd, bool is32bit);
            uint16_t GetIteratedDataBlockSize(OMF86Format * omf, bool is32bit) const;
            void WriteIteratedDataBlock(OMF86Format * omf, 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, Linker::Reader& rd, size_t displacement_size);
            uint16_t GetSize(OMF86Format * omf, bool is32bit) const;
            void Write(OMF86Format * omf, ChecksumWriter& wr, bool is32bit) const;
 
            void CalculateValues(OMF86Format * omf, Module * mod);
            void ResolveReferences(OMF86Format * omf, Module * mod);
        };
 
        class Record : public OMFFormat::Record
        {
        public:
            enum record_type_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
            };
 
            Record()
            {
            }
 
            Record(record_type_t record_type)
                : OMFFormat::Record(record_type)
            {
            }
 
            void ReadRecordContents(OMFFormat * omf, Linker::Reader& rd) override;
            uint16_t GetRecordSize(OMFFormat * omf) const override;
            void WriteRecordContents(OMFFormat * omf, ChecksumWriter& wr) const override;
 
            virtual void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) = 0;
            virtual uint16_t GetRecordSize(OMF86Format * omf) const = 0;
            virtual void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const = 0;
 
            virtual void CalculateValues(OMF86Format * omf, Module * mod);
            virtual void ResolveReferences(OMF86Format * omf, Module * mod);
 
            bool Is32Bit(OMF86Format * omf) const;
 
            size_t GetOffsetSize(OMF86Format * omf) const;
 
            static std::shared_ptr<OMFFormat::Record> ReadRecord(OMF86Format * omf, Linker::Reader& rd);
        };
 
        class EmptyRecord : public Record
        {
        public:
            EmptyRecord()
                : Record()
            {
            }
 
            EmptyRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class ModuleHeaderRecord : public Record
        {
        public:
            std::string name;
 
            ModuleHeaderRecord()
                : Record()
            {
            }
 
            ModuleHeaderRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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)
                : ModuleHeaderRecord(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class ListOfNamesRecord : public Record
        {
        public:
            Module * module;
            std::vector<std::string> names;
            index_t first_lname;
            uint16_t lname_count = 0;
 
            ListOfNamesRecord()
                : Record()
            {
            }
 
            ListOfNamesRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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,
                Align32 = 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 | 4,
            };
 
            combination_t combination;
 
            bool page_resident = false; // Intel
            bool use32 = false;
 
            NameIndex segment_name;
            NameIndex class_name;
            NameIndex overlay_name;
 
            enum access_t
            {
                AccessReadOnly = 0,
                AccessExecuteOnly = 1,
                AccessExecuteRead = 2,
                AccessReadWrite = 3,
            };
 
            std::optional<access_t> access;
 
            SegmentDefinitionRecord()
                : Record()
            {
            }
 
            SegmentDefinitionRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        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 ReadComponent(OMF86Format * omf, Linker::Reader& rd);
                uint16_t GetComponentSize(OMF86Format * omf) const;
                void WriteComponent(OMF86Format * omf, ChecksumWriter& wr) const;
 
                void CalculateValues(OMF86Format * omf, Module * mod);
                void ResolveReferences(OMF86Format * omf, Module * mod);
            };
 
            NameIndex name;
            std::vector<Component> components;
 
            GroupDefinitionRecord()
                : Record()
            {
            }
 
            GroupDefinitionRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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 ReadLeaf(OMF86Format * omf, Linker::Reader& rd);
                uint16_t GetLeafSize(OMF86Format * omf) const;
                void WriteLeaf(OMF86Format * omf, 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()
            {
            }
 
            TypeDefinitionRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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()
            {
            }
 
            SymbolsDefinitionRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class ExternalNamesDefinitionRecord : public Record
        {
        public:
            Module * module;
            ExternalIndex first_extdef;
            uint16_t extdef_count = 0;
 
            ExternalNamesDefinitionRecord()
                : Record()
            {
            }
 
            ExternalNamesDefinitionRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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()
            {
            }
 
            LineNumbersRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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
            {
                NotProcedure = 0x00,
                NearProcedure = 0x80,
                FarProcedure = 0xC0,
            };
            block_type_t procedure;
            uint16_t return_address_offset; // only for procedures
            TypeIndex type;
 
            BlockDefinitionRecord()
                : Record()
            {
            }
 
            BlockDefinitionRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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()
            {
            }
 
            DebugSymbolsRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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()
            {
            }
 
            RelocatableDataRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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()
            {
            }
 
            PhysicalDataRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class LogicalDataRecord : public Record
        {
        public:
            SegmentIndex segment;
            uint32_t offset;
            std::shared_ptr<DataBlock> data;
 
            LogicalDataRecord()
                : Record()
            {
            }
 
            LogicalDataRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class FixupRecord : public Record
        {
        public:
            class Thread
            {
            public:
                unsigned thread_number;
                bool frame;
                std::variant<SegmentIndex, GroupIndex, ExternalIndex, FrameNumber, UsesSource, UsesTarget, UsesAbsolute> reference = FrameNumber(0);
 
                static Thread Read(OMF86Format * omf, Linker::Reader& rd, uint8_t leading_data_byte);
                uint16_t GetSize(OMF86Format * omf) const;
                void Write(OMF86Format * omf, 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, Linker::Reader& rd, uint8_t leading_data_byte, bool is32bit);
                uint16_t GetSize(OMF86Format * omf, bool is32bit) const;
                void Write(OMF86Format * omf, 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()
            {
            }
 
            FixupRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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()
            {
            }
 
            OverlayDefinitionRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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()
            {
            }
 
            EndRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class RegisterInitializationRecord : public Record
        {
        public:
            class Register
            {
            public:
                enum register_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 ReadRegister(OMF86Format * omf, Linker::Reader& rd);
                uint16_t GetRegisterSize(OMF86Format * omf) const;
                void WriteRegister(OMF86Format * omf, ChecksumWriter& wr) const;
 
                void CalculateValues(OMF86Format * omf, Module * mod);
                void ResolveReferences(OMF86Format * omf, Module * mod);
            };
 
            std::vector<Register> registers;
 
            RegisterInitializationRecord()
                : Record()
            {
            }
 
            RegisterInitializationRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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()
            {
            }
 
            ModuleEndRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class IntelLibraryHeaderRecord : public Record
        {
        public:
            uint16_t module_count;
            uint16_t block_number;
            uint16_t byte_number;
 
            IntelLibraryHeaderRecord()
                : Record()
            {
            }
 
            IntelLibraryHeaderRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class IntelLibraryModuleNamesRecord : public Record
        {
        public:
            std::vector<std::string> names;
 
            IntelLibraryModuleNamesRecord()
                : Record()
            {
            }
 
            IntelLibraryModuleNamesRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class IntelLibraryModuleLocationsRecord : public Record
        {
        public:
            struct Location
            {
            public:
                uint16_t block_number;
                uint16_t byte_number;
 
                static Location ReadLocation(Linker::Reader& rd);
                void WriteLocation(ChecksumWriter& wr) const;
            };
 
            std::vector<Location> locations;
 
            IntelLibraryModuleLocationsRecord()
                : Record()
            {
            }
 
            IntelLibraryModuleLocationsRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class IntelLibraryDictionaryRecord : public Record
        {
        public:
            class Group
            {
            public:
                std::vector<std::string> names;
 
                void ReadGroup(Linker::Reader& rd);
                uint16_t GetGroupSize() const;
                void WriteGroup(ChecksumWriter& wr) const;
            };
 
            std::vector<Group> groups;
 
            IntelLibraryDictionaryRecord()
                : Record()
            {
            }
 
            IntelLibraryDictionaryRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        // TODO: document
        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()
            {
            }
 
            BackpatchRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
 
            void CalculateValues(OMF86Format * omf, Module * mod) override;
            void ResolveReferences(OMF86Format * omf, Module * mod) override;
        };
 
        class NamedBackpatchRecord : public Record
        {
        public:
            class OffsetValuePair
            {
            public:
                uint32_t offset;
                uint32_t value;
            };
 
            enum location_type_t : uint8_t
            {
                Location8bit = 0,
                Location16bit = 1,
                Location32bit = 2,
                Location32bit_IBM = 9,
            };
            uint8_t type;
            NameIndex name;
            std::vector<OffsetValuePair> offset_value_pairs;
 
            NamedBackpatchRecord()
                : Record()
            {
            }
 
            NamedBackpatchRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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;
 
            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; // unclear
            NameIndex name;
            std::shared_ptr<DataBlock> data;
 
            InitializedCommunalDataRecord()
                : Record()
            {
            }
 
            InitializedCommunalDataRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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()
            {
            }
 
            SymbolLineNumbersRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, 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 ReadAliasDefinition(OMF86Format * omf, Linker::Reader& rd);
                uint16_t GetAliasDefinitionSize(OMF86Format * omf) const;
                void WriteAliasDefinition(OMF86Format * omf, ChecksumWriter& wr) const;
            };
            std::vector<AliasDefinition> alias_definitions;
 
            AliasDefinitionRecord()
                : Record()
            {
            }
 
            AliasDefinitionRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class OMFVersionNumberRecord : public Record
        {
        public:
            std::string version;
 
            OMFVersionNumberRecord()
                : Record()
            {
            }
 
            OMFVersionNumberRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class VendorExtensionRecord : public Record
        {
        public:
            uint16_t vendor_number;
            std::string extension;
 
            VendorExtensionRecord()
                : Record()
            {
            }
 
            VendorExtensionRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        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, Linker::Reader& rd, uint16_t comment_length) = 0;
            virtual uint16_t GetCommentSize(OMF86Format * omf) const = 0;
            virtual void WriteComment(OMF86Format * omf, ChecksumWriter& wr) const = 0;
 
            static std::shared_ptr<CommentRecord> ReadCommentRecord(OMF86Format * omf, Linker::Reader& rd, uint16_t record_length);
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
 
            class GenericCommentRecord;
            class EmptyCommentRecord;
            class TextCommentRecord;
        };
 
        class 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, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class CommentRecord::EmptyCommentRecord : public CommentRecord
        {
        public:
            EmptyCommentRecord(comment_class_t comment_class = comment_class_t(0))
                : CommentRecord(comment_class)
            {
            }
 
            void ReadComment(OMF86Format * omf, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class 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, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class NoSegmentPaddingRecord : public CommentRecord
        {
        public:
            std::vector<SegmentIndex> segments;
 
            NoSegmentPaddingRecord()
                : CommentRecord(NOPAD)
            {
            }
 
            void ReadComment(OMF86Format * omf, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, 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 ReadAssociation(OMF86Format * omf, Linker::Reader& rd);
                uint16_t GetAssociationSize(OMF86Format * omf) const;
                void WriteAssociation(OMF86Format * omf, 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, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, 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 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, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class OMFExtensionRecord::EmptyOMFExtensionRecord : public OMFExtensionRecord
        {
        public:
            EmptyOMFExtensionRecord(extension_type_t extension_type = extension_type_t(0))
                : OMFExtensionRecord(extension_type)
            {
            }
 
            void ReadComment(OMF86Format * omf, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        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, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, 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, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, 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, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, 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, Linker::Reader& rd, uint16_t comment_length) override;
            uint16_t GetCommentSize(OMF86Format * omf) const override;
            void WriteComment(OMF86Format * omf, ChecksumWriter& wr) const override;
        };
 
        class LibraryHeaderRecord : public Record
        {
        public:
            uint32_t dictionary_offset;
            uint16_t dictionary_size;
            bool case_sensitive;
 
            LibraryHeaderRecord()
                : Record()
            {
            }
 
            LibraryHeaderRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
 
            void WriteRecord(OMFFormat * omf, Linker::Writer& wr) const override;
        };
 
        class LibraryEndRecord : public Record
        {
        public:
            LibraryEndRecord()
                : Record()
            {
            }
 
            LibraryEndRecord(record_type_t record_type)
                : Record(record_type)
            {
            }
 
            using Record::ReadRecordContents;
            void ReadRecordContents(OMF86Format * omf, Linker::Reader& rd) override;
            using Record::GetRecordSize;
            uint16_t GetRecordSize(OMF86Format * omf) const override;
            using Record::WriteRecordContents;
            void WriteRecordContents(OMF86Format * omf, ChecksumWriter& wr) const override;
 
            void WriteRecord(OMFFormat * omf, 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<Module> modules;
 
        // TIS library fields
        uint16_t page_size;
 
        void ReadFile(Linker::Reader& rd) override;
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
        /* TODO */
    };
}
 
#endif /* OMF_H */