RetroLinker/coff_8h_source.html

#ifndef COFF_H

#define COFF_H


#include <array>

#include <map>

#include "cpm68k.h"

#include "mzexe.h"

#include "../common.h"

#include "../linker/module.h"

#include "../linker/options.h"

#include "../linker/segment.h"

#include "../linker/segment_manager.h"

#include "../linker/writer.h"


namespace COFF

{


    class COFFFormat : public virtual Linker::InputFormat, public virtual Linker::SegmentManager

    {

    public:

        /* * * General members * * */


        enum cpu

        {

            CPU_UNKNOWN = 0,


            CPU_I386  = 0x014C,


            CPU_M68K  = 0x0150,


            CPU_W65   = 0x6500,


            CPU_Z80   = 0x805A,


            CPU_Z8K   = 0x8000,


            CPU_I86   = 0x0148,


            CPU_I286  = 0x014A,


            CPU_NS32K = 0x0154,


            CPU_I370  = 0x0158,


            CPU_MIPS  = 0x0160,


            CPU_M88K  = 0x016D,


            CPU_WE32K = 0x0170,


            CPU_VAX   = 0x017D,


            CPU_AM29K = 0x017A,


            CPU_ALPHA = 0x0183,


            CPU_PPC   = 0x01DF,


            CPU_PPC64 = 0x01F7,


            CPU_SHARC = 0x521C,


            CPU_C5400 = 0x0098,

            CPU_C6000 = 0x0099,

            CPU_C5500 = 0x009C,

            CPU_MSP430 = 0x00A0,


            CPU_I860  = 0x014D,


            CPU_SH    = 0x01A2,


            CPU_ARM   = 0x01C0,


            CPU_AM33  = 0x01D3,


            CPU_IA64  = 0x0200,


            CPU_HPPA  = 0x0290,


            CPU_EFI   = 0x0EBC,


            CPU_RISCV32 = 0x5032,


            CPU_RISCV64 = 0x5064,


            CPU_RISCV128 = 0x5128,


            CPU_AMD64 = 0x8664,


            CPU_M32R  = 0x9041,


            CPU_ARM64 = 0xAA64,


            // for now, there are no overloaded values

        };


        enum COFFVariantType

        {

            COFF = 1,

            ECOFF = 2,

            XCOFF32 = 3,

            XCOFF64 = 4,

            PECOFF = 5,

            TICOFF = 6,

            TICOFF1 = 7,

        };


        static constexpr COFFVariantType AnyCOFFVariant = COFFVariantType(0);


        struct MachineType

        {

            cpu actual_cpu;

            ::EndianType endian;

            COFFVariantType coff_variant = AnyCOFFVariant;

        };


        static const std::map<uint32_t, MachineType> MACHINE_TYPES;


        offset_t file_size;


        char signature[2] = { };


        ::EndianType GetEndianType() const;


        enum relocation_format_type

        {

            COFF_10,

            COFF_14,

            COFF_16,

            ECOFF_8,

            ECOFF_16,

            XCOFF_10,

            XCOFF_14,

            TICOFF_10,

            TICOFF_12,

        };


        relocation_format_type relocation_format;


        constexpr size_t GetRelocationEntrySize() const

        {

            switch(relocation_format)

            {

            case COFF_10:

                return 10;

            case COFF_14:

                return 14;

            case COFF_16:

                return 16;

            case ECOFF_8:

                return 8;

            case ECOFF_16:

                return 16;

            case XCOFF_10:

                return 10;

            case XCOFF_14:

                return 14;

            case TICOFF_10:

                return 10;

            case TICOFF_12:

                return 12;

            }

            assert(false);

        }


        // UNIX relocations


        static constexpr uint16_t R_ABS = 0;

        static constexpr uint16_t R_DIR16 = 1;

        static constexpr uint16_t R_REL16 = 2;

        static constexpr uint16_t R_IND16 = 3;

        static constexpr uint16_t R_DIR24 = 4;

        static constexpr uint16_t R_REL24 = 5;

        static constexpr uint16_t R_DIR32 = 6;

        static constexpr uint16_t R_OFF8 = 7;

        static constexpr uint16_t R_OFF16 = 8;

        static constexpr uint16_t R_SEG12 = 9;

        static constexpr uint16_t R_DIR32S = 10;

        static constexpr uint16_t R_AUX = 11;

        static constexpr uint16_t R_OPT16 = 12;

        static constexpr uint16_t R_IND24 = 13;

        static constexpr uint16_t R_IND32 = 14;

        static constexpr uint16_t R_RELBYTE = 15;

        static constexpr uint16_t R_RELWORD = 16;

        static constexpr uint16_t R_RELLONG = 17;

        static constexpr uint16_t R_PCRBYTE = 18;

        static constexpr uint16_t R_PCRWORD = 19;

        static constexpr uint16_t R_PCRLONG = 20;


        // Microsoft relocations (Intel 386)


        static constexpr uint16_t REL_I386_ABSOLUTE = 0;

        static constexpr uint16_t REL_I386_DIR16 = 1;

        static constexpr uint16_t REL_I386_REL16 = 2;

        static constexpr uint16_t REL_I386_DIR32 = 6;

        static constexpr uint16_t REL_I386_DIR32NB = 7;

        static constexpr uint16_t REL_I386_SEG12 = 9;

        static constexpr uint16_t REL_I386_SECTION = 10;

        static constexpr uint16_t REL_I386_SECREL = 11;

        static constexpr uint16_t REL_I386_TOKEN = 12;

        static constexpr uint16_t REL_I386_SECREL7 = 13;

        static constexpr uint16_t REL_I386_REL32 = 20;


        // Microsoft relocations (AMD64)


        static constexpr uint16_t REL_AMD64_ABSOLUTE = 0;

        static constexpr uint16_t REL_AMD64_ADDR64 = 1;

        static constexpr uint16_t REL_AMD64_ADDR32 = 2;

        static constexpr uint16_t REL_AMD64_ADDR32NB = 3;

        static constexpr uint16_t REL_AMD64_REL32 = 4;

        static constexpr uint16_t REL_AMD64_REL32_1 = 5;

        static constexpr uint16_t REL_AMD64_REL32_2 = 6;

        static constexpr uint16_t REL_AMD64_REL32_3 = 7;

        static constexpr uint16_t REL_AMD64_REL32_4 = 8;

        static constexpr uint16_t REL_AMD64_REL32_5 = 9;

        static constexpr uint16_t REL_AMD64_SECTION = 10;

        static constexpr uint16_t REL_AMD64_SECREL = 11;

        static constexpr uint16_t REL_AMD64_SECREL7 = 12;

        static constexpr uint16_t REL_AMD64_TOKEN = 13;

        static constexpr uint16_t REL_AMD64_SREL32 = 14;

        static constexpr uint16_t REL_AMD64_PAIR = 15;

        static constexpr uint16_t REL_AMD64_SSPAN32 = 16;


        // Microsoft relocations (ARM)


        static constexpr uint16_t REL_ARM_ABSOLUTE = 0;

        static constexpr uint16_t REL_ARM_ADDR32 = 1;

        static constexpr uint16_t REL_ARM_ADDR32NB = 2;

        static constexpr uint16_t REL_ARM_BRANCH24 = 3;

        static constexpr uint16_t REL_ARM_BRANCH11 = 4;

        static constexpr uint16_t REL_ARM_REL32 = 10;

        static constexpr uint16_t REL_ARM_SECTION = 14;

        static constexpr uint16_t REL_ARM_SECREL = 15;

        static constexpr uint16_t REL_ARM_MOV32 = 16;

        static constexpr uint16_t REL_THUMB_MOV32 = 17;

        static constexpr uint16_t REL_THUMB_BRANCH24 = 20;

        static constexpr uint16_t REL_THUMB_BLX23 = 21;

        static constexpr uint16_t REL_ARM_PAIR = 22;


        // Microsoft relocations (ARM64)


        static constexpr uint16_t REL_ARM64_ABSOLUTE = 0;

        static constexpr uint16_t REL_ARM64_ADDR32 = 1;

        static constexpr uint16_t REL_ARM64_ADDR32NB = 2;

        static constexpr uint16_t REL_ARM64_BRANCH26 = 3;

        static constexpr uint16_t REL_ARM64_PAGEBASE_REL21 = 4;

        static constexpr uint16_t REL_ARM64_REL21 = 5;

        static constexpr uint16_t REL_ARM64_PAGEOFFSET_12A = 6;

        static constexpr uint16_t REL_ARM64_PAGEOFFSET_12L = 7;

        static constexpr uint16_t REL_ARM64_SECREL = 8;

        static constexpr uint16_t REL_ARM64_SECREL_LOW12A = 9;

        static constexpr uint16_t REL_ARM64_SECREL_HIGH12A = 10;

        static constexpr uint16_t REL_ARM64_SECREL_LOW12L = 11;

        static constexpr uint16_t REL_ARM64_TOKEN = 12;

        static constexpr uint16_t REL_ARM64_SECTION = 13;

        static constexpr uint16_t REL_ARM64_ADDR64 = 14;

        static constexpr uint16_t REL_ARM64_BRANCH19 = 15;

        static constexpr uint16_t REL_ARM64_BRANCH14 = 16;

        static constexpr uint16_t REL_ARM64_REL32 = 17;


        // TODO: Microsoft relocations (MIPS)


        // Microsoft relocations (Alpha)


        static constexpr uint16_t REL_ALPHA_ABSOLUTE = 0;

        static constexpr uint16_t REL_ALPHA_REFLONG = 1;

        static constexpr uint16_t REL_ALPHA_REFQUAD = 2;

        static constexpr uint16_t REL_ALPHA_GPREL32 = 3;

        static constexpr uint16_t REL_ALPHA_LITERAL = 4;

        static constexpr uint16_t REL_ALPHA_LITUSE = 5;

        static constexpr uint16_t REL_ALPHA_GPDISP = 6;

        static constexpr uint16_t REL_ALPHA_BRADDR = 7;

        static constexpr uint16_t REL_ALPHA_HINT = 8;

        static constexpr uint16_t REL_ALPHA_INLINE_REFLONG = 9;

        static constexpr uint16_t REL_ALPHA_REFHI = 10;

        static constexpr uint16_t REL_ALPHA_REFLO = 11;

        static constexpr uint16_t REL_ALPHA_PAIR = 12;

        static constexpr uint16_t REL_ALPHA_MATCH = 13;

        static constexpr uint16_t REL_ALPHA_SECTION = 14;

        static constexpr uint16_t REL_ALPHA_SECREL = 15;

        static constexpr uint16_t REL_ALPHA_REFLONGNB = 16;

        static constexpr uint16_t REL_ALPHA_SECRELLO = 17;

        static constexpr uint16_t REL_ALPHA_SECRELHI = 18;

        static constexpr uint16_t REL_ALPHA_REFQ3 = 19;

        static constexpr uint16_t REL_ALPHA_REFQ2 = 20;

        static constexpr uint16_t REL_ALPHA_REFQ1 = 21;

        static constexpr uint16_t REL_ALPHA_GPRELLO = 22;

        static constexpr uint16_t REL_ALPHA_GPRELHI = 23;


        // TODO: Microsoft relocations (PowerPC)

        // TODO: Microsoft relocations (IA64)


        // TODO: Microsoft relocations (SuperH)


        // Other relocation types


        // https://github.com/aixoss/binutils/blob/master/include/coff/internal.h

        // https://github.com/aixoss/binutils/blob/master/include/coff/z80.h

        // https://github.com/aixoss/binutils/blob/master/include/coff/z8k.h


        static constexpr uint16_t R_Z80_IMM8  = 0x22;

        static constexpr uint16_t R_Z80_IMM16 = 0x01;

        static constexpr uint16_t R_Z80_IMM24 = 0x33;

        static constexpr uint16_t R_Z80_IMM32 = 0x17;

        static constexpr uint16_t R_Z80_OFF8  = 0x32;

        static constexpr uint16_t R_Z80_JR    = 0x02;


        static constexpr uint16_t R_Z8K_IMM4L = 0x23;

        static constexpr uint16_t R_Z8K_IMM4H = 0x24;

        static constexpr uint16_t R_Z8K_DISP7 = 0x25; /* djnz */

        static constexpr uint16_t R_Z8K_IMM8  = 0x22;

        static constexpr uint16_t R_Z8K_IMM16 = 0x01;

        static constexpr uint16_t R_Z8K_REL16 = 0x04;

        static constexpr uint16_t R_Z8K_IMM32 = 0x11;

        static constexpr uint16_t R_Z8K_JR    = 0x02; /* jr */

        static constexpr uint16_t R_Z8K_CALLR = 0x05; /* callr */


        static constexpr uint16_t R_W65_ABS8     = 0x01;

        static constexpr uint16_t R_W65_ABS16    = 0x02;

        static constexpr uint16_t R_W65_ABS24    = 0x03;

        static constexpr uint16_t R_W65_ABS8S8   = 0x04;

        static constexpr uint16_t R_W65_ABS8S16  = 0x05;

        static constexpr uint16_t R_W65_ABS16S8  = 0x06;

        static constexpr uint16_t R_W65_ABS16S16 = 0x07;

        static constexpr uint16_t R_W65_PCR8     = 0x08;

        static constexpr uint16_t R_W65_PCR16    = 0x09;

        static constexpr uint16_t R_W65_DP       = 0x0A;


        class Relocation

        {

        public:

            offset_t address;

            uint32_t symbol_index;

            uint32_t offset;

            uint16_t type;

            uint16_t information;


            void Read(Linker::Reader& rd, const COFFFormat& coff);


            size_t GetSize(const COFFFormat& coff) const;

            void WriteFile(Linker::Writer& wr, const COFFFormat& coff) const;

            void FillEntry(Dumper::Entry& entry, const COFFFormat& coff) const;

        };


        class Symbol

        {

        public:

            std::string name;

            uint32_t name_index;

            uint32_t value;

            uint16_t section_number;

            uint16_t type;

            uint8_t storage_class;

            uint8_t auxiliary_count;


            void Read(Linker::Reader& rd);


            bool IsExternal() const;


            class AuxiliaryEntry

            {

            public:

                virtual ~AuxiliaryEntry() = default;

                virtual void Read(Linker::Reader& rd) = 0;

                virtual void Write(Linker::Writer& wr) const = 0;

                virtual void FillDumpData(Dumper::Entry& entry) const = 0;

            };


            class FileNameAuxiliaryEntry : public AuxiliaryEntry

            {

            public:

                std::string file_name;


                void Read(Linker::Reader& rd) override;

                void Write(Linker::Writer& wr) const override;

                void FillDumpData(Dumper::Entry& entry) const override;

            };


            class SectionAuxiliaryEntry : public AuxiliaryEntry

            {

            public:

                // TODO

                int32_t section_length;

