RetroLinker/gsos_8h_source.html

#ifndef GSOS_H

#define GSOS_H


#include <optional>

#include <variant>

#include "../common.h"

#include "../dumper/dumper.h"

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

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

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

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


/* TODO: most of this code is not tested, it can parse and dump executable binaries */


namespace Apple

{


    class OMFFormat : public virtual Linker::SegmentManager

    {

    public:


        class Segment

        {

        public:

            offset_t segment_offset = 0;

            offset_t total_segment_size = 0;

            offset_t bss_size = 0;

            offset_t total_size = 0;


            enum segment_kind

            {

                SEG_CODE = 0x00,

                SEG_DATA = 0x01,

                SEG_JUMPTABLE = 0x02,

                SEG_PATHNAME = 0x04,

                SEG_LIBDICT = 0x08,

                SEG_INIT = 0x10,

                SEG_ABSBANK = 0x11,

                SEG_DIRPAGE = 0x12,

            };


            segment_kind kind = SEG_CODE;

            uint16_t flags = 0;

            uint8_t label_length = 0;

            uint8_t number_length = 4;

            enum omf_version

            {

                OMF_VERSION_0   = 0x0000, // TODO: unsure

                OMF_VERSION_1   = 0x0100,

                OMF_VERSION_2   = 0x0200,

                OMF_VERSION_2_1 = 0x0201,

            };

            omf_version version = OMF_VERSION_2;

            offset_t bank_size = 0;

            offset_t base_address = 0;

            offset_t align = 0x100;

            uint8_t endiantype = 0;

            uint8_t language_card_bank = 0;

            uint16_t segment_number = 0;

            offset_t entry = 0;

            offset_t segment_name_offset = 0x2C;

            offset_t segment_data_offset = 0;

            offset_t temp_org = 0;

            std::string linker_segment_name;

            std::string segment_name;


            static const uint16_t FLAG_BANK_RELATIVE = 0x0100;

            static const uint16_t FLAG_SKIP_SEGMENT = 0x0200;

            static const uint16_t FLAG_RELOAD = 0x0400;

            static const uint16_t FLAG_ABSOLUTE_BANK = 0x0800;

            static const uint16_t FLAG_NO_SPECIAL_MEMORY = 0x1000;

            static const uint16_t FLAG_POSITION_INDEPENDENT = 0x2000;

            static const uint16_t FLAG_PRIVATE = 0x4000;

            static const uint16_t FLAG_DYNAMIC = 0x8000;


            ::EndianType GetEndianType() const;


            offset_t ReadUnsigned(Linker::Reader& rd) const;

            void WriteWord(Linker::Writer& wr, offset_t value) const;


            std::string ReadLabel(Linker::Reader& rd) const;

            void WriteLabel(Linker::Writer& wr, std::string text) const;


            offset_t CalculateValues(uint16_t segment_number, offset_t current_offset);

            void ReadFile(Linker::Reader& rd);

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

            void Dump(Dumper::Dumper& dump, const OMFFormat& omf, unsigned segment_index) const;


            size_t ReadData(size_t bytes, offset_t offset, void * buffer) const;

            offset_t ReadUnsigned(size_t bytes, offset_t offset) const;


            class Expression

            {

            public:

                // TODO: untested


                enum operation_type

                {

                    End = 0x00,

                    Addition = 0x01,

                    Subtraction = 0x02,

                    Multiplication = 0x03,

                    Division = 0x04,

                    IntegerRemainder = 0x05,

                    Negation = 0x06,

                    BitShift = 0x07,

                    And = 0x08,

                    Or = 0x09,

                    EOr = 0x0A,

                    Not = 0x0B,

                    LessOrEqualTo = 0x0C,

                    GreaterOrEqualTo = 0x0D,

                    NotEqual = 0x0E,

                    LessThan = 0x0F,

                    GreaterThan = 0x10,

                    EqualTo = 0x11,

                    BitAnd = 0x12,

                    BitOr = 0x13,

                    BitEOr = 0x14,

                    BitNot = 0x15,

                    LocationCounterOperand = 0x80,

                    ConstantOperand = 0x81,

                    WeakLabelReferenceOperand = 0x82,

                    LabelReferenceOperand = 0x83,

                    LengthOfLabelReferenceOperand = 0x84,

                    TypeOfLabelReferenceOperand = 0x85,

                    CountOfLabelReferenceOperand = 0x86,

                    RelativeOffsetOperand = 0x87,


                    StackUnderflow = -1,

                };


                operation_type operation = End;

                std::vector<std::unique_ptr<Expression>> operands;

                std::optional<std::variant<offset_t, std::string>> value;


