RetroLinker/coff_8h_source.html

#ifndef COFF_H

#define COFF_H


#include <map>

#include "cpm68k.h"

#include "mzexe.h"

#include "../common.h"

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

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

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

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

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


namespace COFF

{


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

    {

    public:

        /* * * General members * * */


        enum cpu

        {

            CPU_UNKNOWN = 0,


            CPU_I386  = 0x014C,


            CPU_M68K  = 0x0150,


            CPU_W65   = 0x6500,


            CPU_Z80   = 0x805A,


            CPU_Z8K   = 0x8000,


            CPU_I86   = 0x0148,


            CPU_NS32K = 0x0154,


            CPU_I370  = 0x0158,


            CPU_MIPS  = 0x0160,


            CPU_M88K  = 0x016D,


            CPU_WE32K = 0x0170,


            CPU_VAX   = 0x0178,


            CPU_AM29K = 0x017A,


            CPU_ALPHA = 0x0183,


            CPU_PPC   = 0x01DF,


            CPU_PPC64 = 0x01F7,


            CPU_SHARC = 0x521C,


            CPU_C5400 = 0x0098,

            CPU_C6000 = 0x0099,

            CPU_C5500 = 0x009C,

            CPU_MSP430 = 0x00A0,


            CPU_I860  = 0x014D,


            CPU_SH    = 0x01A2,


            CPU_ARM   = 0x01C0,


            CPU_AM33  = 0x01D3,


            CPU_IA64  = 0x0200,


            CPU_HPPA  = 0x0290,


            CPU_EFI   = 0x0EBC,


            CPU_RISCV32 = 0x5032,


            CPU_RISCV64 = 0x5064,


            CPU_RISCV128 = 0x5128,


            CPU_AMD64 = 0x8664,


            CPU_M32R  = 0x9041,


            CPU_ARM64 = 0xAA64,


            // for now, there are no overloaded values

        };


        enum COFFVariantType

        {

            COFF = 1,

            ECOFF = 2,

            XCOFF32 = 3,

            XCOFF64 = 4,

            PECOFF = 5,

            TICOFF = 6,

            TICOFF1 = 7,

        };


        static constexpr COFFVariantType AnyCOFFVariant = COFFVariantType(0);


        struct MachineType

        {

            cpu actual_cpu;

            ::EndianType endian;

            COFFVariantType coff_variant = AnyCOFFVariant;

        };


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


        offset_t file_size;


        char signature[2] = { };


        ::EndianType GetEndianType() const;


        class Relocation

        {

        public:

            virtual ~Relocation();

            virtual offset_t GetAddress() const = 0;

            virtual size_t GetSize() const = 0;

            virtual size_t GetEntrySize() const = 0;

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

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

        };


        class UNIXRelocation : public Relocation

        {

        public:

            static constexpr uint16_t R_ABS = 0;

            static constexpr uint16_t R_DIR16 = 1;

            static constexpr uint16_t R_REL16 = 2;

            static constexpr uint16_t R_DIR32 = 6;

            static constexpr uint16_t R_DIR32NB = 7;

            static constexpr uint16_t R_SEG12 = 9;

            static constexpr uint16_t R_SECTION = 10;

            static constexpr uint16_t R_SECREL = 11;

            static constexpr uint16_t R_TOKEN = 12;

            static constexpr uint16_t R_SECREL7 = 13;

            static constexpr uint16_t R_REL32 = 20;


            COFFVariantType coff_variant;

            cpu cpu_type;


            offset_t address = 0;

            uint32_t symbol_index = 0;

            uint16_t type = 0;

            uint32_t information = 0;


            UNIXRelocation(COFFVariantType coff_variant, cpu cpu_type)

                : coff_variant(coff_variant), cpu_type(cpu_type)

            {

            }


            void Read(Linker::Reader& rd);


            offset_t GetAddress() const override;


            size_t GetSize() const override;


            size_t GetEntrySize() const override;


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


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

        };


        class ZilogRelocation : public Relocation

        {

        public:

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

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

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


            static constexpr uint16_t R_Z80_IMM8  = 0x22;

            static constexpr uint16_t R_Z80_IMM16 = 0x01;

            static constexpr uint16_t R_Z80_IMM24 = 0x33;

            static constexpr uint16_t R_Z80_IMM32 = 0x17;

            static constexpr uint16_t R_Z80_OFF8  = 0x32;

            static constexpr uint16_t R_Z80_JR    = 0x02;


            static constexpr uint16_t R_Z8K_IMM4L = 0x23;

            static constexpr uint16_t R_Z8K_IMM4H = 0x24;

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

            static constexpr uint16_t R_Z8K_IMM8  = 0x22;

            static constexpr uint16_t R_Z8K_IMM16 = 0x01;

            static constexpr uint16_t R_Z8K_REL16 = 0x04;

            static constexpr uint16_t R_Z8K_IMM32 = 0x11;

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

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


            static constexpr uint16_t R_W65_ABS8     = 0x01;

            static constexpr uint16_t R_W65_ABS16    = 0x02;

            static constexpr uint16_t R_W65_ABS24    = 0x03;

            static constexpr uint16_t R_W65_ABS8S8   = 0x04;

            static constexpr uint16_t R_W65_ABS8S16  = 0x05;

            static constexpr uint16_t R_W65_ABS16S8  = 0x06;

            static constexpr uint16_t R_W65_ABS16S16 = 0x07;

            static constexpr uint16_t R_W65_PCR8     = 0x08;

            static constexpr uint16_t R_W65_PCR16    = 0x09;

            static constexpr uint16_t R_W65_DP       = 0x0A;


            cpu cpu_type;


            uint32_t address;

            uint32_t symbol_index;

            uint32_t offset;

            uint16_t type;

            uint16_t data;


            ZilogRelocation(cpu cpu_type)

                : cpu_type(cpu_type)

            {

            }


            void Read(Linker::Reader& rd);


            offset_t GetAddress() const override;


            size_t GetSize() const override;


            size_t GetEntrySize() const override;


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


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

        };


        class Symbol

        {

        public:

            std::string name;

            uint32_t name_index;

            uint32_t value;

            uint16_t section_number;

            uint16_t type;

            uint8_t storage_class;

            uint8_t auxiliary_count;


            void Read(Linker::Reader& rd);


            bool IsExternal() const;

        };


        class Section

        {

        public:

            std::string name;

            offset_t physical_address = 0;

            offset_t address = 0;

            offset_t size = 0;

            offset_t section_pointer = 0;

            offset_t relocation_pointer = 0;

            offset_t line_number_pointer = 0;

            uint32_t relocation_count = 0;

            uint32_t line_number_count = 0;

            uint32_t flags = 0;

            uint16_t memory_page_number = 0;


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


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


            /* COFF section flags */

            static constexpr uint32_t TEXT = 0x0020;

            static constexpr uint32_t DATA = 0x0040;

            static constexpr uint32_t BSS  = 0x0080;


            void Clear();


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

                : flags(flags), image(image)

            {

            }


            virtual ~Section();


            void ReadSectionHeader(Linker::Reader& rd, COFFVariantType coff_variant);


            void WriteSectionHeader(Linker::Writer& wr, COFFVariantType coff_variant);


            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;

        };


        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 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:

            static constexpr uint16_t OMAGIC = 0x0107;

            static constexpr uint16_t NMAGIC = 0x0108;

            static constexpr uint16_t ZMAGIC = 0x010B;

            uint16_t magic = 0;

            static constexpr uint16_t SYM_STAMP = 0x030D;

            uint16_t version_stamp = SYM_STAMP;

            uint16_t build_revision = 0;


            uint64_t code_size = 0;

            uint64_t data_size = 0;

            uint64_t bss_size = 0;

            uint64_t entry_address = 0;

            uint64_t code_address = 0;

            uint64_t data_address = 0;

            uint64_t bss_address = 0;

            uint32_t gpr_mask = 0;

            uint32_t fpr_mask = 0;

            uint64_t global_pointer = 0;


            ECOFFAOutHeader(uint16_t magic = 0)

                : magic(magic)

            {

            }


            uint32_t GetSize() const override;


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


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


            offset_t CalculateValues(COFFFormat& coff) override;


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

        };