                uint16_t relocation_entry_count;

                uint16_t line_number_count;


                void Read(Linker::Reader& rd) override;

                void Write(Linker::Writer& wr) const override;

                void FillDumpData(Dumper::Entry& entry) const override;

            };


            class TagNameAuxiliaryEntry : public AuxiliaryEntry

            {

            public:

                // TODO

                // skip 6 bytes

                uint16_t size;

                // skip 4 bytes

                int32_t next_entry_index;


                void Read(Linker::Reader& rd) override;

                void Write(Linker::Writer& wr) const override;

                void FillDumpData(Dumper::Entry& entry) const override;

            };


            class EndOfStructureAuxiliaryEntry : public AuxiliaryEntry

            {

            public:

                // TODO

                int32_t tag_index;

                // skip 2 bytes

                uint16_t size;

                // skip 4 bytes


                void Read(Linker::Reader& rd) override;

                void Write(Linker::Writer& wr) const override;

                void FillDumpData(Dumper::Entry& entry) const override;

            };


            class FunctionAuxiliaryEntry : public AuxiliaryEntry

            {

            public:

                // TODO

                int32_t tag_index;

                int32_t size;

                int32_t pointer_to_line_number;

                int32_t next_entry_index;

                uint16_t transfer_table_index;


                void Read(Linker::Reader& rd) override;

                void Write(Linker::Writer& wr) const override;

                void FillDumpData(Dumper::Entry& entry) const override;

            };


            class ArrayAuxiliaryEntry : public AuxiliaryEntry

            {

            public:

                // TODO

                int32_t tag_index;

                uint16_t declaration_line_number;

                uint16_t size;

                std::array<uint16_t, 4> dimensions;


                void Read(Linker::Reader& rd) override;

                void Write(Linker::Writer& wr) const override;

                void FillDumpData(Dumper::Entry& entry) const override;

            };


            class BeginOrEndAuxiliaryEntry : public AuxiliaryEntry

            {

            public:

                // TODO

                // skip 4 bytes

                uint16_t line_number;

                // skip 6 bytes

                int32_t next_entry_index; // TODO: only for beginning


                void Read(Linker::Reader& rd) override;

                void Write(Linker::Writer& wr) const override;

                void FillDumpData(Dumper::Entry& entry) const override;

            };


            class StructureAuxiliaryEntry : public AuxiliaryEntry

            {

            public:

                // TODO

                int32_t tag_index;

                // skip 2 bytes

                uint16_t size;


                void Read(Linker::Reader& rd) override;

                void Write(Linker::Writer& wr) const override;

                void FillDumpData(Dumper::Entry& entry) const override;

            };


            std::unique_ptr<AuxiliaryEntry> auxiliary_entry = nullptr;


            enum

            {

                C_EFCN = uint8_t(-1),

                C_NULL = 0,

                C_AUTO,

                C_EXT,

                C_STAT,

                C_REG,

                C_EXTDEF,

                C_LABEL,

                C_ULABEL,

                C_MOS,

                C_ARG,

                C_STRTAG,

                C_MOU,

                C_UNTAG,

                C_TPDEF,

                C_USTATIC,

                C_ENTAG,

                C_MOE,

                C_REGPARM,

                C_FIELD,

                C_BLOCK = 100,

                C_FCN,

                C_EOS,

                C_FILE,

                C_LINE,

                C_ALIAS,

                C_HIDDEN,

                C_SHADOW,

                C_WEAKEXT

            };


            enum

            {

                N_DEBUG = uint16_t(-2),

                N_ABS = uint16_t(-1),

                N_UNDEF = 0,

            };


            enum

            {

                T_NULL = 0,

                T_ARG,

                T_CHAR,

                T_SHORT,

                T_INT,

                T_LONG,

                T_FLOAT,

                T_DOUBLE,

                T_STRUCT,

                T_UNION,

                T_ENUM,

                T_MOE,

                T_UCHAR,

                T_USHORT,

                T_UINT,

                T_ULONG,

            };


            enum

            {

                DT_NON = 0,

                DT_PTR,

                DT_FCN,

                DT_ARY,

            };

        };


        class Section

        {

        public:

            std::string name;

            offset_t physical_address = 0;

            offset_t address = 0;

            offset_t size = 0;

            offset_t section_pointer = 0;

            offset_t relocation_pointer = 0;

            offset_t line_number_pointer = 0;

            uint32_t relocation_count = 0;

            uint32_t line_number_count = 0;

            uint32_t flags = 0;

            uint16_t memory_page_number = 0;


            std::shared_ptr<Linker::Contents> image;


            std::vector<std::unique_ptr<Relocation>> relocations;


            /* COFF section flags (common to all variants) */

            static constexpr uint32_t TEXT  = 0x0020;

            static constexpr uint32_t DATA  = 0x0040;

            static constexpr uint32_t BSS   = 0x0080;


            /* UNIX COFF section flags */


            struct COFF_Flags

            {

                static constexpr uint32_t DSECT  = 0x0001;

                static constexpr uint32_t NOLOAD = 0x0002;

                static constexpr uint32_t GROUP  = 0x0004;

                static constexpr uint32_t PAD    = 0x0008;

                static constexpr uint32_t COPY   = 0x0010;

                static constexpr uint32_t INFO   = 0x0200;

                static constexpr uint32_t OVER   = 0x0400;

                static constexpr uint32_t LIB    = 0x0800;

            };


            /* ECOFF section flags */


            struct ECOFF_Flags

            {

                static constexpr uint32_t RDATA    = 0x00000100;

                static constexpr uint32_t SDATA    = 0x00000200;

                static constexpr uint32_t SBSS     = 0x00000400;

                static constexpr uint32_t UCODE    = 0x00000800;

                static constexpr uint32_t GOT      = 0x00001000;

                static constexpr uint32_t DYNAMIC  = 0x00002000;

                static constexpr uint32_t DYNSYM   = 0x00004000;

                static constexpr uint32_t REL_DYN  = 0x00008000;

                static constexpr uint32_t DYNSTR   = 0x00010000;

                static constexpr uint32_t HASH     = 0x00020000;

                static constexpr uint32_t DSOLIST  = 0x00040000;

                static constexpr uint32_t MSYM     = 0x00080000;

                static constexpr uint32_t EXTMASK  = 0x0FF00000;

                static constexpr uint32_t CONFLICT = 0x00100000;

                static constexpr uint32_t FINI     = 0x01000000;

                static constexpr uint32_t COMMENT  = 0x02000000;

                static constexpr uint32_t RCONST   = 0x02200000;

                static constexpr uint32_t XDATA    = 0x02400000;

                static constexpr uint32_t TLSDATA  = 0x02500000;

                static constexpr uint32_t TLSBSS   = 0x02600000;

                static constexpr uint32_t TLSINIT  = 0x02700000;

                static constexpr uint32_t PDATA    = 0x02800000;

                static constexpr uint32_t LITA     = 0x04000000;

                static constexpr uint32_t LIT8     = 0x08000000;

                static constexpr uint32_t LIT4     = 0x10000000;

                static constexpr uint32_t NRELOC_OVERFLOWED = 0x20000000;

                static constexpr uint32_t INIT     = 0x80000000;

            };


            /* PE section flags */


            struct PECOFF_Flags

            {

                static constexpr uint32_t TYPE_NO_PAD = 0x00000008;

                static constexpr uint32_t LNK_OTHER = 0x00000100;

                static constexpr uint32_t LNK_INFO = 0x00000200;

                static constexpr uint32_t LNK_REMOVE = 0x00000800;

                static constexpr uint32_t LNK_COMDAT = 0x00001000;

                static constexpr uint32_t GPREL = 0x00008000;

                static constexpr uint32_t MEM_PURGEABLE = 0x00010000;

                static constexpr uint32_t MEM_16BIT = 0x00020000;

                static constexpr uint32_t MEM_LOCKED = 0x00040000;

                static constexpr uint32_t MEM_PRELOAD = 0x00080000;

                static constexpr uint32_t ALIGN_MASK = 0x00F00000;

                static constexpr uint32_t ALIGN_SHIFT = 20;

                static constexpr uint32_t LNK_NRELOC_OVFL = 0x01000000;

                static constexpr uint32_t MEM_DISCARDABLE = 0x02000000;

                static constexpr uint32_t MEM_NOT_CACHED = 0x04000000;

                static constexpr uint32_t MEM_NOT_PAGED = 0x08000000;

                static constexpr uint32_t MEM_SHARED = 0x10000000;

                static constexpr uint32_t MEM_EXECUTE = 0x20000000;

                static constexpr uint32_t MEM_READ = 0x40000000;

                static constexpr uint32_t MEM_WRITE = 0x80000000;

            };


            /* XCOFF section flags */


            struct XCOFF_Flags

            {

                static constexpr uint32_t PAD = 0x0008;

                static constexpr uint32_t DWARF = 0x0010;

                static constexpr uint32_t EXCEPT = 0x0100;

                static constexpr uint32_t INFO = 0x0200;

                static constexpr uint32_t TDATA = 0x0400;

                static constexpr uint32_t TBSS = 0x0800;

                static constexpr uint32_t LOADER = 0x1000;

                static constexpr uint32_t DEBUG = 0x2000;

                static constexpr uint32_t TYPCHK = 0x4000;

                static constexpr uint32_t OVERFLO = 0x8000;

            };


            /* TICOFF section flags */


            struct TICOFF_Flags

            {

                static constexpr uint32_t DSECT  = 0x00000001;

                static constexpr uint32_t NOLOAD = 0x00000002;

                static constexpr uint32_t GROUP  = 0x00000004;

                static constexpr uint32_t PAD    = 0x00000008;

                static constexpr uint32_t COPY   = 0x00000010;

                static constexpr uint32_t BLOCK  = 0x00010000;

                static constexpr uint32_t PASS   = 0x00020000;

                static constexpr uint32_t CLINK  = 0x00040000;

                static constexpr uint32_t VECTOR = 0x00080000;

                static constexpr uint32_t PADDED = 0x00100000;

            };


            void Clear();


            Section(uint32_t flags = 0, std::shared_ptr<Linker::Contents> image = nullptr)

                : flags(flags), image(image)

            {

            }


            virtual ~Section();


            bool PresentInFile(COFFVariantType coff_variant) const;

            bool PresentInMemory(COFFVariantType coff_variant) const;


            void ReadSectionHeader(Linker::Reader& rd, COFFFormat& coff_format);


            void WriteSectionHeader(Linker::Writer& wr, const COFFFormat& coff_format);


            virtual uint32_t ImageSize(const COFFFormat& coff_format) const;


            virtual void ReadSectionData(Linker::Reader& rd, const COFFFormat& coff_format);

            virtual void WriteSectionData(Linker::Writer& wr, const COFFFormat& coff_format) const;

            virtual void Dump(Dumper::Dumper& dump, const COFFFormat& format, unsigned section_index) const;

        };


        std::vector<std::shared_ptr<Section>> sections;


        uint16_t section_count = 0;

        uint32_t timestamp = 0;

        offset_t symbol_table_offset = 0;

        uint32_t symbol_count = 0;

        std::vector<std::unique_ptr<Symbol>> symbols;

        uint32_t optional_header_size = 0;

        uint16_t flags = 0;

        uint16_t target = 0;


        class OptionalHeader

        {

        public:

            virtual ~OptionalHeader();

            virtual uint32_t GetSize() const = 0;

            virtual void ReadFile(Linker::Reader& rd) = 0;

            virtual void WriteFile(Linker::Writer& wr) const = 0;

            virtual offset_t CalculateValues(COFFFormat& coff) = 0;

            virtual void PostReadFile(COFFFormat& coff, Linker::Reader& rd);

            virtual void PostWriteFile(const COFFFormat& coff, Linker::Writer& wr) const;


            virtual void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const;

        };


        std::unique_ptr<OptionalHeader> optional_header = nullptr;


        struct CDOS68K_Relocation

        {

            size_t size;

            CDOS68K_Relocation(size_t size = 0)

                : size(size)

            {

            }

            operator size_t() const;

            static CDOS68K_Relocation Create(size_t size, uint32_t offset, const COFFFormat& format);

        };


        std::map<uint32_t, CDOS68K_Relocation> relocations; /* CDOS68K */


        class UnknownOptionalHeader : public OptionalHeader

        {

        public:

            std::unique_ptr<Linker::Buffer> buffer = nullptr;


            UnknownOptionalHeader(offset_t size)

                : buffer(std::make_unique<Linker::Buffer>(size))

            {

            }


            uint32_t GetSize() const override;


            void ReadFile(Linker::Reader& rd) override;


            void WriteFile(Linker::Writer& wr) const override;


            offset_t CalculateValues(COFFFormat& coff) override;


            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const override;

        };


        class AOutHeader : public OptionalHeader

        {

        public:

            uint16_t magic = 0;

            uint16_t version_stamp = 0;


            uint32_t code_size = 0;

            uint32_t data_size = 0;

            uint32_t bss_size = 0;

            uint32_t entry_address = 0;

            uint32_t code_address = 0;

            uint32_t data_address = 0;


            AOutHeader(uint16_t magic = 0)

                : magic(magic)

            {

            }


            uint32_t GetSize() const override;


            void ReadFile(Linker::Reader& rd) override;


            void WriteFile(Linker::Writer& wr) const override;


            offset_t CalculateValues(COFFFormat& coff) override;


        protected:

            virtual void DumpFields(const COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) const;


        public:

            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const override;

        };


        class AOutHeader3B20 : public AOutHeader

        {

        public:

            uint32_t reserved1 = 0;

            uint32_t reserved2 = 0;


            AOutHeader3B20(uint16_t magic = 0)

                : AOutHeader(magic)

            {

            }


            uint32_t GetSize() const override;


            void ReadFile(Linker::Reader& rd) override;


            void WriteFile(Linker::Writer& wr) const override;


            //offset_t CalculateValues(COFFFormat& coff) override;


        protected:

            void DumpFields(const COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) const override;


        //public:

        //  void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const override;

        };


        class FlexOSAOutHeader : public AOutHeader

        {

        public:

            FlexOSAOutHeader(uint16_t magic = 0)

                : AOutHeader(magic)

            {

            }


            uint32_t relocations_offset = 0;

            uint32_t stack_size = 0;


            /* TODO: magic not needed for CDOS68K? */


            uint32_t GetSize() const override;


            void ReadFile(Linker::Reader& rd) override;


            void WriteFile(Linker::Writer& wr) const override;


            offset_t CalculateValues(COFFFormat& coff) override;


            void PostReadFile(COFFFormat& coff, Linker::Reader& rd) override;


            void PostWriteFile(const COFFFormat& coff, Linker::Writer& wr) const override;


        protected:

            void DumpFields(const COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) const override;

        };


        class GNUAOutHeader : public OptionalHeader

        {

        public:

            /* Note: untested */

            uint32_t info = 0;

            uint32_t code_size = 0;

            uint32_t data_size = 0;

            uint32_t bss_size = 0;

            uint32_t symbol_table_size = 0;

            uint32_t entry_address = 0;

            uint32_t code_relocation_size = 0;

            uint32_t data_relocation_size = 0;


            uint32_t GetSize() const override;


            void ReadFile(Linker::Reader& wr) override;


            void WriteFile(Linker::Writer& wr) const override;


            offset_t CalculateValues(COFFFormat& coff) override;


            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const override;

        };


        class MIPSAOutHeader : public AOutHeader

        {

        public:

            // https://web.archive.org/web/20140723105157/http://www-scf.usc.edu/~csci402/ncode/coff_8h-source.html

            /* bss_start */

            uint32_t bss_address;

            /* gpr_mask */

            uint32_t gpr_mask;

            /* cprmask */

            uint32_t cpr_mask[4];

            /* gp_value */

            uint32_t gp_value;


            MIPSAOutHeader(uint16_t magic = 0)

                : AOutHeader(magic)

            {

            }


            uint32_t GetSize() const override;


            void ReadFile(Linker::Reader& rd) override;


            void WriteFile(Linker::Writer& wr) const override;


            offset_t CalculateValues(COFFFormat& coff) override;


        protected:

            void DumpFields(const COFFFormat& coff, Dumper::Dumper& dump, Dumper::Region& header_region) const override;

        };


        class ECOFFAOutHeader : public OptionalHeader

        {

        public:

            uint16_t magic = 0;

            static constexpr uint16_t SYM_STAMP = 0x030D;

            uint16_t version_stamp = SYM_STAMP;

            uint16_t build_revision = 0;


            uint64_t code_size = 0;

            uint64_t data_size = 0;

            uint64_t bss_size = 0;

            uint64_t entry_address = 0;

            uint64_t code_address = 0;

            uint64_t data_address = 0;

            uint64_t bss_address = 0;

            uint32_t gpr_mask = 0;

            uint32_t fpr_mask = 0;

            uint64_t global_pointer = 0;


            ECOFFAOutHeader(uint16_t magic = 0)

                : magic(magic)

            {

            }


            uint32_t GetSize() const override;


            void ReadFile(Linker::Reader& rd) override;


            void WriteFile(Linker::Writer& wr) const override;


            offset_t CalculateValues(COFFFormat& coff) override;


            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const override;

        };


        class XCOFFAOutHeader : public OptionalHeader

        {

        public:

            bool is64 = false;

            uint16_t magic = 0;

            uint16_t version_stamp = 0;

            uint64_t code_size = 0;

            uint64_t data_size = 0;

            uint64_t bss_size = 0;

            uint64_t entry_address = 0;

            uint64_t code_address = 0;

            uint64_t data_address = 0;

            uint64_t toc_address = 0;

            uint16_t entry_section = 0;

            uint16_t code_section = 0;

            uint16_t data_section = 0;

            uint16_t toc_section = 0;

            uint16_t loader_section = 0;

            uint16_t bss_section = 0;

            uint16_t code_align = 0;

            uint16_t data_align = 0;

            uint16_t module_type = 0;

            uint8_t cpu_flags = 0;

            uint8_t cpu_type = 0;

            uint64_t maximum_stack_size = 0;

            uint64_t maximum_data_size = 0;

            uint32_t debugger_data = 0;

            uint8_t code_page_size = 0;

            uint8_t text_page_size = 0;

            uint8_t stack_page_size = 0;

            uint8_t flags = 0;

            uint16_t tdata_section = 0;

            uint16_t tbss_section = 0;

            uint32_t xcoff64_flags = 0;

#if 0

            uint8_t shared_memory_page = 0;

#endif


            XCOFFAOutHeader(bool is64, uint16_t magic = 0)

                : is64(is64), magic(magic)

            {

            }


            uint32_t GetSize() const override;


            void ReadFile(Linker::Reader& rd) override;


            void WriteFile(Linker::Writer& wr) const override;


            offset_t CalculateValues(COFFFormat& coff) override;


            void Dump(const COFFFormat& coff, Dumper::Dumper& dump) const override;

        };


        void Clear() override;


        void AssignMagicValue(uint16_t value, ::EndianType as_endian_type);

        void AssignMagicValue(uint16_t value);

        void AssignMagicValue();


        COFFVariantType coff_variant = AnyCOFFVariant;


        cpu cpu_type = CPU_UNKNOWN;


        ::EndianType endiantype = ::UndefinedEndian;


        bool DetectCpuType(::EndianType expected);


        void DetectCpuType();


        void ReadFile(Linker::Reader& rd) override;


    protected:

        void ReadCOFFHeader(Linker::Reader& rd);

        void ReadOptionalHeader(Linker::Reader& rd);

        void ReadRestOfFile(Linker::Reader& rd);


    public:

        offset_t ImageSize() const override;


        using Linker::Format::WriteFile;

        offset_t WriteFile(Linker::Writer& wr) const override;


    protected:

        offset_t WriteFileContents(Linker::Writer& wr) const;


    public:

        void Dump(Dumper::Dumper& dump) const override;


        /* * * Reader members * * */


        void SetupOptions(std::shared_ptr<Linker::OutputFormat> format) override;


        bool option_segmentation = false;


        bool FormatRequiresDataStreamFix() const override;


    private:

        /* symbols */

        std::string segment_prefix();


        std::string segment_of_prefix();


        std::string segmented_address_prefix();


#if 0

        // TODO: can this be used?

        std::string segment_difference_prefix();

#endif


        enum

        {

            /* section number */

            N_UNDEF = 0,

            N_ABS = 0xFFFF,

            N_DEBUG = 0xFFFE,


            /* storage class */

            C_EXT = 2,

            C_STAT = 3,

            C_LABEL = 6,

        };


    public:

        using Linker::InputFormat::GenerateModule;

        void GenerateModule(Linker::Module& module) const override;


        /* * * Writer members * * */


        enum opthdr_magic_type

        {

            OMAGIC = 0x0107,

            NMAGIC = 0x0108,

            ZMAGIC = 0x010B,

            SHMAGIC = 0x012B,

            MAGIC_FLEXOS386 = 0x01C0,

        };


        opthdr_magic_type magic_type = opthdr_magic_type(0);

        bool option_unmapped_zero_page = false;


        class COFFOptionCollector : public Linker::OptionCollector

        {

        public:


            class MagicEnumeration : public Linker::Enumeration<opthdr_magic_type>

            {

            public:

                MagicEnumeration()

                    : Enumeration(

                        "OMAGIC", OMAGIC,

                        "IMPURE", OMAGIC,

                        "NMAGIC", NMAGIC,

                        "ROTEXT", NMAGIC,

                        "PURE", NMAGIC,

                        "ZMAGIC", ZMAGIC,

                        "DEMANDPAGED", ZMAGIC)

                {

                    descriptions = {

                        { OMAGIC, "Impure executable (OMAGIC)" },

                        { NMAGIC, "Pure executable (NMAGIC)" },

                        { ZMAGIC, "Demand paged executable (ZMAGIC)" },

                    };

                }

            };


            Linker::Option<std::string> stub{"stub", "Filename for stub that gets prepended to executable"};

            Linker::Option<Linker::ItemOf<MagicEnumeration>> type{"type", "Executable type"};

            Linker::Option<bool> Nflag{"N", "Impure executable (OMAGIC)"};

            Linker::Option<bool> nflag{"n", "Pure executable (NMAGIC)"};

            Linker::Option<bool> zflag{"z", "Demand paged executable (ZMAGIC)"};


            // TODO: make stack size a parameter (for FlexOS)


            COFFOptionCollector()

            {

                InitializeFields(stub, type, Nflag, nflag, zflag);

            }

        };


        // for DJGPP binaries

        mutable Microsoft::MZSimpleStubWriter stub;


        enum format_type

        {

            GENERIC,

            UNIX,

            UNIX_3B20,

            UNIX_3B5,

            UNIX_3B2,

            DJGPP,

            CDOS68K,

            CDOS386,

            WINDOWS,

        };


        format_type type = GENERIC;


        bool option_no_relocation = false;


        uint32_t stub_size = 0;


        std::shared_ptr<Linker::Segment> stack;

        uint32_t entry_address = 0; /* TODO */

        uint32_t relocations_offset = 0;


        COFFFormat(format_type type = GENERIC, COFFVariantType coff_variant = COFF, EndianType endiantype = ::UndefinedEndian)

            : coff_variant(coff_variant), endiantype(endiantype), type(type)

        {

        }


        ~COFFFormat()

        {

            Clear();

        }


        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;


        static std::vector<Linker::OptionDescription<void> *> ParameterNames;

        std::vector<Linker::OptionDescription<void> *> GetLinkerScriptParameterNames() override;


        std::shared_ptr<Linker::OptionCollector> GetOptions() override;


        void SetOptions(std::map<std::string, std::string>& options) override;


        enum

        {

            FLAG_NO_RELOCATIONS = 0x0001,

            FLAG_EXECUTABLE = 0x0002,

            FLAG_NO_LINE_NUMBERS = 0x0004,

            FLAG_NO_SYMBOLS = 0x0008,

            FLAG_PDP11_ENDIAN = 0x0080,

            FLAG_32BIT_LITTLE_ENDIAN = 0x0100,

            FLAG_32BIT_BIG_ENDIAN = 0x0200,

        };


        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;


        void CreateDefaultSegments();


        std::unique_ptr<Script::List> GetScript(Linker::Module& module);


        void Link(Linker::Module& module);


        std::shared_ptr<Linker::Segment> GetSegment(std::shared_ptr<Section>& section);


        std::shared_ptr<Linker::Segment> GetCodeSegment();


        std::shared_ptr<Linker::Segment> GetDataSegment();


        std::shared_ptr<Linker::Segment> GetBssSegment();


        void ProcessModule(Linker::Module& module) override;


        void CalculateValues() override;


        void GenerateFile(std::string filename, Linker::Module& module) override;


        using Linker::OutputFormat::GetDefaultExtension;

        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;

    };


}


#endif /* COFF_H */

COFF::COFFFormat::AOutHeader3B20
AT&T 3B20 36 byte a.out optional header.
Definition coff.h:1363

COFF::COFFFormat::AOutHeader3B20::GetSize
uint32_t GetSize() const override
Returns size of optional header.
Definition coff.cc:1443

COFF::COFFFormat::AOutHeader
A standard 28 byte a.out optional header, used by AT&T UNIX and DJGPP.
Definition coff.h:1303

COFF::COFFFormat::AOutHeader::code_address
uint32_t code_address
Address of code (COFF name: text_start)
Definition coff.h:1333

COFF::COFFFormat::AOutHeader::version_stamp
uint16_t version_stamp
Version stamp (COFF name: vstamp)
Definition coff.h:1312

COFF::COFFFormat::AOutHeader::entry_address
uint32_t entry_address
Initial value of eip (COFF name: entry)
Definition coff.h:1329

COFF::COFFFormat::AOutHeader::magic
uint16_t magic
Type of executable, most typically ZMAGIC (COFF name: magic)
Definition coff.h:1308

COFF::COFFFormat::AOutHeader::code_size
uint32_t code_size
Code size (COFF name: tsize)
Definition coff.h:1317

COFF::COFFFormat::AOutHeader::GetSize
uint32_t GetSize() const override
Returns size of optional header.
Definition coff.cc:1358

COFF::COFFFormat::AOutHeader::data_size
uint32_t data_size
Data size (COFF name: dsize)
Definition coff.h:1321

COFF::COFFFormat::AOutHeader::bss_size
uint32_t bss_size
BSS size (COFF name: bsize)
Definition coff.h:1325

COFF::COFFFormat::AOutHeader::data_address
uint32_t data_address
Address of data (COFF name: data_start)
Definition coff.h:1337

COFF::COFFFormat::COFFOptionCollector::MagicEnumeration
Definition coff.h:1838

COFF::COFFFormat::COFFOptionCollector
Definition coff.h:1835

COFF::COFFFormat::ECOFFAOutHeader
ECOFF optional header.
Definition coff.h:1496

COFF::COFFFormat::ECOFFAOutHeader::bss_address
uint64_t bss_address
Base address for bss segment (ECOFF name: bss_start)
Definition coff.h:1539

COFF::COFFFormat::ECOFFAOutHeader::gpr_mask
uint32_t gpr_mask
unused (ECOFF name: gprmask)
Definition coff.h:1541

COFF::COFFFormat::ECOFFAOutHeader::magic
uint16_t magic
Type of executable.
Definition coff.h:1501

COFF::COFFFormat::ECOFFAOutHeader::data_size
uint64_t data_size
Size of data segment (ECOFF name: dsize)
Definition coff.h:1519

COFF::COFFFormat::ECOFFAOutHeader::GetSize
uint32_t GetSize() const override
Returns size of optional header.
Definition coff.cc:1644

COFF::COFFFormat::ECOFFAOutHeader::version_stamp
uint16_t version_stamp
Object file version stamp (ECOFF name: vstamp)
Definition coff.h:1506

COFF::COFFFormat::ECOFFAOutHeader::bss_size
uint64_t bss_size
Size of bss segment (ECOFF name: bsize)
Definition coff.h:1523

COFF::COFFFormat::ECOFFAOutHeader::fpr_mask
uint32_t fpr_mask
unused (ECOFF name: fprmask)
Definition coff.h:1543

COFF::COFFFormat::ECOFFAOutHeader::global_pointer
uint64_t global_pointer
Initial global pointer value (ECOFF name: gp_value)
Definition coff.h:1545

COFF::COFFFormat::ECOFFAOutHeader::data_address
uint64_t data_address
Base address for data segment (ECOFF name: data_start)
Definition coff.h:1535

COFF::COFFFormat::ECOFFAOutHeader::code_address
uint64_t code_address
Base address for code segment (ECOFF name: text_start)
Definition coff.h:1531

COFF::COFFFormat::ECOFFAOutHeader::build_revision
uint16_t build_revision
Revision build of system tools (ECOFF name: bldrev)
Definition coff.h:1510

COFF::COFFFormat::ECOFFAOutHeader::code_size
uint64_t code_size
Size of code segment (ECOFF name: tsize)
Definition coff.h:1515

COFF::COFFFormat::ECOFFAOutHeader::entry_address
uint64_t entry_address
Virtual address of execution start (ECOFF name: entry)
Definition coff.h:1527

COFF::COFFFormat::FlexOSAOutHeader
Concurrent DOS 68K/FlexOS 386 optional header Concurrent DOS 68K uses the typical a....
Definition coff.h:1393

COFF::COFFFormat::FlexOSAOutHeader::GetSize
uint32_t GetSize() const override
Returns size of optional header.
Definition coff.cc:1483