                Expression(int operation)

                    : operation(operation_type(operation))

                {

                }


                Expression(int operation, std::unique_ptr<Expression>& operand)

                    : operation(operation_type(operation))

                {

                    operands.emplace_back(std::move(operand));

                }


                Expression(int operation, std::unique_ptr<Expression>& operand1, std::unique_ptr<Expression>& operand2)

                    : operation(operation_type(operation))

                {

                    operands.emplace_back(std::move(operand1));

                    operands.emplace_back(std::move(operand2));

                }


                Expression(int operation, offset_t value)

                    : operation(operation_type(operation)), value(value)

                {

                }


                Expression(int operation, std::string value)

                    : operation(operation_type(operation)), value(value)

                {

                }


                offset_t GetLength(const Segment& segment) const;

                void ReadFile(Segment& segment, Linker::Reader& rd);

                void WriteFile(const Segment& segment, Linker::Writer& wr) const;

                std::string GetStandardNotation() const;

            protected:

                void PopElementsInto(size_t count, std::vector<std::unique_ptr<Expression>>& target);

                uint8_t ReadSingleOperation(Segment& segment, Linker::Reader& rd);


                struct precedence

                {

                    enum precedence_type

                    {

                        Or,

                        EOr,

                        And,

                        LessThan,

                        EqualTo,

                        BitOr,

                        BitEOr,

                        BitAnd,

                        BitShift,

                        Addition,

                        Multiplication,

                        Negation,

                    };

                };


                typedef precedence::precedence_type precedence_type;

                void GetStandardNotation(std::ostream& out, precedence_type precedence) const;

            };


            class Record

            {

            public:

                enum record_type

                {

                    // E: executable, O: object, L: library

                    OPC_END = 0x00, // EOL

                    OPC_CONST_BASE = 0x00,

                    OPC_CONST_FIRST = 0x01, // O

                    OPC_CONST_LAST = 0xDF, // O

                    OPC_ALIGN = 0xE0, // O

                    OPC_ORG = 0xE1, // O

                    OPC_RELOC = 0xE2, // E

                    OPC_INTERSEG = 0xE3, // E

                    OPC_USING = 0xE4, // O

                    OPC_STRONG = 0xE5, // O

                    OPC_GLOBAL = 0xE6, // O

                    OPC_GEQU = 0xE7, // O

                    OPC_MEM = 0xE8, // O

                    OPC_EXPR = 0xEB, // O

                    OPC_ZEXPR = 0xEC, // O

                    OPC_BEXPR = 0xED, // O

                    OPC_RELEXPR = 0xEE, // O

                    OPC_LOCAL = 0xEF, // O

                    OPC_EQU = 0xF0, // O

                    OPC_DS = 0xF1, // EOL

                    OPC_LCONST = 0xF2, // EOL

                    OPC_LEXPR = 0xF3, // O

                    OPC_ENTRY = 0xF4, // L

                    OPC_C_RELOC = 0xF5, // E

                    OPC_C_INTERSEG = 0xF6, // E

                    OPC_SUPER = 0xF7, // E (V2)

                };

                record_type type;


                Record(record_type type)

                    : type(type)

                {

                }


                virtual ~Record() = default;

                virtual offset_t GetLength(const Segment& segment) const;

                virtual offset_t GetMemoryLength(const Segment& segment, offset_t current_address) const;

                virtual void ReadFile(Segment& segment, Linker::Reader& rd);

                virtual void WriteFile(const Segment& segment, Linker::Writer& wr) const;

                virtual void Dump(Dumper::Dumper& dump, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const;

                virtual void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const;

                virtual void AddSignals(Dumper::Block& block, offset_t current_segment_offset) const;

                virtual void ReadData(size_t bytes, offset_t offset, void * buffer) const;

            };


            class DataRecord : public Record

            {

            public:

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


                DataRecord(record_type type, std::shared_ptr<Linker::Image> image)

                    : Record(type), image(image)

                {

                }


                DataRecord(record_type type)

                    : Record(type)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                offset_t GetMemoryLength(const Segment& segment, offset_t current_address) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void Dump(Dumper::Dumper& dump, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

                void ReadData(size_t bytes, offset_t offset, void * buffer) const override;

            };


            class ValueRecord : public Record

            {

            public:

                offset_t value;


                ValueRecord(record_type type, offset_t value)

                    : Record(type), value(value)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                offset_t GetMemoryLength(const Segment& segment, offset_t current_address) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

                void ReadData(size_t bytes, offset_t offset, void * buffer) const override;

            };


            class RelocationRecord : public Record

            {