        class XCOFFAOutHeader : public OptionalHeader

        {

        public:

            bool is64 = false;

            uint16_t magic = 0;

            uint16_t version_stamp = 0;

            uint64_t code_size = 0;

            uint64_t data_size = 0;

            uint64_t bss_size = 0;

            uint64_t entry_address = 0;

            uint64_t code_address = 0;

            uint64_t data_address = 0;

            uint64_t toc_address = 0;

            uint16_t entry_section = 0;

            uint16_t code_section = 0;

            uint16_t data_section = 0;

            uint16_t toc_section = 0;

            uint16_t loader_section = 0;

            uint16_t bss_section = 0;

            uint16_t code_align = 0;

            uint16_t data_align = 0;

            uint16_t module_type = 0;

            uint8_t cpu_flags = 0;

            uint8_t cpu_type = 0;

            uint64_t maximum_stack_size = 0;

            uint64_t maximum_data_size = 0;

            uint32_t debugger_data = 0;

            uint8_t code_page_size = 0;

            uint8_t text_page_size = 0;

            uint8_t stack_page_size = 0;

            uint8_t flags = 0;

            uint16_t tdata_section = 0;

            uint16_t tbss_section = 0;

            uint32_t xcoff64_flags = 0;

#if 0

            uint8_t shared_memory_page = 0;

#endif