COFF::COFFFormat::FlexOSAOutHeader::PostReadFile
void PostReadFile(COFFFormat &coff, Linker::Reader &rd) override
Retrieves any additional data from the file corresponding to this type of optional header.
Definition coff.cc:1510

COFF::COFFFormat::FlexOSAOutHeader::PostWriteFile
void PostWriteFile(const COFFFormat &coff, Linker::Writer &wr) const override
Stores any additional data in the file corresponding to this type of optional header.
Definition coff.cc:1519

COFF::COFFFormat::FlexOSAOutHeader::stack_size
uint32_t stack_size
Size of stack for execution.
Definition coff.h:1407

COFF::COFFFormat::FlexOSAOutHeader::relocations_offset
uint32_t relocations_offset
The offset to the crunched relocation data within the file.
Definition coff.h:1403

COFF::COFFFormat::GNUAOutHeader
GNU a.out optional header TODO.
Definition coff.h:1432

COFF::COFFFormat::GNUAOutHeader::GetSize
uint32_t GetSize() const override
Returns size of optional header.
Definition coff.cc:1537

COFF::COFFFormat::MIPSAOutHeader
56 byte long header used on MIPS
Definition coff.h:1461

COFF::COFFFormat::MIPSAOutHeader::GetSize
uint32_t GetSize() const override
Returns size of optional header.
Definition coff.cc:1598

COFF::COFFFormat::OptionalHeader
An abstract class to represent the optional header.
Definition coff.h:1227

COFF::COFFFormat::OptionalHeader::GetSize
virtual uint32_t GetSize() const =0
Returns size of optional header.

COFF::COFFFormat::OptionalHeader::CalculateValues
virtual offset_t CalculateValues(COFFFormat &coff)=0
Sets up fields to be consistent.

COFF::COFFFormat::OptionalHeader::PostReadFile
virtual void PostReadFile(COFFFormat &coff, Linker::Reader &rd)
Retrieves any additional data from the file corresponding to this type of optional header.
Definition coff.cc:1311

COFF::COFFFormat::OptionalHeader::PostWriteFile
virtual void PostWriteFile(const COFFFormat &coff, Linker::Writer &wr) const
Stores any additional data in the file corresponding to this type of optional header.
Definition coff.cc:1315

COFF::COFFFormat::Relocation
A generic COFF relocation.
Definition coff.h:602

COFF::COFFFormat::Relocation::offset
uint32_t offset
(COFF name: r_offset)
Definition coff.h:615

COFF::COFFFormat::Relocation::symbol_index
uint32_t symbol_index
Index of symbol in symbol table (COFF name: r_symndx)
Definition coff.h:611

COFF::COFFFormat::Relocation::information
uint16_t information
Assorted information (COFF name: r_bits, r_size, r_stuff etc.)
Definition coff.h:623

COFF::COFFFormat::Relocation::address
offset_t address
Address of the relocation (COFF name: r_vaddr)
Definition coff.h:607

COFF::COFFFormat::Relocation::type
uint16_t type
Type of relocation (COFF name: r_type)
Definition coff.h:619

COFF::COFFFormat::Section
A COFF section.
Definition coff.h:914

COFF::COFFFormat::Section::name
std::string name
The name of the section (COFF name: s_name)
Definition coff.h:919

COFF::COFFFormat::Section::relocation_pointer
offset_t relocation_pointer
Offset to COFF relocations (COFF name: s_relptr)
Definition coff.h:941

COFF::COFFFormat::Section::relocation_count
uint32_t relocation_count
COFF relocation count (COFF name: s_nreloc)
Definition coff.h:949

COFF::COFFFormat::Section::Dump
virtual void Dump(Dumper::Dumper &dump, const COFFFormat &format, unsigned section_index) const
Displays the section information and contents.
Definition coff.cc:1109

COFF::COFFFormat::Section::size
offset_t size
The size of the section (COFF name: s_size)
Definition coff.h:933

COFF::COFFFormat::Section::address
offset_t address
The virtual address of the section (COFF name: s_vaddr)
Definition coff.h:929

COFF::COFFFormat::Section::BSS
static constexpr uint32_t BSS
COFF section flag: Section contains uninitialized data (COFF name: STYP_BSS)
Definition coff.h:979

COFF::COFFFormat::Section::relocations
std::vector< std::unique_ptr< Relocation > > relocations
Collection of COFF relocations.
Definition coff.h:971

COFF::COFFFormat::Section::memory_page_number
uint16_t memory_page_number
TICOFF specific field.
Definition coff.h:961

COFF::COFFFormat::Section::line_number_pointer
offset_t line_number_pointer
unused (COFF name: s_lnnoptr)
Definition coff.h:945

COFF::COFFFormat::Section::ReadSectionHeader
void ReadSectionHeader(Linker::Reader &rd, COFFFormat &coff_format)
Reads an entry in the section header table.
Definition coff.cc:923

COFF::COFFFormat::Section::DATA
static constexpr uint32_t DATA
COFF section flag: Section contains initialized data (COFF name: STYP_DATA)
Definition coff.h:977

COFF::COFFFormat::Section::WriteSectionData
virtual void WriteSectionData(Linker::Writer &wr, const COFFFormat &coff_format) const
Writes the section contents to a stream, can be overloaded by subclasses.
Definition coff.cc:1103

COFF::COFFFormat::Section::ReadSectionData
virtual void ReadSectionData(Linker::Reader &rd, const COFFFormat &coff_format)
Reads the section contents from a stream, can be overloaded by subclasses.
Definition coff.cc:1097

COFF::COFFFormat::Section::section_pointer
offset_t section_pointer
Offset of stored image data from COFF header start (COFF name: s_scnptr)
Definition coff.h:937

COFF::COFFFormat::Section::WriteSectionHeader
void WriteSectionHeader(Linker::Writer &wr, const COFFFormat &coff_format)
Writes an entry in the section header table.
Definition coff.cc:1017