            public:

                uint8_t size = 0;

                int8_t shift = 0;

                offset_t source = 0;

                offset_t target = 0;


                RelocationRecord(record_type type)

                    : Record(type)

                {

                }


                RelocationRecord(record_type type, uint8_t size, int8_t shift, offset_t source, offset_t target)

                    : Record(type), size(size), shift(shift), source(source), target(target)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

                void AddSignals(Dumper::Block& block, offset_t current_segment_offset) const override;

            };


            class IntersegmentRelocationRecord : public RelocationRecord

            {

            public:

                uint16_t file_number = 0;

                uint16_t segment_number = 0;


                explicit IntersegmentRelocationRecord()

                    : RelocationRecord(record_type(0))

                {

                }


                IntersegmentRelocationRecord(record_type type)

                    : RelocationRecord(type)

                {

                }


                IntersegmentRelocationRecord(record_type type, uint8_t size, uint8_t shift, offset_t source, uint16_t file_number, uint16_t segment_number, offset_t target)

                    : RelocationRecord(type, size, shift, source, target), file_number(file_number), segment_number(segment_number)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

            };


            class StringRecord : public Record

            {

            public:

                std::string name;


                StringRecord(record_type type, std::string name)

                    : Record(type), name(name)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

            };


            class LabelRecord : public Record

            {

            public:

                std::string name;

                uint16_t line_length = 0;

                enum operation_type

                {

                    OP_ADDRESS_DC = 'A',

                    OP_BOOL_DC = 'B',

                    OP_CHAR_DC = 'C',

                    OP_DOUBLE_DC = 'D',

                    OP_FLOAT_DC = 'E',

                    OP_EQU_GEQU = 'G',

                    OP_HEX_DC = 'H',

                    OP_INT_DC = 'I',

                    OP_REF_ADDRESS_DC = 'K',

                    OP_SOFT_REF_DC = 'L',

                    OP_INSTRUCTION = 'M',

                    OP_ASM_DIRECTIVE = 'N',

                    OP_ORG = 'O',

                    OP_ALIGN = 'P',

                    OP_DS = 'S',

                    OP_ARITHMETIC_SYMBOL = 'X',

                    OP_BOOL_SYMBOL = 'Y',

                    OP_CHAR_SYMBOL = 'Z'

                };

                operation_type operation = operation_type(0);

                uint16_t private_flag = 0;


                LabelRecord(record_type type)

                    : Record(type)

                {

                }


                LabelRecord(record_type type, std::string name, uint16_t line_length, int operation, uint16_t private_flag)

                    : Record(type), name(name), line_length(line_length), operation(operation_type(operation)), private_flag(private_flag)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

            };


            class LabelExpressionRecord : public LabelRecord

            {

            public:

                std::unique_ptr<Expression> expression;


                LabelExpressionRecord(record_type type)

                    : LabelRecord(type)

                {

                }


                LabelExpressionRecord(record_type type, std::string name, uint16_t line_length, int operation, uint16_t private_flag, std::unique_ptr<Expression> expression)

                    : LabelRecord(type, name, line_length, operation, private_flag), expression(std::move(expression))

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

            };


            class RangeRecord : public Record

            {

            public:

                offset_t start = 0;

                offset_t end = 0;


                RangeRecord(record_type type)

                    : Record(type)

                {

                }


                RangeRecord(record_type type, offset_t start, offset_t end)

                    : Record(type), start(start), end(end)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

            };


            class ExpressionRecord : public Record

            {

            public:

                uint8_t size = 0;

                std::unique_ptr<Expression> expression;


                ExpressionRecord(record_type type)

                    : Record(type)

                {

                }


                ExpressionRecord(record_type type, uint8_t size, std::unique_ptr<Expression> expression)

                    : Record(type), size(size), expression(std::move(expression))

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                offset_t GetMemoryLength(const Segment& segment, offset_t current_address) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

                void ReadData(size_t bytes, offset_t offset, void * buffer) const override;

            };


            class RelativeExpressionRecord : public ExpressionRecord

            {

            public:

                offset_t origin = 0;


                RelativeExpressionRecord(record_type type)

                    : ExpressionRecord(type)

                {

                }


                RelativeExpressionRecord(record_type type, uint8_t size, offset_t origin, std::unique_ptr<Expression> expression)

                    : ExpressionRecord(type, size, std::move(expression)), origin(origin)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

            };


            class EntryRecord : public Record

            {

            public:

                uint16_t segment_number;

                offset_t location;

                std::string name;


                EntryRecord(record_type type)

                    : Record(type)

                {

                }