            XCOFFAOutHeader(bool is64, uint16_t magic = 0)

                : is64(is64), magic(magic)

            {

            }


            uint32_t GetSize() const override;


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


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


            offset_t CalculateValues(COFFFormat& coff) override;


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

        };


        void Clear() override;


        void AssignMagicValue(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 * * */


        class COFFOptionCollector : public Linker::OptionCollector

        {

        public:

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


            COFFOptionCollector()

            {

                InitializeFields(stub);

            }

        };


        // for DJGPP binaries

        mutable Microsoft::MZSimpleStubWriter stub;


        enum format_type

        {

            GENERIC,

            DJGPP,

            CDOS68K,

            CDOS386,

            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,


            OMAGIC = 0x0107,

            NMAGIC = 0x0108,

            ZMAGIC = 0x010B,

            MAGIC_FLEXOS386 = 0x01C0,

        };


        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::AOutHeader
A standard 28 byte a.out optional header, used by DJGPP.
Definition coff.h:677

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:848

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:857

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

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

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

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

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

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

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

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:689

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:693

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:679

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:673

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:491

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:479

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

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

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

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:511

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

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

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:443

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

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:453

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:435

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:457

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

COFF::COFFFormat::UNIXRelocation
The standard UNIX COFF relocation format.
Definition coff.h:292

COFF::COFFFormat::UNIXRelocation::R_SECTION
static constexpr uint16_t R_SECTION
(Microsoft, debugging) 16-bit section index
Definition coff.h:307

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

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

COFF::COFFFormat::UNIXRelocation::R_DIR32NB
static constexpr uint16_t R_DIR32NB
(Microsoft COFF) 32-bit relative virtual address of symbol
Definition coff.h:303

COFF::COFFFormat::UNIXRelocation::R_SECREL7
static constexpr uint16_t R_SECREL7
(Microsoft) 7-bit offset from section base
Definition coff.h:313

COFF::COFFFormat::UNIXRelocation::R_REL32
static constexpr uint16_t R_REL32
32-bit relative address of symbol
Definition coff.h:315

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

COFF::COFFFormat::UNIXRelocation::R_SECREL
static constexpr uint16_t R_SECREL
(Microsoft, debugging) 32-bit offset from section start
Definition coff.h:309

COFF::COFFFormat::UNIXRelocation::R_TOKEN
static constexpr uint16_t R_TOKEN
(Microsoft) CLR token
Definition coff.h:311

COFF::COFFFormat::UNIXRelocation::R_DIR16
static constexpr uint16_t R_DIR16
16-bit virtual address of symbol
Definition coff.h:297

COFF::COFFFormat::UNIXRelocation::R_DIR32
static constexpr uint16_t R_DIR32
32-bit virtual address of symbol
Definition coff.h:301

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

COFF::COFFFormat::ZilogRelocation
A relocation, as stored by the Z80/Z8000 backend.
Definition coff.h:347

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

COFF::COFFFormat::ZilogRelocation::data
uint16_t data
unknown (COFF name: r_stuff)
Definition coff.h:402

COFF::COFFFormat::ZilogRelocation::address
uint32_t address
Address of the relocation (COFF name: r_vaddr)
Definition coff.h:386

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

COFF::COFFFormat::ZilogRelocation::offset
uint32_t offset
(COFF name: r_offset)
Definition coff.h:394

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

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

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:1729

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

COFF::COFFFormat::COFF
@ COFF
Standard COFF variant.
Definition coff.h:238

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

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

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

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

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

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

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

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

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:1171

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

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

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

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

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

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

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

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

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

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

COFF::COFFFormat::ZMAGIC
@ ZMAGIC
Stored as the magic of the a.out header.
Definition coff.h:1263

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

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

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

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

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:2301

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:2096

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:2091

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:1201

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

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:1211

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

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

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:2511

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

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

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

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

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:1196

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:2101

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

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

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

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:647

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:2111

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

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

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

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

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

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

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

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

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

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:193

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:215

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:467

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

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:16

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:269

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

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