COFF::COFFFormat::Section::physical_address
offset_t physical_address
The physical address of the section (expected to be identical to the virtual address) (COFF name: s_p...
Definition coff.h:925

COFF::COFFFormat::Section::TEXT
static constexpr uint32_t TEXT
COFF section flag: Section contains executable instructions (COFF name: STYP_TEXT)
Definition coff.h:975

COFF::COFFFormat::Section::line_number_count
uint32_t line_number_count
unused (COFF name: s_nlnno)
Definition coff.h:953

COFF::COFFFormat::Section::flags
uint32_t flags
COFF section flags, determines the type of the section (text, data, bss, etc.) (COFF name: s_flags)
Definition coff.h:957

COFF::COFFFormat::Section::image
std::shared_ptr< Linker::Contents > image
The stored image data.
Definition coff.h:966

COFF::COFFFormat::Symbol::ArrayAuxiliaryEntry
Definition coff.h:749

COFF::COFFFormat::Symbol::AuxiliaryEntry
Definition coff.h:674

COFF::COFFFormat::Symbol::BeginOrEndAuxiliaryEntry
Definition coff.h:763

COFF::COFFFormat::Symbol::EndOfStructureAuxiliaryEntry
Definition coff.h:720

COFF::COFFFormat::Symbol::FileNameAuxiliaryEntry
Definition coff.h:683

COFF::COFFFormat::Symbol::FunctionAuxiliaryEntry
Definition coff.h:734

COFF::COFFFormat::Symbol::SectionAuxiliaryEntry
Definition coff.h:693

COFF::COFFFormat::Symbol::StructureAuxiliaryEntry
Definition coff.h:777

COFF::COFFFormat::Symbol::TagNameAuxiliaryEntry
Definition coff.h:706

COFF::COFFFormat::Symbol
A COFF symbol.
Definition coff.h:636

COFF::COFFFormat::Symbol::name
std::string name
Symbol name (COFF name: n_name, if it fits inside field)
Definition coff.h:641

COFF::COFFFormat::Symbol::section_number
uint16_t section_number
The number of the section, with special values 0 (N_UNDEF), 1 (N_ABS) and 2 (N_DEBUG) (COFF name: n_s...
Definition coff.h:653

COFF::COFFFormat::Symbol::N_UNDEF
@ N_UNDEF
Undefined external symbol.
Definition coff.h:859

COFF::COFFFormat::Symbol::N_ABS
@ N_ABS
Absolute symbol.
Definition coff.h:857

COFF::COFFFormat::Symbol::N_DEBUG
@ N_DEBUG
Debugging symbol.
Definition coff.h:855

COFF::COFFFormat::Symbol::type
uint16_t type
The symbol type (COFF name: n_type)
Definition coff.h:657

COFF::COFFFormat::Symbol::DT_NON
@ DT_NON
Not a derived type.
Definition coff.h:900

COFF::COFFFormat::Symbol::DT_FCN
@ DT_FCN
Function returning.
Definition coff.h:904

COFF::COFFFormat::Symbol::DT_ARY
@ DT_ARY
Array of.
Definition coff.h:906

COFF::COFFFormat::Symbol::DT_PTR
@ DT_PTR
Pointer to.
Definition coff.h:902

COFF::COFFFormat::Symbol::storage_class
uint8_t storage_class
COFF name: n_sclass, typical values are 2 (C_EXT), 3 (C_STAT)
Definition coff.h:663

COFF::COFFFormat::Symbol::C_UNTAG
@ C_UNTAG
union tag
Definition coff.h:819

COFF::COFFFormat::Symbol::C_MOU
@ C_MOU
member of union
Definition coff.h:817

COFF::COFFFormat::Symbol::C_EFCN
@ C_EFCN
Pysical end of function.
Definition coff.h:794

COFF::COFFFormat::Symbol::C_ULABEL
@ C_ULABEL
undefined label
Definition coff.h:809

COFF::COFFFormat::Symbol::C_AUTO
@ C_AUTO
Automatic variable.
Definition coff.h:797

COFF::COFFFormat::Symbol::C_EXTDEF
@ C_EXTDEF
external definition
Definition coff.h:805

COFF::COFFFormat::Symbol::C_SHADOW
@ C_SHADOW
shadow symbol
Definition coff.h:847

COFF::COFFFormat::Symbol::C_ALIAS
@ C_ALIAS
duplicated tag
Definition coff.h:843

COFF::COFFFormat::Symbol::C_FIELD
@ C_FIELD
bit field
Definition coff.h:831

COFF::COFFFormat::Symbol::C_TPDEF
@ C_TPDEF
type definition
Definition coff.h:821

COFF::COFFFormat::Symbol::C_STAT
@ C_STAT
static variable
Definition coff.h:801

COFF::COFFFormat::Symbol::C_FCN
@ C_FCN
begin/end function
Definition coff.h:835

COFF::COFFFormat::Symbol::C_LABEL
@ C_LABEL
label
Definition coff.h:807

COFF::COFFFormat::Symbol::C_WEAKEXT
@ C_WEAKEXT
external with weak linkage
Definition coff.h:849

COFF::COFFFormat::Symbol::C_MOS
@ C_MOS
member of structure
Definition coff.h:811

COFF::COFFFormat::Symbol::C_REGPARM
@ C_REGPARM
register parameter
Definition coff.h:829

COFF::COFFFormat::Symbol::C_FILE
@ C_FILE
file name
Definition coff.h:839

COFF::COFFFormat::Symbol::C_REG
@ C_REG
register variable
Definition coff.h:803

COFF::COFFFormat::Symbol::C_USTATIC
@ C_USTATIC
uninitialized static
Definition coff.h:823

COFF::COFFFormat::Symbol::C_MOE
@ C_MOE
member of enumeration
Definition coff.h:827

COFF::COFFFormat::Symbol::C_EXT
@ C_EXT
external symbol
Definition coff.h:799

COFF::COFFFormat::Symbol::C_STRTAG
@ C_STRTAG
structure tag
Definition coff.h:815

COFF::COFFFormat::Symbol::C_ARG
@ C_ARG
function argument
Definition coff.h:813

COFF::COFFFormat::Symbol::C_EOS
@ C_EOS
end of structure
Definition coff.h:837

COFF::COFFFormat::Symbol::C_BLOCK
@ C_BLOCK
begin/end block
Definition coff.h:833

COFF::COFFFormat::Symbol::C_HIDDEN
@ C_HIDDEN
static but avoids name conflict
Definition coff.h:845

COFF::COFFFormat::Symbol::C_ENTAG
@ C_ENTAG
enumeration tag
Definition coff.h:825

COFF::COFFFormat::Symbol::name_index
uint32_t name_index
The index of the symbol name within the string table, if not stored directly in the entry,...
Definition coff.h:645

COFF::COFFFormat::Symbol::auxiliary_count
uint8_t auxiliary_count
Signifies how many extra entries are present, these should be skipped, 0 is a typical value (COFF nam...
Definition coff.h:667

COFF::COFFFormat::Symbol::value
uint32_t value
The actual value of the symbol (COFF name: n_value)
Definition coff.h:649

COFF::COFFFormat::Symbol::T_MOE
@ T_MOE
Member of enumeration.
Definition coff.h:886

COFF::COFFFormat::Symbol::T_UNION
@ T_UNION
Union (C keyword union)
Definition coff.h:882

COFF::COFFFormat::Symbol::T_USHORT
@ T_USHORT
Unsigned short integer (C type unsigned short)
Definition coff.h:890

COFF::COFFFormat::Symbol::T_ULONG
@ T_ULONG
Unsigned long integer (C type unsigned long)
Definition coff.h:894

COFF::COFFFormat::Symbol::T_ENUM
@ T_ENUM
Enumeration (C keyword enum)
Definition coff.h:884

COFF::COFFFormat::Symbol::T_CHAR
@ T_CHAR
Character (C type char)
Definition coff.h:868

COFF::COFFFormat::Symbol::T_LONG
@ T_LONG
Long integer (C type long)
Definition coff.h:874

COFF::COFFFormat::Symbol::T_STRUCT
@ T_STRUCT
Structure (C keyword struct)
Definition coff.h:880

COFF::COFFFormat::Symbol::T_ARG
@ T_ARG
Function argument.
Definition coff.h:866

COFF::COFFFormat::Symbol::T_UINT
@ T_UINT
Unsigned integer (C type unsigned int)
Definition coff.h:892

COFF::COFFFormat::Symbol::T_UCHAR
@ T_UCHAR
Unsigned character (C type unsigned char)
Definition coff.h:888

COFF::COFFFormat::Symbol::T_DOUBLE
@ T_DOUBLE
Double (C type double)
Definition coff.h:878

COFF::COFFFormat::Symbol::T_INT
@ T_INT
Integer (C type int)
Definition coff.h:872

COFF::COFFFormat::Symbol::T_SHORT
@ T_SHORT
Short integer (C type short)
Definition coff.h:870

COFF::COFFFormat::Symbol::T_FLOAT
@ T_FLOAT
Float (C type float)
Definition coff.h:876

COFF::COFFFormat::UnknownOptionalHeader
A simplified class to represent an optional header of unknown structure.
Definition coff.h:1279

COFF::COFFFormat::UnknownOptionalHeader::GetSize
uint32_t GetSize() const override
Returns size of optional header.
Definition coff.cc:1333

COFF::COFFFormat::XCOFFAOutHeader
XCOFF optional header.
Definition coff.h:1569

COFF::COFFFormat::XCOFFAOutHeader::code_align
uint16_t code_align
Maximum alignment of text (XCOFF name: algntext)
Definition coff.h:1636

COFF::COFFFormat::XCOFFAOutHeader::version_stamp
uint16_t version_stamp
Object file version stamp (XCOFF name: vstamp)
Definition coff.h:1580

COFF::COFFFormat::XCOFFAOutHeader::is64
bool is64
False for XCOFF32, true for XCOFF64.
Definition coff.h:1572

COFF::COFFFormat::XCOFFAOutHeader::maximum_stack_size
uint64_t maximum_stack_size
Maximum stack size (XCOFF name: maxstack)
Definition coff.h:1656

COFF::COFFFormat::XCOFFAOutHeader::magic
uint16_t magic
Type of executable (XCOFF name: mflag)
Definition coff.h:1576

COFF::COFFFormat::XCOFFAOutHeader::data_size
uint64_t data_size
Size of data segment (XCOFF name: dsize)
Definition coff.h:1588

COFF::COFFFormat::XCOFFAOutHeader::xcoff64_flags
uint32_t xcoff64_flags
XCOFF64 specific flags (XCOFF64 name: x64flags)
Definition coff.h:1692

COFF::COFFFormat::XCOFFAOutHeader::toc_section
uint16_t toc_section
Section number for TOC (XCOFF name: sntoc)
Definition coff.h:1624

COFF::COFFFormat::XCOFFAOutHeader::debugger_data
uint32_t debugger_data
Reserved for debugger (XCOFF name: debugger)
Definition coff.h:1664

COFF::COFFFormat::XCOFFAOutHeader::code_size
uint64_t code_size
Size of code segment (XCOFF name: tsize)
Definition coff.h:1584

COFF::COFFFormat::XCOFFAOutHeader::entry_section
uint16_t entry_section
Section number for entry point (XCOFF name: snentry)
Definition coff.h:1612

COFF::COFFFormat::XCOFFAOutHeader::text_page_size
uint8_t text_page_size
Requested data page size (XCOFF name: datapsize)
Definition coff.h:1672

COFF::COFFFormat::XCOFFAOutHeader::data_address
uint64_t data_address
Base address for data segment (XCOFF name: data_start)
Definition coff.h:1604

COFF::COFFFormat::XCOFFAOutHeader::tbss_section
uint16_t tbss_section
Section number for tbss (XCOFF name: sntbss)
Definition coff.h:1688

COFF::COFFFormat::XCOFFAOutHeader::loader_section
uint16_t loader_section
Section number for loader data (XCOFF name: snloader)
Definition coff.h:1628

COFF::COFFFormat::XCOFFAOutHeader::bss_size
uint64_t bss_size
Size of bss segment (XCOFF name: bsize)
Definition coff.h:1592

COFF::COFFFormat::XCOFFAOutHeader::cpu_type
uint8_t cpu_type
CPU type (XCOFF name: cputype)
Definition coff.h:1652

COFF::COFFFormat::XCOFFAOutHeader::stack_page_size
uint8_t stack_page_size
Requested stack page size (XCOFF name: stackpsize)
Definition coff.h:1676

COFF::COFFFormat::XCOFFAOutHeader::cpu_flags
uint8_t cpu_flags
CPU flags (XCOFF name: cpuflag)
Definition coff.h:1648

COFF::COFFFormat::XCOFFAOutHeader::module_type
uint16_t module_type
Module type (XCOFF name: modtype)
Definition coff.h:1644

COFF::COFFFormat::XCOFFAOutHeader::data_section
uint16_t data_section
Section number for data (XCOFF name: sndata)
Definition coff.h:1620

COFF::COFFFormat::XCOFFAOutHeader::code_address
uint64_t code_address
Base address for code segment (XCOFF name: text_start)
Definition coff.h:1600

COFF::COFFFormat::XCOFFAOutHeader::data_align
uint16_t data_align
Maximum alignment of data (XCOFF name: algndata)
Definition coff.h:1640

COFF::COFFFormat::XCOFFAOutHeader::code_section
uint16_t code_section
Section number for text (XCOFF name: sntext)
Definition coff.h:1616

COFF::COFFFormat::XCOFFAOutHeader::entry_address
uint64_t entry_address
Virtual address of execution start (XCOFF name: entry)
Definition coff.h:1596

COFF::COFFFormat::XCOFFAOutHeader::toc_address
uint64_t toc_address
Address of TOC (XCOFF name: toc)
Definition coff.h:1608

COFF::COFFFormat::XCOFFAOutHeader::flags
uint8_t flags
Flags.
Definition coff.h:1680

COFF::COFFFormat::XCOFFAOutHeader::code_page_size
uint8_t code_page_size
Requested code page size (XCOFF name: textpsize)
Definition coff.h:1668

COFF::COFFFormat::XCOFFAOutHeader::GetSize
uint32_t GetSize() const override
Returns size of optional header.
Definition coff.cc:1695

COFF::COFFFormat::XCOFFAOutHeader::bss_section
uint16_t bss_section
Section number for bss (XCOFF name: snbss)
Definition coff.h:1632

COFF::COFFFormat::XCOFFAOutHeader::tdata_section
uint16_t tdata_section
Section number for tdata (XCOFF name: sntdata)
Definition coff.h:1684

COFF::COFFFormat::XCOFFAOutHeader::maximum_data_size
uint64_t maximum_data_size
Maximum data size (XCOFF name: maxdata)
Definition coff.h:1660

COFF::COFFFormat
The UNIX COFF file format.
Definition coff.h:28

COFF::COFFFormat::Clear
void Clear() override
Resets all fields to their default values, deallocate memory.
Definition coff.cc:1836

COFF::COFFFormat::R_REL16
static constexpr uint16_t R_REL16
16-bit relative address of symbol
Definition coff.h:338

COFF::COFFFormat::REL_ALPHA_PAIR
static constexpr uint16_t REL_ALPHA_PAIR
Displacement value for a preceding REFHI, SECRELHI, REFQ3 or REFQ2 relocation.
Definition coff.h:535

COFF::COFFFormat::GenerateModule
void GenerateModule(Linker::Module &module) const override
Loads the information into a module object, a convenience method when there is a single module genera...
Definition coff.cc:2550

COFF::COFFFormat::COFFVariantType
COFFVariantType
Variants of the COFF file format.
Definition coff.h:243

COFF::COFFFormat::COFF
@ COFF
Standard COFF variant (also for 32-bit ECOFF for MIPS)
Definition coff.h:245

COFF::COFFFormat::ECOFF
@ ECOFF
ECOFF 64-bit version.
Definition coff.h:247

COFF::COFFFormat::XCOFF32
@ XCOFF32
32-bit XCOFF from IBM
Definition coff.h:249

COFF::COFFFormat::TICOFF
@ TICOFF
Texas Instruments COFF variant (COFF2)
Definition coff.h:255

COFF::COFFFormat::XCOFF64
@ XCOFF64
64-bit XCOFF from IBM
Definition coff.h:251

COFF::COFFFormat::PECOFF
@ PECOFF
Microsoft PE/COFF variant.
Definition coff.h:253

COFF::COFFFormat::TICOFF1
@ TICOFF1
Texas Instruments COFF variant (COFF1)
Definition coff.h:257

COFF::COFFFormat::REL_AMD64_REL32_4
static constexpr uint16_t REL_AMD64_REL32_4
32-bit relative address of symbol minus 4
Definition coff.h:420

COFF::COFFFormat::sections
std::vector< std::shared_ptr< Section > > sections
The list of COFF sections.
Definition coff.h:1188

COFF::COFFFormat::REL_ALPHA_GPDISP
static constexpr uint16_t REL_ALPHA_GPDISP
reserved
Definition coff.h:523

COFF::COFFFormat::R_RELWORD
static constexpr uint16_t R_RELWORD
16-bit direct (symbol relative) address of symbol
Definition coff.h:366

COFF::COFFFormat::REL_ARM64_SECREL_LOW12A
static constexpr uint16_t REL_ARM64_SECREL_LOW12A
Low 12 bits of offset from section start for ADD/ADDS.
Definition coff.h:488

COFF::COFFFormat::REL_AMD64_SECTION
static constexpr uint16_t REL_AMD64_SECTION
16-bit section index (debugging)
Definition coff.h:424

COFF::COFFFormat::CalculateValues
void CalculateValues() override
Intermediate step between processing module and generating output file to set up headers and manageme...
Definition coff.cc:3268

COFF::COFFFormat::format_type
format_type
Represents the type of target system, which will determine the CPU type and several other fields.
Definition coff.h:1879

COFF::COFFFormat::UNIX_3B5
@ UNIX_3B5
AT&T UNIX System V Release 3 for the AT&T 3B5 and 3B15 (WE32K)
Definition coff.h:1895

COFF::COFFFormat::UNIX
@ UNIX
AT&T UNIX System V Release 1-3.
Definition coff.h:1887

COFF::COFFFormat::UNIX_3B2
@ UNIX_3B2
AT&T UNIX System V Release 3 for the AT&T 3B2 (WE32K)
Definition coff.h:1899

COFF::COFFFormat::CDOS386
@ CDOS386
FlexOS 386 executable.
Definition coff.h:1911

COFF::COFFFormat::WINDOWS
@ WINDOWS
Windows Portable Executable (used only by PE)
Definition coff.h:1915

COFF::COFFFormat::UNIX_3B20
@ UNIX_3B20
AT&T UNIX System V Release 3 for the AT&T 3B20 (WE32K)
Definition coff.h:1891

COFF::COFFFormat::GENERIC
@ GENERIC
An unspecified value, probably will not work.
Definition coff.h:1883

COFF::COFFFormat::DJGPP
@ DJGPP
DJGPP COFF executable.
Definition coff.h:1903

COFF::COFFFormat::CDOS68K
@ CDOS68K
Concurrent DOS 68K executable (untested but confident)
Definition coff.h:1907

COFF::COFFFormat::optional_header_size
uint32_t optional_header_size
The size of the optional header (COFF: f_opthdr)
Definition coff.h:1213

COFF::COFFFormat::REL_ARM64_BRANCH26
static constexpr uint16_t REL_ARM64_BRANCH26
26-bit ARM relative address of symbol
Definition coff.h:476

COFF::COFFFormat::FLAG_NO_SYMBOLS
@ FLAG_NO_SYMBOLS
F_LSYMS.
Definition coff.h:1974

COFF::COFFFormat::FLAG_NO_RELOCATIONS
@ FLAG_NO_RELOCATIONS
F_RELFLG.
Definition coff.h:1968

COFF::COFFFormat::FLAG_32BIT_LITTLE_ENDIAN
@ FLAG_32BIT_LITTLE_ENDIAN
F_AR32WR.
Definition coff.h:1978

COFF::COFFFormat::FLAG_32BIT_BIG_ENDIAN
@ FLAG_32BIT_BIG_ENDIAN
F_AR32W.
Definition coff.h:1980

COFF::COFFFormat::FLAG_NO_LINE_NUMBERS
@ FLAG_NO_LINE_NUMBERS
F_LNNO.
Definition coff.h:1972

COFF::COFFFormat::FLAG_PDP11_ENDIAN
@ FLAG_PDP11_ENDIAN
F_AR16WR.
Definition coff.h:1976

COFF::COFFFormat::FLAG_EXECUTABLE
@ FLAG_EXECUTABLE
F_EXEC.
Definition coff.h:1970

COFF::COFFFormat::REL_AMD64_REL32_2
static constexpr uint16_t REL_AMD64_REL32_2
32-bit relative address of symbol minus 2
Definition coff.h:416

COFF::COFFFormat::REL_ARM64_BRANCH19
static constexpr uint16_t REL_ARM64_BRANCH19
19-bit relative address of symbol
Definition coff.h:500

COFF::COFFFormat::REL_ALPHA_REFLONG
static constexpr uint16_t REL_ALPHA_REFLONG
32-bit virtual address of symbol
Definition coff.h:513

COFF::COFFFormat::R_PCRLONG
static constexpr uint16_t R_PCRLONG
32-bit PC relative address of symbol
Definition coff.h:374

COFF::COFFFormat::REL_ALPHA_MATCH
static constexpr uint16_t REL_ALPHA_MATCH
Displacement value for a preceding REFLONG relocation.
Definition coff.h:537

COFF::COFFFormat::REL_AMD64_SSPAN32
static constexpr uint16_t REL_AMD64_SSPAN32
?
Definition coff.h:436

COFF::COFFFormat::R_RELLONG
static constexpr uint16_t R_RELLONG
32-bit direct (symbol relative) address of symbol
Definition coff.h:368

COFF::COFFFormat::REL_ALPHA_LITUSE
static constexpr uint16_t REL_ALPHA_LITUSE
reserved
Definition coff.h:521

COFF::COFFFormat::REL_ARM64_PAGEOFFSET_12L
static constexpr uint16_t REL_ARM64_PAGEOFFSET_12L
12-bit page offset of symbol for LDR
Definition coff.h:484

COFF::COFFFormat::R_DIR32
static constexpr uint16_t R_DIR32
32-bit direct address of symbol
Definition coff.h:346

COFF::COFFFormat::R_ABS
static constexpr uint16_t R_ABS
No relocation.
Definition coff.h:334

COFF::COFFFormat::GetSegment
std::shared_ptr< Linker::Segment > GetSegment(std::shared_ptr< Section > &section)
Return the segment stored inside the section, note that this only works for binary generation.
Definition coff.cc:3173

COFF::COFFFormat::REL_AMD64_REL32
static constexpr uint16_t REL_AMD64_REL32
32-bit relative address of symbol
Definition coff.h:412

COFF::COFFFormat::REL_ALPHA_REFQ1
static constexpr uint16_t REL_ALPHA_REFQ1
The least significant 16 bits of the 64-bit virtual address of symbol.
Definition coff.h:553

COFF::COFFFormat::REL_ALPHA_INLINE_REFLONG
static constexpr uint16_t REL_ALPHA_INLINE_REFLONG
32-bit virtual address of symbol split into two 16-bit values; this relocation must be followed by an...
Definition coff.h:529

COFF::COFFFormat::REL_ARM_MOV32
static constexpr uint16_t REL_ARM_MOV32
Two 32-bit ARM instructions with 32 bits of the virtual address of the symbol.
Definition coff.h:457

COFF::COFFFormat::REL_I386_DIR32
static constexpr uint16_t REL_I386_DIR32
32-bit virtual address of symbol
Definition coff.h:385

COFF::COFFFormat::R_DIR32S
static constexpr uint16_t R_DIR32S
(WE32K) 32-bit direct address of symbol, byte swapped
Definition coff.h:354

COFF::COFFFormat::REL_ARM_REL32
static constexpr uint16_t REL_ARM_REL32
32-bit relative address of symbol
Definition coff.h:451

COFF::COFFFormat::REL_ALPHA_SECREL
static constexpr uint16_t REL_ALPHA_SECREL
32-bit offset from section start (debugging)
Definition coff.h:541

COFF::COFFFormat::REL_ALPHA_LITERAL
static constexpr uint16_t REL_ALPHA_LITERAL
16-bit global pointer relative address of symbol
Definition coff.h:519

COFF::COFFFormat::REL_I386_SECREL7
static constexpr uint16_t REL_I386_SECREL7
7-bit offset from section base
Definition coff.h:397

COFF::COFFFormat::REL_AMD64_SECREL7
static constexpr uint16_t REL_AMD64_SECREL7
7-bit offset from section base
Definition coff.h:428

COFF::COFFFormat::GetOptions
std::shared_ptr< Linker::OptionCollector > GetOptions() override
Returns object containing a sequence of option fields provided with the -S command line flag.
Definition coff.cc:2936

COFF::COFFFormat::REL_ALPHA_GPRELHI
static constexpr uint16_t REL_ALPHA_GPRELHI
High 16 bits of 32-bit global pointer relative address of symbol.
Definition coff.h:557

COFF::COFFFormat::REL_I386_SECTION
static constexpr uint16_t REL_I386_SECTION
16-bit section index (debugging)
Definition coff.h:391

COFF::COFFFormat::GetLinkerScriptParameterNames
std::vector< Linker::OptionDescription< void > * > GetLinkerScriptParameterNames() override
Returns a list of the parameters used in the linker scripts, used for documentation.
Definition coff.cc:2931

COFF::COFFFormat::Dump
void Dump(Dumper::Dumper &dump) const override
Display file contents in a nice manner.
Definition coff.cc:2299

COFF::COFFFormat::REL_ARM64_PAGEOFFSET_12A
static constexpr uint16_t REL_ARM64_PAGEOFFSET_12A
12-bit page offset of symbol for ADD/ADDS
Definition coff.h:482

COFF::COFFFormat::REL_ARM64_SECREL_HIGH12A
static constexpr uint16_t REL_ARM64_SECREL_HIGH12A
Bits 12 to 23 of offset from section start for ADD/ADDS.
Definition coff.h:490

COFF::COFFFormat::REL_ALPHA_ABSOLUTE
static constexpr uint16_t REL_ALPHA_ABSOLUTE
No relocation.
Definition coff.h:511

COFF::COFFFormat::REL_I386_REL32
static constexpr uint16_t REL_I386_REL32
32-bit relative address of symbol
Definition coff.h:399

COFF::COFFFormat::REL_ALPHA_REFQ2
static constexpr uint16_t REL_ALPHA_REFQ2
The third most significant 16 bits of the 64-bit virtual address of symbol; this relocation must be f...
Definition coff.h:551

COFF::COFFFormat::WriteFile
offset_t WriteFile(Linker::Writer &wr) const override
Stores data in memory to file.
Definition coff.cc:2210

COFF::COFFFormat::type
format_type type
A representation of the format to generate.
Definition coff.h:1920

COFF::COFFFormat::REL_ALPHA_REFHI
static constexpr uint16_t REL_ALPHA_REFHI
High 16 bits of 32-bit virtual address of symbol; this relocation must be followed by a PAIR relocati...
Definition coff.h:531

COFF::COFFFormat::REL_ARM_BRANCH11
static constexpr uint16_t REL_ARM_BRANCH11
Two 16-bit instructions with 11 bits of the relative address of symbol each.
Definition coff.h:449

COFF::COFFFormat::REL_THUMB_BLX23
static constexpr uint16_t REL_THUMB_BLX23
23-bit Thumb BLX relative address of symbol
Definition coff.h:463

COFF::COFFFormat::REL_ARM_ABSOLUTE
static constexpr uint16_t REL_ARM_ABSOLUTE
No relocation.
Definition coff.h:441

COFF::COFFFormat::REL_ALPHA_REFLO
static constexpr uint16_t REL_ALPHA_REFLO
Low 16 bits of 32-bit virtual address of symbol.
Definition coff.h:533

COFF::COFFFormat::REL_ALPHA_SECRELHI
static constexpr uint16_t REL_ALPHA_SECRELHI
High 16 bits of 32-bit offset from section start; this relocation must be followed by a PAIR relocati...
Definition coff.h:547

COFF::COFFFormat::signature
char signature[2]
The actual value of the magic number (COFF name: f_magic)
Definition coff.h:274

COFF::COFFFormat::REL_ALPHA_GPREL32
static constexpr uint16_t REL_ALPHA_GPREL32
32-bit global pointer relative address of symbol
Definition coff.h:517

COFF::COFFFormat::REL_AMD64_REL32_3
static constexpr uint16_t REL_AMD64_REL32_3
32-bit relative address of symbol minus 3
Definition coff.h:418

COFF::COFFFormat::REL_ARM_ADDR32
static constexpr uint16_t REL_ARM_ADDR32
32-bit virtual address of symbol
Definition coff.h:443

COFF::COFFFormat::symbols
std::vector< std::unique_ptr< Symbol > > symbols
The symbols stored inside the COFF file.
Definition coff.h:1209

COFF::COFFFormat::FormatRequiresDataStreamFix
bool FormatRequiresDataStreamFix() const override
Whether the generated file might contain bugs that require fixing.
Definition coff.cc:2545

COFF::COFFFormat::REL_THUMB_MOV32
static constexpr uint16_t REL_THUMB_MOV32
Two 32-bit Thumb instructions with 32 bits of the virtual address of the symbol.
Definition coff.h:459

COFF::COFFFormat::R_OFF16
static constexpr uint16_t R_OFF16
8-bit high byte of address of symbol
Definition coff.h:350

COFF::COFFFormat::cpu
cpu
Represents the first 16-bit word of a COFF file.
Definition coff.h:36

COFF::COFFFormat::CPU_IA64
@ CPU_IA64
Intel Itanium architecture, also known as IA-64.
Definition coff.h:187

COFF::COFFFormat::CPU_ALPHA
@ CPU_ALPHA
DEC Alpha.
Definition coff.h:133

COFF::COFFFormat::CPU_PPC
@ CPU_PPC
IBM PowerPC, 32-bit.
Definition coff.h:139

COFF::COFFFormat::CPU_AMD64
@ CPU_AMD64
x86-64, introduced by AMD
Definition coff.h:223

COFF::COFFFormat::CPU_VAX
@ CPU_VAX
DEC VAX.
Definition coff.h:121

COFF::COFFFormat::CPU_I86
@ CPU_I86
Intel x86-16, introduced with the Intel 8086.
Definition coff.h:79

COFF::COFFFormat::CPU_M32R
@ CPU_M32R
Mitsubishi M32R.
Definition coff.h:229

COFF::COFFFormat::CPU_AM33
@ CPU_AM33
Matsushita AM33.
Definition coff.h:181

COFF::COFFFormat::CPU_RISCV32
@ CPU_RISCV32
RISC-V 32.
Definition coff.h:205

COFF::COFFFormat::CPU_Z8K
@ CPU_Z8K
Zilog Z8000.
Definition coff.h:71

COFF::COFFFormat::CPU_I286
@ CPU_I286
Intel x86-16, introduced with the Intel 286.
Definition coff.h:85

COFF::COFFFormat::CPU_Z80
@ CPU_Z80
Zilog Z80.
Definition coff.h:65

COFF::COFFFormat::CPU_I370
@ CPU_I370
IBM System/370.
Definition coff.h:97

COFF::COFFFormat::CPU_NS32K
@ CPU_NS32K
National Semiconductor NS32000.
Definition coff.h:91

COFF::COFFFormat::CPU_PPC64
@ CPU_PPC64
IBM PowerPC, 64-bit.
Definition coff.h:145

COFF::COFFFormat::CPU_I386
@ CPU_I386
Intel x86-32, introduced with the Intel 80386.
Definition coff.h:45

COFF::COFFFormat::CPU_ARM
@ CPU_ARM
ARM, also known as ARM32 or AArch32; also represents Thumb.
Definition coff.h:175

COFF::COFFFormat::CPU_EFI
@ CPU_EFI
EFI bytecode.
Definition coff.h:199

COFF::COFFFormat::CPU_M68K
@ CPU_M68K
Motorola 68000 and compatibles.
Definition coff.h:51

COFF::COFFFormat::CPU_I860
@ CPU_I860
Intel i860.
Definition coff.h:163

COFF::COFFFormat::CPU_WE32K
@ CPU_WE32K
AT&T Bellmac 32, Western Electric 32000 and family.
Definition coff.h:115

COFF::COFFFormat::CPU_M88K
@ CPU_M88K
Motorola 88000.
Definition coff.h:109

COFF::COFFFormat::CPU_SH
@ CPU_SH
Hitachi SuperH family.
Definition coff.h:169

COFF::COFFFormat::CPU_HPPA
@ CPU_HPPA
Hewlett-Packard PA-RISC.
Definition coff.h:193

COFF::COFFFormat::CPU_SHARC
@ CPU_SHARC
SHARC from Analog Devices.
Definition coff.h:148

COFF::COFFFormat::CPU_ARM64
@ CPU_ARM64
ARM64, also known as AArch64.
Definition coff.h:235

COFF::COFFFormat::CPU_MIPS
@ CPU_MIPS
MIPS architecture.
Definition coff.h:103

COFF::COFFFormat::CPU_W65
@ CPU_W65
WDC 65C816.
Definition coff.h:59

COFF::COFFFormat::CPU_RISCV64
@ CPU_RISCV64
RISC-V 64.
Definition coff.h:211

COFF::COFFFormat::CPU_RISCV128
@ CPU_RISCV128
RISC-V 128.
Definition coff.h:217

COFF::COFFFormat::CPU_AM29K
@ CPU_AM29K
AMD 29000.
Definition coff.h:127

COFF::COFFFormat::REL_ARM64_ADDR32
static constexpr uint16_t REL_ARM64_ADDR32
32-bit virtual address of symbol
Definition coff.h:472

COFF::COFFFormat::REL_ARM_SECREL
static constexpr uint16_t REL_ARM_SECREL
32-bit offset from section start (debugging)
Definition coff.h:455

COFF::COFFFormat::R_SEG12
static constexpr uint16_t R_SEG12
(Intel x86) 16-bit segment selector of symbol
Definition coff.h:352

COFF::COFFFormat::REL_AMD64_ABSOLUTE
static constexpr uint16_t REL_AMD64_ABSOLUTE
No relocation.
Definition coff.h:404

COFF::COFFFormat::R_IND16
static constexpr uint16_t R_IND16
16-bit indirect address of symbol
Definition coff.h:340

COFF::COFFFormat::REL_ARM64_REL32
static constexpr uint16_t REL_ARM64_REL32
32-bit relative address of symbol
Definition coff.h:504

COFF::COFFFormat::endiantype
::EndianType endiantype
The byte order.
Definition coff.h:1737

COFF::COFFFormat::relocations_offset
uint32_t relocations_offset
Concurrent DOS 68K: Offset to relocations.
Definition coff.h:1943

COFF::COFFFormat::REL_ALPHA_REFQ3
static constexpr uint16_t REL_ALPHA_REFQ3
The second most significant 16 bits of the 64-bit virtual address of symbol; this relocation must be ...
Definition coff.h:549

COFF::COFFFormat::REL_AMD64_PAIR
static constexpr uint16_t REL_AMD64_PAIR
?
Definition coff.h:434

COFF::COFFFormat::REL_ARM64_TOKEN
static constexpr uint16_t REL_ARM64_TOKEN
CLR token.
Definition coff.h:494

COFF::COFFFormat::REL_AMD64_REL32_5
static constexpr uint16_t REL_AMD64_REL32_5
32-bit relative address of symbol minus 5
Definition coff.h:422

COFF::COFFFormat::option_no_relocation
bool option_no_relocation
Suppress relocation generation, only relevant for Concurrent DOS 68K, since the other target formats ...
Definition coff.h:1925

COFF::COFFFormat::REL_ALPHA_REFQUAD
static constexpr uint16_t REL_ALPHA_REFQUAD
64-bit virtual address of symbol
Definition coff.h:515

COFF::COFFFormat::R_PCRWORD
static constexpr uint16_t R_PCRWORD
16-bit PC relative address of symbol
Definition coff.h:372

COFF::COFFFormat::REL_I386_TOKEN
static constexpr uint16_t REL_I386_TOKEN
CLR token.
Definition coff.h:395

COFF::COFFFormat::R_IND32
static constexpr uint16_t R_IND32
32-bit indirect address of symbol
Definition coff.h:362

COFF::COFFFormat::REL_I386_SEG12
static constexpr uint16_t REL_I386_SEG12
16-bit segment selector of symbol (not supported)
Definition coff.h:389

COFF::COFFFormat::stub_size
uint32_t stub_size
Size of MZ stub, only used for DJGPP COFF executables.
Definition coff.h:1930

COFF::COFFFormat::stack
std::shared_ptr< Linker::Segment > stack
Concurrent DOS 68K and FlexOS 386: The stack segment, not stored as part of any section.
Definition coff.h:1935

COFF::COFFFormat::SetupOptions
void SetupOptions(std::shared_ptr< Linker::OutputFormat > format) override
Initializes the reader for linking purposes.
Definition coff.cc:2540

COFF::COFFFormat::ReadFile
void ReadFile(Linker::Reader &rd) override
Loads file into memory.
Definition coff.cc:1919

COFF::COFFFormat::REL_ARM_BRANCH24
static constexpr uint16_t REL_ARM_BRANCH24
24-bit ARM relative address of symbol
Definition coff.h:447

COFF::COFFFormat::REL_ARM_ADDR32NB
static constexpr uint16_t REL_ARM_ADDR32NB
32-bit relative virtual address of symbol
Definition coff.h:445

COFF::COFFFormat::GenerateFile
void GenerateFile(std::string filename, Linker::Module &module) override
The main function that handles processing, calculating and generating the final image.
Definition coff.cc:3436

COFF::COFFFormat::section_count
uint16_t section_count
Section count (COFF name: f_nscns)
Definition coff.h:1193

COFF::COFFFormat::REL_ARM_SECTION
static constexpr uint16_t REL_ARM_SECTION
16-bit section index (debugging)
Definition coff.h:453

COFF::COFFFormat::R_DIR24
static constexpr uint16_t R_DIR24
24-bit direct address of symbol
Definition coff.h:342

COFF::COFFFormat::REL_ARM64_REL21
static constexpr uint16_t REL_ARM64_REL21
12-bit relative address of symbol for ADR
Definition coff.h:480

COFF::COFFFormat::target
uint16_t target
TI system target ID.
Definition coff.h:1221

COFF::COFFFormat::REL_ALPHA_SECTION
static constexpr uint16_t REL_ALPHA_SECTION
16-bit section index (debugging)
Definition coff.h:539

COFF::COFFFormat::entry_address
uint32_t entry_address
Entry address, gets stored in optional header later.
Definition coff.h:1939

COFF::COFFFormat::relocation_format_type
relocation_format_type
Definition coff.h:282

COFF::COFFFormat::TICOFF_10
@ TICOFF_10
A 10-byte relocation used for TICOFF.
Definition coff.h:298

COFF::COFFFormat::ECOFF_8
@ ECOFF_8
An 8-byte relocation, used for 32-bit ECOFF MIPS binaries.
Definition coff.h:290

COFF::COFFFormat::XCOFF_10
@ XCOFF_10
A 10-byte relocation, used for 32-bit XCOFF32 binaries.
Definition coff.h:294

COFF::COFFFormat::ECOFF_16
@ ECOFF_16
A 16-byte relocation, used for 64-bit ECOFF Alpha binaries.
Definition coff.h:292

COFF::COFFFormat::XCOFF_14
@ XCOFF_14
A 14-byte relocation, used for 64-bit XCOFF64 binaries.
Definition coff.h:296

COFF::COFFFormat::TICOFF_12
@ TICOFF_12
A 12-byte relocation used for TICOFF.
Definition coff.h:300

COFF::COFFFormat::COFF_16
@ COFF_16
A 16-byte relocation, as stored by the Z80/Z8000 GNU assembler.
Definition coff.h:288

COFF::COFFFormat::COFF_14
@ COFF_14
A 14-byte relocation.
Definition coff.h:286

COFF::COFFFormat::COFF_10
@ COFF_10
The standard 10-byte UNIX COFF relocation format, also used for Microsoft PE COFF objects.
Definition coff.h:284

COFF::COFFFormat::REL_ARM64_ADDR64
static constexpr uint16_t REL_ARM64_ADDR64
64-bit virtual address of symbol
Definition coff.h:498

COFF::COFFFormat::REL_AMD64_ADDR32
static constexpr uint16_t REL_AMD64_ADDR32
32-bit virtual address of symbol
Definition coff.h:408

COFF::COFFFormat::R_IND24
static constexpr uint16_t R_IND24
24-bit indirect address of symbol
Definition coff.h:360

COFF::COFFFormat::REL_ARM64_ABSOLUTE
static constexpr uint16_t REL_ARM64_ABSOLUTE
No relocation.
Definition coff.h:470

COFF::COFFFormat::opthdr_magic_type
opthdr_magic_type
Value stored as the magic of the a.out header.
Definition coff.h:1809

COFF::COFFFormat::SHMAGIC
@ SHMAGIC
Shared library.
Definition coff.h:1825

COFF::COFFFormat::MAGIC_FLEXOS386
@ MAGIC_FLEXOS386
Magic number required by FlexOS 386.
Definition coff.h:1829

COFF::COFFFormat::NMAGIC
@ NMAGIC
Shared text - text segment is write protected, data segment follows on the next page.
Definition coff.h:1817

COFF::COFFFormat::ZMAGIC
@ ZMAGIC
Demand paged.
Definition coff.h:1821

COFF::COFFFormat::OMAGIC
@ OMAGIC
Impure format - text segment is not write protected, text and data segment are contiguous.
Definition coff.h:1813

COFF::COFFFormat::REL_THUMB_BRANCH24
static constexpr uint16_t REL_THUMB_BRANCH24
24-bit Thumb relative address of symbol
Definition coff.h:461

COFF::COFFFormat::R_OPT16
static constexpr uint16_t R_OPT16
16-bit (WE32K) optimized indirect address of symbol
Definition coff.h:358

COFF::COFFFormat::REL_AMD64_SECREL
static constexpr uint16_t REL_AMD64_SECREL
32-bit offset from section start (debugging)
Definition coff.h:426

COFF::COFFFormat::symbol_count
uint32_t symbol_count
The number of symbols (COFF name: f_nsyms)
Definition coff.h:1205

COFF::COFFFormat::AssignMagicValue
void AssignMagicValue()
Loads the currently set CPU value in the currently set byte order into the COFF header signature.
Definition coff.cc:1858

COFF::COFFFormat::REL_I386_SECREL
static constexpr uint16_t REL_I386_SECREL
32-bit offset from section start (debugging)
Definition coff.h:393

COFF::COFFFormat::REL_ALPHA_SECRELLO
static constexpr uint16_t REL_ALPHA_SECRELLO
Low 16 bits of 32-bit offset from section start (debugging)
Definition coff.h:545

COFF::COFFFormat::REL_I386_DIR32NB
static constexpr uint16_t REL_I386_DIR32NB
32-bit relative virtual address of symbol
Definition coff.h:387

COFF::COFFFormat::R_PCRBYTE
static constexpr uint16_t R_PCRBYTE
8-bit PC relative address of symbol
Definition coff.h:370

COFF::COFFFormat::R_DIR16
static constexpr uint16_t R_DIR16
16-bit direct address of symbol
Definition coff.h:336

COFF::COFFFormat::REL_ARM64_ADDR32NB
static constexpr uint16_t REL_ARM64_ADDR32NB
32-bit relative virtual address of symbol
Definition coff.h:474

COFF::COFFFormat::REL_I386_ABSOLUTE
static constexpr uint16_t REL_I386_ABSOLUTE
No relocation.
Definition coff.h:379

COFF::COFFFormat::REL_ARM64_BRANCH14
static constexpr uint16_t REL_ARM64_BRANCH14
14-bit relative address of symbol for TBZ/TBNZ
Definition coff.h:502

COFF::COFFFormat::SetOptions
void SetOptions(std::map< std::string, std::string > &options) override
Passes command line parameters as settings over to format object.
Definition coff.cc:2941

COFF::COFFFormat::REL_I386_DIR16
static constexpr uint16_t REL_I386_DIR16
16-bit virtual address of symbol (not supported)
Definition coff.h:381

COFF::COFFFormat::R_REL24
static constexpr uint16_t R_REL24
24-bit relative address of symbol
Definition coff.h:344

COFF::COFFFormat::ProcessModule
void ProcessModule(Linker::Module &module) override
Processes the module object and initializes format fields.
Definition coff.cc:3208

COFF::COFFFormat::GetEndianType
::EndianType GetEndianType() const
Retrieves the natural byte order for the architecture.
Definition coff.cc:130

COFF::COFFFormat::R_OFF8
static constexpr uint16_t R_OFF8
8-bit low byte of address of symbol
Definition coff.h:348

COFF::COFFFormat::REL_ARM64_SECTION
static constexpr uint16_t REL_ARM64_SECTION
16-bit section index (debugging)
Definition coff.h:496

COFF::COFFFormat::symbol_table_offset
offset_t symbol_table_offset
Offset to the first symbol (COFF name: f_symptr)
Definition coff.h:1201

COFF::COFFFormat::relocations
std::map< uint32_t, CDOS68K_Relocation > relocations
Concurrent DOS 68K requires a special block of data to represent "crunched" relocations (see CPM68KWr...
Definition coff.h:1273

COFF::COFFFormat::R_AUX
static constexpr uint16_t R_AUX
Auxiliary relocation.
Definition coff.h:356

COFF::COFFFormat::REL_ALPHA_HINT
static constexpr uint16_t REL_ALPHA_HINT
14-bit hint for jump target
Definition coff.h:527

COFF::COFFFormat::REL_ARM64_PAGEBASE_REL21
static constexpr uint16_t REL_ARM64_PAGEBASE_REL21
Page base of symbol for ADRP.
Definition coff.h:478

COFF::COFFFormat::OnNewSegment
void OnNewSegment(std::shared_ptr< Linker::Segment > segment) override
Callback function when allocating a new segment When the linker script runs, it creates segments cons...
Definition coff.cc:2982

COFF::COFFFormat::REL_AMD64_SREL32
static constexpr uint16_t REL_AMD64_SREL32
?
Definition coff.h:432

COFF::COFFFormat::REL_AMD64_ADDR64
static constexpr uint16_t REL_AMD64_ADDR64
64-bit virtual address of symbol
Definition coff.h:406

COFF::COFFFormat::REL_ALPHA_BRADDR
static constexpr uint16_t REL_ALPHA_BRADDR
21-bit relative address of symbol
Definition coff.h:525

COFF::COFFFormat::GetDefaultExtension
std::string GetDefaultExtension(Linker::Module &module, std::string filename) const override
Appends a default extension to the filename.
Definition coff.cc:3596

COFF::COFFFormat::REL_ARM64_SECREL
static constexpr uint16_t REL_ARM64_SECREL
32-bit offset from section start (debugging)
Definition coff.h:486

COFF::COFFFormat::ImageSize
offset_t ImageSize() const override
Retrieves size of stored data.
Definition coff.cc:2222

COFF::COFFFormat::REL_ARM_PAIR
static constexpr uint16_t REL_ARM_PAIR
?
Definition coff.h:465

COFF::COFFFormat::REL_AMD64_ADDR32NB
static constexpr uint16_t REL_AMD64_ADDR32NB
32-bit relative virtual address of symbol
Definition coff.h:410

COFF::COFFFormat::REL_ALPHA_REFLONGNB
static constexpr uint16_t REL_ALPHA_REFLONGNB
32-bit relative virtual address of symbol
Definition coff.h:543

COFF::COFFFormat::optional_header
std::unique_ptr< OptionalHeader > optional_header
The optional header instance used for reading/writing the COFF file.
Definition coff.h:1257

COFF::COFFFormat::REL_I386_REL16
static constexpr uint16_t REL_I386_REL16
16-bit relative address of symbol (not supported)
Definition coff.h:383

COFF::COFFFormat::REL_AMD64_REL32_1
static constexpr uint16_t REL_AMD64_REL32_1
32-bit relative address of symbol minus 1
Definition coff.h:414

COFF::COFFFormat::REL_AMD64_TOKEN
static constexpr uint16_t REL_AMD64_TOKEN
CLR token.
Definition coff.h:430

COFF::COFFFormat::flags
uint16_t flags
COFF flags, such as whether the file is executable (f_flags)
Definition coff.h:1217

COFF::COFFFormat::R_RELBYTE
static constexpr uint16_t R_RELBYTE
8-bit direct (symbol relative) address of symbol
Definition coff.h:364

COFF::COFFFormat::cpu_type
cpu cpu_type
The CPU type, reflected by the first 16-bit word of a COFF file.
Definition coff.h:1732

COFF::COFFFormat::REL_ARM64_SECREL_LOW12L
static constexpr uint16_t REL_ARM64_SECREL_LOW12L
Low 12 bits of offset from section start for LDR.
Definition coff.h:492

COFF::COFFFormat::timestamp
uint32_t timestamp
Time stamp, unused (COFF name: f_timdat)
Definition coff.h:1197

COFF::COFFFormat::REL_ALPHA_GPRELLO
static constexpr uint16_t REL_ALPHA_GPRELLO
Low 16 bits of 32-bit global pointer relative address of symbol.
Definition coff.h:555

Dumper::Dumper
An abstract interface that separates structure and presentation of the data inside a file.
Definition dumper.h:773

Dumper::Entry
A brief record, such as a relocation or imported library.
Definition dumper.h:687

Dumper::Region
A record that represents a region within the file.
Definition dumper.h:666

Linker::Enumeration
A representation of an enumeration with associated string representations for each value.
Definition options.h:15

Linker::Enumeration< opthdr_magic_type >::descriptions
std::map< value_type, std::string > descriptions
An empty dictionary that explains the value types in detail.
Definition options.h:20

Linker::Format::WriteFile
offset_t WriteFile(Writer &wr) const override=0
Stores data in memory to file.

Linker::InputFormat
A class that provides a general interface to loading a module.
Definition format.h:198

Linker::InputFormat::GenerateModule
virtual void GenerateModule(ModuleCollector &linker, std::string file_name, bool is_library=false) const
Loads the information into a module object.
Definition format.cc:221

Linker::Module
Encodes an object module file as a collection of sections, symbols and relocations.
Definition module.h:24

Linker::OptionCollector
Helper class that contains the options interpreted by the format.
Definition options.h:474

Linker::Option
Documents and handles command line options.
Definition options.h:306

Linker::OutputFormat::GetDefaultExtension
virtual std::string GetDefaultExtension(Module &module, std::string filename) const
Appends a default extension to the filename.

Linker::Reader
A helper class, encapsulating functionality needed to import binary data.
Definition reader.h:20

Linker::SegmentManager
A helper class to collect sections into segments.
Definition segment_manager.h:32

Linker::Writer
A helper class, encapsulating functionality needed to export binary data.
Definition writer.h:15

Microsoft::MZSimpleStubWriter
Definition mzexe.h:274

COFF::COFFFormat::CDOS68K_Relocation
Definition coff.h:1260

COFF::COFFFormat::MachineType
Definition coff.h:263

COFF::COFFFormat::Section::COFF_Flags
Definition coff.h:983

COFF::COFFFormat::Section::COFF_Flags::INFO
static constexpr uint32_t INFO
COFF section flag: Comment section (COFF name: STYP_INFO)
Definition coff.h:995

COFF::COFFFormat::Section::COFF_Flags::NOLOAD
static constexpr uint32_t NOLOAD
COFF section flag: Noload section (COFF name: STYP_NOLOAD)
Definition coff.h:987

COFF::COFFFormat::Section::COFF_Flags::OVER
static constexpr uint32_t OVER
COFF section flag: Overlay section (COFF name: STYP_OVER)
Definition coff.h:997

COFF::COFFFormat::Section::COFF_Flags::COPY
static constexpr uint32_t COPY
COFF section flag: Copy section (COFF name: STYP_COPY)
Definition coff.h:993

COFF::COFFFormat::Section::COFF_Flags::PAD
static constexpr uint32_t PAD
COFF section flag: Padding section (COFF name: STYP_PAD)
Definition coff.h:991

COFF::COFFFormat::Section::COFF_Flags::LIB
static constexpr uint32_t LIB
COFF section flag: Library section (also used by X/GEM to store library information) (COFF name: STYP...
Definition coff.h:999

COFF::COFFFormat::Section::COFF_Flags::DSECT
static constexpr uint32_t DSECT
COFF section flag: Dummy section (COFF name: STYP_DSECT)
Definition coff.h:985

COFF::COFFFormat::Section::COFF_Flags::GROUP
static constexpr uint32_t GROUP
COFF section flag: Grouped section, formed from input sections (COFF name: STYP_GROUP)
Definition coff.h:989

COFF::COFFFormat::Section::ECOFF_Flags
Definition coff.h:1004

COFF::COFFFormat::Section::ECOFF_Flags::SDATA
static constexpr uint32_t SDATA
ECOFF section flag: "Small data" (ECOFF name: STYP_SDATA)
Definition coff.h:1008

COFF::COFFFormat::Section::ECOFF_Flags::DYNSYM
static constexpr uint32_t DYNSYM
ECOFF section flag: Dynamic linking symbol table (ECOFF name: STYP_DYNSYM)
Definition coff.h:1018

COFF::COFFFormat::Section::ECOFF_Flags::REL_DYN
static constexpr uint32_t REL_DYN
ECOFF section flag: Dynamic relocation information (ECOFF name: STYP_REL_DYN)
Definition coff.h:1020

COFF::COFFFormat::Section::ECOFF_Flags::XDATA
static constexpr uint32_t XDATA
ECOFF section flag: Exception scope table (ECOFF name: STYP_XDATA)
Definition coff.h:1040

COFF::COFFFormat::Section::ECOFF_Flags::MSYM
static constexpr uint32_t MSYM
ECOFF section flag: Additional dynamic linking symbol table (ECOFF name: STYP_MSYM)
Definition coff.h:1028

COFF::COFFFormat::Section::ECOFF_Flags::LITA
static constexpr uint32_t LITA
ECOFF section flag: Address literals (ECOFF name: STYP_LITA)
Definition coff.h:1050

COFF::COFFFormat::Section::ECOFF_Flags::GOT
static constexpr uint32_t GOT
ECOFF section flag: Global offset table (ECOFF name: STYP_GOT)
Definition coff.h:1014

COFF::COFFFormat::Section::ECOFF_Flags::SBSS
static constexpr uint32_t SBSS
ECOFF section flag: "Small bss" (ECOFF name: STYP_SBSS)
Definition coff.h:1010

COFF::COFFFormat::Section::ECOFF_Flags::DYNSTR
static constexpr uint32_t DYNSTR
ECOFF section flag: Dynamic linking string table (ECOFF name: STYP_DYNSTR)
Definition coff.h:1022

COFF::COFFFormat::Section::ECOFF_Flags::TLSINIT
static constexpr uint32_t TLSINIT
ECOFF section flag: Initialization for TLS data (ECOFF name: STYP_TLSINIT)
Definition coff.h:1046

COFF::COFFFormat::Section::ECOFF_Flags::NRELOC_OVERFLOWED
static constexpr uint32_t NRELOC_OVERFLOWED
ECOFF section flag: the s_nreloc field overflowed (ECOFF name: S_NRELOC_OVFL)
Definition coff.h:1056

COFF::COFFFormat::Section::ECOFF_Flags::HASH
static constexpr uint32_t HASH
ECOFF section flag: Dynamic symbol hash table (ECOFF name: STYP_HASH)
Definition coff.h:1024

COFF::COFFFormat::Section::ECOFF_Flags::EXTMASK
static constexpr uint32_t EXTMASK
ECOFF section flag: Multiple bit flag values.
Definition coff.h:1030

COFF::COFFFormat::Section::ECOFF_Flags::TLSBSS
static constexpr uint32_t TLSBSS
ECOFF section flag: Uninitialized TLS data (ECOFF name: STYP_TLSBSS)
Definition coff.h:1044

COFF::COFFFormat::Section::ECOFF_Flags::FINI
static constexpr uint32_t FINI
ECOFF section flag: Termination text (ECOFF name: STYP_FINI)
Definition coff.h:1034

COFF::COFFFormat::Section::ECOFF_Flags::LIT4
static constexpr uint32_t LIT4
ECOFF section flag: 4-byte literals (ECOFF name: STYP_LIT8)
Definition coff.h:1054

COFF::COFFFormat::Section::ECOFF_Flags::RDATA
static constexpr uint32_t RDATA
ECOFF section flag: Section contains read-only data (ECOFF name: STYP_RDATA)
Definition coff.h:1006

COFF::COFFFormat::Section::ECOFF_Flags::INIT
static constexpr uint32_t INIT
ECOFF section flag: Initialization text (ECOFF name: STYP_INIT)
Definition coff.h:1058

COFF::COFFFormat::Section::ECOFF_Flags::TLSDATA
static constexpr uint32_t TLSDATA
ECOFF section flag: Initialized TLS data (ECOFF name: STYP_TLSDATA)
Definition coff.h:1042

COFF::COFFFormat::Section::ECOFF_Flags::COMMENT
static constexpr uint32_t COMMENT
ECOFF section flag: Comment section (ECOFF name: STYP_COMMENT)
Definition coff.h:1036

COFF::COFFFormat::Section::ECOFF_Flags::LIT8
static constexpr uint32_t LIT8
ECOFF section flag: 8-byte literals (ECOFF name: STYP_LIT8)
Definition coff.h:1052

COFF::COFFFormat::Section::ECOFF_Flags::CONFLICT
static constexpr uint32_t CONFLICT
ECOFF section flag: Additional dynamic linking information (ECOFF name: STYP_CONFLICT)
Definition coff.h:1032

COFF::COFFFormat::Section::ECOFF_Flags::PDATA
static constexpr uint32_t PDATA
ECOFF section flag: Exception procedure table (ECOFF name: STYP_PDATA)
Definition coff.h:1048

COFF::COFFFormat::Section::ECOFF_Flags::DSOLIST
static constexpr uint32_t DSOLIST
ECOFF section flag: Shared library dependency list (ECOFF name: STYP_DSOLIST)
Definition coff.h:1026

COFF::COFFFormat::Section::ECOFF_Flags::UCODE
static constexpr uint32_t UCODE
ECOFF section flag: (ECOFF name: STYP_UCODE)
Definition coff.h:1012

COFF::COFFFormat::Section::ECOFF_Flags::RCONST
static constexpr uint32_t RCONST
ECOFF section flag: Read-only constants (ECOFF name: STYP_RCONST)
Definition coff.h:1038

COFF::COFFFormat::Section::ECOFF_Flags::DYNAMIC
static constexpr uint32_t DYNAMIC
ECOFF section flag: Dynamic linking information (ECOFF name: STYP_DYNAMIC)
Definition coff.h:1016

COFF::COFFFormat::Section::PECOFF_Flags
Definition coff.h:1063

COFF::COFFFormat::Section::PECOFF_Flags::LNK_INFO
static constexpr uint32_t LNK_INFO
PE section flag: Section contains comments.
Definition coff.h:1069

COFF::COFFFormat::Section::PECOFF_Flags::MEM_NOT_PAGED
static constexpr uint32_t MEM_NOT_PAGED
PE section flag: Section is not pageable.
Definition coff.h:1095

COFF::COFFFormat::Section::PECOFF_Flags::GPREL
static constexpr uint32_t GPREL
PE section flag: Section data accessed through the global pointer.
Definition coff.h:1075

COFF::COFFFormat::Section::PECOFF_Flags::MEM_LOCKED
static constexpr uint32_t MEM_LOCKED
PE section flag: reserved.
Definition coff.h:1081

COFF::COFFFormat::Section::PECOFF_Flags::LNK_COMDAT
static constexpr uint32_t LNK_COMDAT
PE section flag: Section contains COMDAT data.
Definition coff.h:1073

COFF::COFFFormat::Section::PECOFF_Flags::MEM_NOT_CACHED
static constexpr uint32_t MEM_NOT_CACHED
PE section flag: Section cannot be cached.
Definition coff.h:1093

COFF::COFFFormat::Section::PECOFF_Flags::MEM_WRITE
static constexpr uint32_t MEM_WRITE
PE section flag: Section can be written to.
Definition coff.h:1103

COFF::COFFFormat::Section::PECOFF_Flags::LNK_OTHER
static constexpr uint32_t LNK_OTHER
PE section flag: reserved.
Definition coff.h:1067

COFF::COFFFormat::Section::PECOFF_Flags::MEM_PURGEABLE
static constexpr uint32_t MEM_PURGEABLE
PE section flag: reserved.
Definition coff.h:1077

COFF::COFFFormat::Section::PECOFF_Flags::MEM_16BIT
static constexpr uint32_t MEM_16BIT
PE section flag: reserved.
Definition coff.h:1079

COFF::COFFFormat::Section::PECOFF_Flags::MEM_PRELOAD
static constexpr uint32_t MEM_PRELOAD
PE section flag: reserved.
Definition coff.h:1083

COFF::COFFFormat::Section::PECOFF_Flags::ALIGN_SHIFT
static constexpr uint32_t ALIGN_SHIFT
PE section flag: alignment shift.
Definition coff.h:1087

COFF::COFFFormat::Section::PECOFF_Flags::MEM_SHARED
static constexpr uint32_t MEM_SHARED
PE section flag: Section can be shared in memory.
Definition coff.h:1097

COFF::COFFFormat::Section::PECOFF_Flags::ALIGN_MASK
static constexpr uint32_t ALIGN_MASK
PE section flag: alignment mask.
Definition coff.h:1085

COFF::COFFFormat::Section::PECOFF_Flags::LNK_NRELOC_OVFL
static constexpr uint32_t LNK_NRELOC_OVFL
PE section flag: Section contains more than 65535 relocations.
Definition coff.h:1089

COFF::COFFFormat::Section::PECOFF_Flags::TYPE_NO_PAD
static constexpr uint32_t TYPE_NO_PAD
PE section flag: Section should not be padded.
Definition coff.h:1065

COFF::COFFFormat::Section::PECOFF_Flags::MEM_EXECUTE
static constexpr uint32_t MEM_EXECUTE
PE section flag: Section data can be executed.
Definition coff.h:1099

COFF::COFFFormat::Section::PECOFF_Flags::MEM_READ
static constexpr uint32_t MEM_READ
PE section flag: Section can be read from.
Definition coff.h:1101

COFF::COFFFormat::Section::PECOFF_Flags::LNK_REMOVE
static constexpr uint32_t LNK_REMOVE
PE section flag: Section should be removed when generating image.
Definition coff.h:1071

COFF::COFFFormat::Section::PECOFF_Flags::MEM_DISCARDABLE
static constexpr uint32_t MEM_DISCARDABLE
PE section flag: Section can be discarded.
Definition coff.h:1091

COFF::COFFFormat::Section::TICOFF_Flags
Definition coff.h:1133

COFF::COFFFormat::Section::TICOFF_Flags::PASS
static constexpr uint32_t PASS
TI COFF section flag: Section should not be changed (TI COFF name: STYP_PASS)
Definition coff.h:1147

COFF::COFFFormat::Section::TICOFF_Flags::VECTOR
static constexpr uint32_t VECTOR
TI COFF section flag: Section contains vector table (TI COFF name: STYP_VECTOR)
Definition coff.h:1151

COFF::COFFFormat::Section::TICOFF_Flags::CLINK
static constexpr uint32_t CLINK
TI COFF section flag: Conditional linking required (TI COFF name: STYP_CLINK)
Definition coff.h:1149

COFF::COFFFormat::Section::TICOFF_Flags::NOLOAD
static constexpr uint32_t NOLOAD
COFF section flag: Noload section (COFF name: STYP_NOLOAD)
Definition coff.h:1137

COFF::COFFFormat::Section::TICOFF_Flags::COPY
static constexpr uint32_t COPY
COFF section flag: Copy section (COFF name: STYP_COPY)
Definition coff.h:1143

COFF::COFFFormat::Section::TICOFF_Flags::DSECT
static constexpr uint32_t DSECT
COFF section flag: Dummy section (COFF name: STYP_DSECT)
Definition coff.h:1135

COFF::COFFFormat::Section::TICOFF_Flags::PAD
static constexpr uint32_t PAD
COFF section flag: Padding section (COFF name: STYP_PAD)
Definition coff.h:1141

COFF::COFFFormat::Section::TICOFF_Flags::PADDED
static constexpr uint32_t PADDED
TI COFF section flag: Section has been padded (TI COFF name: STYP_PADDED)
Definition coff.h:1153

COFF::COFFFormat::Section::TICOFF_Flags::GROUP
static constexpr uint32_t GROUP
COFF section flag: Grouped section, formed from input sections (COFF name: STYP_GROUP)
Definition coff.h:1139

COFF::COFFFormat::Section::TICOFF_Flags::BLOCK
static constexpr uint32_t BLOCK
TI COFF section flag: Alignment used as a blocking factor (TI COFF name: STYP_BLOCK)
Definition coff.h:1145

COFF::COFFFormat::Section::XCOFF_Flags
Definition coff.h:1108

COFF::COFFFormat::Section::XCOFF_Flags::OVERFLO
static constexpr uint32_t OVERFLO
XCOFF section flag: (XCOFF name: STYP_OVERFLO)
Definition coff.h:1128

COFF::COFFFormat::Section::XCOFF_Flags::INFO
static constexpr uint32_t INFO
XCOFF section flag: Comment section (XCOFF name: STYP_INFO)
Definition coff.h:1116

COFF::COFFFormat::Section::XCOFF_Flags::DWARF
static constexpr uint32_t DWARF
XCOFF section flag: DWARF relocation section (XCOFF name: STYP_DWARF)
Definition coff.h:1112

COFF::COFFFormat::Section::XCOFF_Flags::EXCEPT
static constexpr uint32_t EXCEPT
XCOFF section flag: Exception section (XCOFF name: STYP_EXCEPT)
Definition coff.h:1114

COFF::COFFFormat::Section::XCOFF_Flags::TYPCHK
static constexpr uint32_t TYPCHK
XCOFF section flag: Type-check section (XCOFF name: STYP_TYPCHK)
Definition coff.h:1126

COFF::COFFFormat::Section::XCOFF_Flags::LOADER
static constexpr uint32_t LOADER
XCOFF section flag: Loader section (XCOFF name: STYP_LOADER)
Definition coff.h:1122

COFF::COFFFormat::Section::XCOFF_Flags::TBSS
static constexpr uint32_t TBSS
XCOFF section flag: Uninitialized thread-local data (XCOFF name: STYP_TBSS)
Definition coff.h:1120

COFF::COFFFormat::Section::XCOFF_Flags::TDATA
static constexpr uint32_t TDATA
XCOFF section flag: Initialized thread-local data (XCOFF name: STYP_TDATA)
Definition coff.h:1118

COFF::COFFFormat::Section::XCOFF_Flags::DEBUG
static constexpr uint32_t DEBUG
XCOFF section flag: Debug section (XCOFF name: STYP_DEBUG)
Definition coff.h:1124

COFF::COFFFormat::Section::XCOFF_Flags::PAD
static constexpr uint32_t PAD
XCOFF section flag: Padding section (XCOFF name: STYP_PAD)
Definition coff.h:1110