                EntryRecord(record_type type, uint16_t segment_number, offset_t location, std::string name)

                    : Record(type), segment_number(segment_number), location(location), name(name)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

            };


            class SuperCompactRecord : public Record

            {

            public:

                enum super_record_type

                {

                    SUPER_RELOC2,

                    SUPER_RELOC3,

                    SUPER_INTERSEG1,

                    SUPER_INTERSEG13 = SUPER_INTERSEG1 - 1 + 13,

                    SUPER_INTERSEG25 = SUPER_INTERSEG1 - 1 + 25,

                    SUPER_INTERSEG36 = SUPER_INTERSEG1 - 1 + 36,

                };


                super_record_type super_type = super_record_type(0);


                std::vector<uint16_t> offsets;


                SuperCompactRecord(record_type type, super_record_type super_type = super_record_type(0))

                    : Record(type), super_type(super_type)

                {

                }


                offset_t GetLength(const Segment& segment) const override;

                void ReadFile(Segment& segment, Linker::Reader& rd) override;

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

            private:

                void WritePatchList(Linker::Writer& wr, const std::vector<uint8_t>& patches) const;


            public:

                void Dump(Dumper::Dumper& dump, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

                void AddFields(Dumper::Dumper& dump, Dumper::Region& region, const OMFFormat& omf, const Segment& segment, unsigned index, offset_t file_offset, offset_t address) const override;

                void AddSignals(Dumper::Block& block, offset_t current_segment_offset) const override;


                bool GetRelocation(IntersegmentRelocationRecord& relocation, unsigned index) const;

                bool GetRelocation(IntersegmentRelocationRecord& relocation, unsigned index, const Segment& segment) const;

            };


            std::vector<std::unique_ptr<Record>> records;


            std::unique_ptr<Expression> ReadExpression(Linker::Reader& rd);


            std::unique_ptr<Record> ReadRecord(Linker::Reader& rd);


            std::unique_ptr<Record> makeEND();

            std::unique_ptr<Record> makeCONST(std::shared_ptr<Linker::Image> image);

            std::unique_ptr<Record> makeCONST(size_t length);

            std::unique_ptr<Record> makeALIGN(offset_t align = 0);

            std::unique_ptr<Record> makeORG(offset_t value = 0);

            std::unique_ptr<Record> makeRELOC(uint8_t size, uint8_t shift, offset_t source, offset_t target);

            std::unique_ptr<Record> makeRELOC();

            std::unique_ptr<Record> makeINTERSEG(uint8_t size, uint8_t shift, offset_t source, uint16_t file_number, uint16_t segment_number, offset_t target);

            std::unique_ptr<Record> makeINTERSEG();

            std::unique_ptr<Record> makeUSING(std::string name = "");

            std::unique_ptr<Record> makeSTRONG(std::string name = "");

            std::unique_ptr<Record> makeGLOBAL();

            std::unique_ptr<Record> makeGLOBAL(std::string name, uint16_t line_length, int operation, uint16_t private_flag);

            std::unique_ptr<Record> makeGEQU();

            std::unique_ptr<Record> makeGEQU(std::string name, uint16_t line_length, int operation, uint16_t private_flag, std::unique_ptr<Expression> expression);

            std::unique_ptr<Record> makeMEM();

            std::unique_ptr<Record> makeMEM(offset_t start, offset_t end);

            std::unique_ptr<Record> makeEXPR();

            std::unique_ptr<Record> makeEXPR(uint8_t size, std::unique_ptr<Expression> expression);

            std::unique_ptr<Record> makeZEXPR();

            std::unique_ptr<Record> makeZEXPR(uint8_t size, std::unique_ptr<Expression> expression);

            std::unique_ptr<Record> makeBEXPR();

            std::unique_ptr<Record> makeBEXPR(uint8_t size, std::unique_ptr<Expression> expression);

            std::unique_ptr<Record> makeRELEXPR();

            std::unique_ptr<Record> makeRELEXPR(uint8_t size, offset_t origin, std::unique_ptr<Expression> expression);

            std::unique_ptr<Record> makeLOCAL();

            std::unique_ptr<Record> makeLOCAL(std::string name, uint16_t line_length, int operation, uint16_t private_flag);

            std::unique_ptr<Record> makeEQU();

            std::unique_ptr<Record> makeEQU(std::string name, uint16_t line_length, int operation, uint16_t private_flag, std::unique_ptr<Expression> expression);

            std::unique_ptr<Record> makeDS(offset_t count = 0);

            std::unique_ptr<Record> makeLCONST();

            std::unique_ptr<Record> makeLCONST(std::shared_ptr<Linker::Image> image);

            std::unique_ptr<Record> makeLEXPR();

            std::unique_ptr<Record> makeLEXPR(uint8_t size, std::unique_ptr<Expression> expression);

            std::unique_ptr<Record> makeENTRY();

            std::unique_ptr<Record> makeENTRY(uint16_t segment_number, offset_t location, std::string name);

            std::unique_ptr<Record> makecRELOC(uint8_t size, uint8_t shift, uint16_t source, uint16_t target);

            std::unique_ptr<Record> makecRELOC();

            std::unique_ptr<Record> makecINTERSEG(uint8_t size, uint8_t shift, uint16_t source, uint16_t segment_number, uint16_t target);

            std::unique_ptr<Record> makecINTERSEG();

            std::unique_ptr<Record> makeSUPER(SuperCompactRecord::super_record_type super_type = SuperCompactRecord::super_record_type(0));

        };


        std::vector<std::unique_ptr<Segment>> segments;


        void CalculateValues() override;

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

        using Linker::Format::WriteFile;

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

        offset_t ImageSize() const override;

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

        /* TODO */

    };


}


#endif /* GSOS_H */

Apple::OMFFormat::Segment::DataRecord
Represents a CONST or LCONST record, containing a sequence of bytes.
Definition gsos.h:329

Apple::OMFFormat::Segment::DataRecord::Dump
void Dump(Dumper::Dumper &dump, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Displays information pertaining to this record.
Definition gsos.cc:865

Apple::OMFFormat::Segment::DataRecord::ReadData
void ReadData(size_t bytes, offset_t offset, void *buffer) const override
Attempts to read data from the in-memory image, if possible, it can be assumed that offset + bytes <=...
Definition gsos.cc:878

Apple::OMFFormat::Segment::DataRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:821

Apple::OMFFormat::Segment::DataRecord::GetMemoryLength
offset_t GetMemoryLength(const Segment &segment, offset_t current_address) const override
Returns the amount of memory the record occupies when loaded into memory. Most records have a length ...
Definition gsos.cc:833

Apple::OMFFormat::Segment::EntryRecord
Represents an ENTRY record.
Definition gsos.h:581

Apple::OMFFormat::Segment::EntryRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:1267

Apple::OMFFormat::Segment::EntryRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:1247

Apple::OMFFormat::Segment::ExpressionRecord
Represents an EXPR, ZEXPR, BEXPR or LEXPR record.
Definition gsos.h:534

Apple::OMFFormat::Segment::ExpressionRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:1210

Apple::OMFFormat::Segment::ExpressionRecord::ReadData
void ReadData(size_t bytes, offset_t offset, void *buffer) const override
Attempts to read data from the in-memory image, if possible, it can be assumed that offset + bytes <=...
Definition gsos.cc:1216

Apple::OMFFormat::Segment::ExpressionRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:1187

Apple::OMFFormat::Segment::ExpressionRecord::GetMemoryLength
offset_t GetMemoryLength(const Segment &segment, offset_t current_address) const override
Returns the amount of memory the record occupies when loaded into memory. Most records have a length ...
Definition gsos.cc:1192

Apple::OMFFormat::Segment::Expression
Definition gsos.h:142

Apple::OMFFormat::Segment::Expression::value
std::optional< std::variant< offset_t, std::string > > value
A value corresponding to an operation, such as an integer constant or a label name.
Definition gsos.h:192

Apple::OMFFormat::Segment::Expression::operands
std::vector< std::unique_ptr< Expression > > operands
The operands the operation takes.
Definition gsos.h:190

Apple::OMFFormat::Segment::Expression::PopElementsInto
void PopElementsInto(size_t count, std::vector< std::unique_ptr< Expression > > &target)
Removes elements from the top of the operands stack and copies them into target. On stack underflow,...
Definition gsos.cc:432

Apple::OMFFormat::Segment::Expression::ReadSingleOperation
uint8_t ReadSingleOperation(Segment &segment, Linker::Reader &rd)
Reads a single byte of operation (plus optional number and label) and modifies the current list of op...
Definition gsos.cc:447

Apple::OMFFormat::Segment::Expression::operation_type
operation_type
Represents an operation inside an expression in the object file.
Definition gsos.h:151

Apple::OMFFormat::Segment::Expression::StackUnderflow
@ StackUnderflow
A symbolic value to represent a stack underflow condition, it should not be printed back into a binar...
Definition gsos.h:184

Apple::OMFFormat::Segment::Expression::GetStandardNotation
std::string GetStandardNotation() const
Converts expression into a C-like syntax.
Definition gsos.cc:425

Apple::OMFFormat::Segment::Expression::operation
operation_type operation
The type of operation, End means that the result is the last operand.
Definition gsos.h:188

Apple::OMFFormat::Segment::IntersegmentRelocationRecord
Represents an INTERSEG or cINTERSEG record, containing an intersegment relocation.
Definition gsos.h:398

Apple::OMFFormat::Segment::IntersegmentRelocationRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:1045

Apple::OMFFormat::Segment::IntersegmentRelocationRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:993

Apple::OMFFormat::Segment::LabelExpressionRecord
Represents an EQU or GEQU record.
Definition gsos.h:489

Apple::OMFFormat::Segment::LabelExpressionRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:1157

Apple::OMFFormat::Segment::LabelExpressionRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:1133

Apple::OMFFormat::Segment::LabelRecord
Represents a LOCAL or GLOBAL record.
Definition gsos.h:443

Apple::OMFFormat::Segment::LabelRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:1077

Apple::OMFFormat::Segment::LabelRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:1099

Apple::OMFFormat::Segment::RangeRecord
Represents a MEM record.
Definition gsos.h:511

Apple::OMFFormat::Segment::RangeRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:1181

Apple::OMFFormat::Segment::RangeRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:1163

Apple::OMFFormat::Segment::Record
A single record inside the segment body, also represents an END record.
Definition gsos.h:257

Apple::OMFFormat::Segment::Record::Dump
virtual void Dump(Dumper::Dumper &dump, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const
Displays information pertaining to this record.
Definition gsos.cc:772

Apple::OMFFormat::Segment::Record::AddFields
virtual void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:809

Apple::OMFFormat::Segment::Record::AddSignals
virtual void AddSignals(Dumper::Block &block, offset_t current_segment_offset) const
If this is a relocation record, add the relocation signals to the block.
Definition gsos.cc:813

Apple::OMFFormat::Segment::Record::ReadData
virtual void ReadData(size_t bytes, offset_t offset, void *buffer) const
Attempts to read data from the in-memory image, if possible, it can be assumed that offset + bytes <=...
Definition gsos.cc:817

Apple::OMFFormat::Segment::Record::GetMemoryLength
virtual offset_t GetMemoryLength(const Segment &segment, offset_t current_address) const
Returns the amount of memory the record occupies when loaded into memory. Most records have a length ...
Definition gsos.cc:758

Apple::OMFFormat::Segment::Record::GetLength
virtual offset_t GetLength(const Segment &segment) const
Returns the size of the record, as stored in the file.
Definition gsos.cc:753

Apple::OMFFormat::Segment::RelativeExpressionRecord
Represents a RELEXPR record.
Definition gsos.h:559

Apple::OMFFormat::Segment::RelativeExpressionRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:1221

Apple::OMFFormat::Segment::RelativeExpressionRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:1241

Apple::OMFFormat::Segment::RelocationRecord
Represents a RELOC or cRELOC record, containing an intrasegment relocation.
Definition gsos.h:372

Apple::OMFFormat::Segment::RelocationRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:932

Apple::OMFFormat::Segment::RelocationRecord::AddSignals
void AddSignals(Dumper::Block &block, offset_t current_segment_offset) const override
If this is a relocation record, add the relocation signals to the block.
Definition gsos.cc:985

Apple::OMFFormat::Segment::RelocationRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:977

Apple::OMFFormat::Segment::StringRecord
Represents a USING or STRONG record, containing a string.
Definition gsos.h:426

Apple::OMFFormat::Segment::StringRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:1072

Apple::OMFFormat::Segment::StringRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:1056

Apple::OMFFormat::Segment::SuperCompactRecord
Represents a SUPER record.
Definition gsos.h:605

Apple::OMFFormat::Segment::SuperCompactRecord::Dump
void Dump(Dumper::Dumper &dump, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Displays information pertaining to this record.
Definition gsos.cc:1379

Apple::OMFFormat::Segment::SuperCompactRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:1273

Apple::OMFFormat::Segment::SuperCompactRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:1402

Apple::OMFFormat::Segment::SuperCompactRecord::GetRelocation
bool GetRelocation(IntersegmentRelocationRecord &relocation, unsigned index) const
Expands the super compact relocation into a full relocation, without filling in the target fields.
Definition gsos.cc:1427

Apple::OMFFormat::Segment::SuperCompactRecord::AddSignals
void AddSignals(Dumper::Block &block, offset_t current_segment_offset) const override
If this is a relocation record, add the relocation signals to the block.
Definition gsos.cc:1416

Apple::OMFFormat::Segment::ValueRecord
Represents an ALIGN, ORG or DS record, containing an integer.
Definition gsos.h:353

Apple::OMFFormat::Segment::ValueRecord::GetMemoryLength
offset_t GetMemoryLength(const Segment &segment, offset_t current_address) const override
Returns the amount of memory the record occupies when loaded into memory. Most records have a length ...
Definition gsos.cc:889

Apple::OMFFormat::Segment::ValueRecord::GetLength
offset_t GetLength(const Segment &segment) const override
Returns the size of the record, as stored in the file.
Definition gsos.cc:884

Apple::OMFFormat::Segment::ValueRecord::ReadData
void ReadData(size_t bytes, offset_t offset, void *buffer) const override
Attempts to read data from the in-memory image, if possible, it can be assumed that offset + bytes <=...
Definition gsos.cc:927

Apple::OMFFormat::Segment::ValueRecord::AddFields
void AddFields(Dumper::Dumper &dump, Dumper::Region &region, const OMFFormat &omf, const Segment &segment, unsigned index, offset_t file_offset, offset_t address) const override
Adds any further fields to the file region that encompasses this record.
Definition gsos.cc:914

Apple::OMFFormat::Segment
Definition gsos.h:27

Apple::OMFFormat::Segment::segment_offset
offset_t segment_offset
Offset of segment within file.
Definition gsos.h:30

Apple::OMFFormat::Segment::WriteLabel
void WriteLabel(Linker::Writer &wr, std::string text) const
Writes a string the size of label_length, or variable length if it is 0.
Definition gsos.cc:41

Apple::OMFFormat::Segment::label_length
uint8_t label_length
(LABLEN) Label length, or 0 for variable length labels
Definition gsos.h:61

Apple::OMFFormat::Segment::total_size
offset_t total_size
(LENGTH) Total size of segment when loaded into memory, including the additional zeroes
Definition gsos.h:36

Apple::OMFFormat::Segment::WriteWord
void WriteWord(Linker::Writer &wr, offset_t value) const
Writes a number the size of number_length.
Definition gsos.cc:26

Apple::OMFFormat::Segment::bss_size
offset_t bss_size
(RESSPC) Additional zeroes to append to segment
Definition gsos.h:34

Apple::OMFFormat::Segment::base_address
offset_t base_address
(ORG) Base address of segment
Definition gsos.h:76

Apple::OMFFormat::Segment::language_card_bank
uint8_t language_card_bank
(LCBANK) Language card bank
Definition gsos.h:82

Apple::OMFFormat::Segment::number_length
uint8_t number_length
(NUMLEN) Number length, must be 4
Definition gsos.h:63

Apple::OMFFormat::Segment::version
omf_version version
(VERSION, REVISION) OMF file format version
Definition gsos.h:72

Apple::OMFFormat::Segment::FLAG_NO_SPECIAL_MEMORY
static const uint16_t FLAG_NO_SPECIAL_MEMORY
Segment flag: Do not load in special memory (version 2 only)
Definition gsos.h:107

Apple::OMFFormat::Segment::linker_segment_name
std::string linker_segment_name
(LOADNAME) Name of segment according to linker
Definition gsos.h:94

Apple::OMFFormat::Segment::align
offset_t align
(ALIGN) Segment alignment
Definition gsos.h:78

Apple::OMFFormat::Segment::FLAG_PRIVATE
static const uint16_t FLAG_PRIVATE
Segment flag: Private.
Definition gsos.h:111

Apple::OMFFormat::Segment::FLAG_ABSOLUTE_BANK
static const uint16_t FLAG_ABSOLUTE_BANK
Segment flag: Absolute bank segment (version 2 only)
Definition gsos.h:105

Apple::OMFFormat::Segment::temp_org
offset_t temp_org
(tempOrg) (only version 2.1, optional)
Definition gsos.h:92

Apple::OMFFormat::Segment::FLAG_RELOAD
static const uint16_t FLAG_RELOAD
Segment flag: Reload segment (version 2 only)
Definition gsos.h:103

Apple::OMFFormat::Segment::kind
segment_kind kind
(KIND) Segment type
Definition gsos.h:57

Apple::OMFFormat::Segment::total_segment_size
offset_t total_segment_size
(BYTECNT/BLKCNT) Total size of the segment, including the header, as stored in file
Definition gsos.h:32

Apple::OMFFormat::Segment::segment_name
std::string segment_name
(LOADNAME) Name of segment
Definition gsos.h:96

Apple::OMFFormat::Segment::entry
offset_t entry
(ENTRY) Entry point (not present in version 0)
Definition gsos.h:86

Apple::OMFFormat::Segment::endiantype
uint8_t endiantype
(NUMSEX) Endianness, must be 0 for LittleEndian
Definition gsos.h:80

Apple::OMFFormat::Segment::bank_size
offset_t bank_size
(BANKSIZE) Maximum bank size of segment
Definition gsos.h:74

Apple::OMFFormat::Segment::FLAG_POSITION_INDEPENDENT
static const uint16_t FLAG_POSITION_INDEPENDENT
Segment flag: Position independent.
Definition gsos.h:109

Apple::OMFFormat::Segment::segment_data_offset
offset_t segment_data_offset
(DISPDATA) Offset to segment data, typically appearing after segment_name (not present in version 0)
Definition gsos.h:90

Apple::OMFFormat::Segment::FLAG_BANK_RELATIVE
static const uint16_t FLAG_BANK_RELATIVE
Segment flag: Bank relative (version 2 only)
Definition gsos.h:99

Apple::OMFFormat::Segment::FLAG_DYNAMIC
static const uint16_t FLAG_DYNAMIC
Segment flag: Dynamic.
Definition gsos.h:113

Apple::OMFFormat::Segment::FLAG_SKIP_SEGMENT
static const uint16_t FLAG_SKIP_SEGMENT
Segment flag: Skip segment (version 2 only)
Definition gsos.h:101

Apple::OMFFormat::Segment::flags
uint16_t flags
(KIND) Segment flags
Definition gsos.h:59

Apple::OMFFormat::Segment::segment_number
uint16_t segment_number
(SEGNUM) Segment number (not present in version 0)
Definition gsos.h:84

Apple::OMFFormat::Segment::ReadUnsigned
offset_t ReadUnsigned(Linker::Reader &rd) const
Reads a number the size of number_length.
Definition gsos.cc:21

Apple::OMFFormat::Segment::segment_name_offset
offset_t segment_name_offset
(DISPNAME) Offset to linker_segment_name (LOADNAME), (not present in version 0)
Definition gsos.h:88

Apple::OMFFormat::Segment::segment_kind
segment_kind
Definition gsos.h:38

Apple::OMFFormat::Segment::SEG_CODE
@ SEG_CODE
Code segment.
Definition gsos.h:40

Apple::OMFFormat::Segment::SEG_DIRPAGE
@ SEG_DIRPAGE
Direct page/stack segment.
Definition gsos.h:54

Apple::OMFFormat::Segment::SEG_JUMPTABLE
@ SEG_JUMPTABLE
Jump table segment.
Definition gsos.h:44

Apple::OMFFormat::Segment::SEG_INIT
@ SEG_INIT
Initialization segment.
Definition gsos.h:50

Apple::OMFFormat::Segment::SEG_PATHNAME
@ SEG_PATHNAME
Pathname segment.
Definition gsos.h:46

Apple::OMFFormat::Segment::SEG_DATA
@ SEG_DATA
Data segment.
Definition gsos.h:42

Apple::OMFFormat::Segment::SEG_LIBDICT
@ SEG_LIBDICT
Library dictionary segment.
Definition gsos.h:48

Apple::OMFFormat::Segment::SEG_ABSBANK
@ SEG_ABSBANK
Absolute bank segment (version 1 only)
Definition gsos.h:52

Apple::OMFFormat::Segment::ReadLabel
std::string ReadLabel(Linker::Reader &rd) const
Reads a string the size of label_length, or variable length if it is 0.
Definition gsos.cc:31

Apple::OMFFormat
Apple GS/OS OMF file format.
Definition gsos.h:24

Apple::OMFFormat::ImageSize
offset_t ImageSize() const override
Retrieves size of stored data.
Definition gsos.cc:730

Apple::OMFFormat::ReadFile
void ReadFile(Linker::Reader &rd) override
Loads file into memory.
Definition gsos.cc:707

Apple::OMFFormat::WriteFile
offset_t WriteFile(Linker::Writer &wr) const override
Stores data in memory to file.
Definition gsos.cc:720

Apple::OMFFormat::CalculateValues
void CalculateValues() override
Intermediate step between processing module and generating output file to set up headers and manageme...
Definition gsos.cc:698

Apple::OMFFormat::Dump
void Dump(Dumper::Dumper &dump) const override
Display file contents in a nice manner.
Definition gsos.cc:737

Dumper::Block
A region within a file that can be dumped, decompiled, and it may contain fixups.
Definition dumper.h:524

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

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::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::SegmentManager::current_address
offset_t current_address
Holds the current address value when there is no current_segment.
Definition segment_manager.h:37

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

Apple::OMFFormat::Segment::Expression::precedence
Definition gsos.h:234