hunk.h

#ifndef HUNK_H
#define HUNK_H
 
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/module.h"
#include "../linker/section.h"
#include "../linker/segment.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
 
namespace Amiga
{
    class HunkFormat : public virtual Linker::SegmentManager
    {
    public:
        /* * * General members * * */
 
        class Hunk;
        class Module;
 
        struct Relocation
        {
            size_t size;
            enum relocation_type
            {
                Absolute,
                SelfRelative,
                DataRelative,
                SelfRelative26,
            };
            relocation_type type;
            uint32_t offset;
            Relocation(size_t size, relocation_type type, uint32_t offset)
                : size(size), type(type), offset(offset)
            {
            }
            bool operator <(const Relocation& other) const;
        };
 
        class Block
        {
        public:
            enum block_type
            {
                HUNK_UNIT = 0x3E7,
                HUNK_NAME = 0x3E8,
                HUNK_CODE = 0x3E9,
                HUNK_DATA = 0x3EA,
                HUNK_BSS = 0x3EB,
                HUNK_ABSRELOC32 = 0x3EC,
                HUNK_RELRELOC16 = 0x3ED,
                HUNK_RELRELOC8 = 0x3EE,
                HUNK_EXT = 0x3EF,
                HUNK_SYMBOL = 0x3F0,
                HUNK_DEBUG = 0x3F1,
                HUNK_END = 0x3F2,
                HUNK_HEADER = 0x3F3,
                HUNK_OVERLAY = 0x3F5,
                HUNK_BREAK = 0x3F6,
                HUNK_DRELOC32 = 0x3F7,
                HUNK_DRELOC16 = 0x3F8,
                HUNK_DRELOC8 = 0x3F9,
                HUNK_LIB = 0x3FA,
                HUNK_INDEX = 0x3FB,
                HUNK_RELOC32SHORT = 0x3FC,
                HUNK_RELRELOC32 = 0x3FD,
                HUNK_ABSRELOC16 = 0x3FE,
                HUNK_PPC_CODE = 0x4E9,
                HUNK_RELRELOC26 = 0x4EC,
 
                HUNK_V37_RELOC32SHORT = 0x3F7,
            };
            block_type type;
            bool is_executable = false;
            Block(block_type type, bool is_executable = false)
                : type(type), is_executable(is_executable)
            {
            }
            virtual ~Block() = default;
            static std::shared_ptr<Block> ReadBlock(Linker::Reader& rd, bool is_executable = false);
            virtual void Read(Linker::Reader& rd);
            virtual void Write(Linker::Writer& wr) const;
            virtual offset_t FileSize() const;
            virtual void Dump(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const;
            void AddCommonFields(Dumper::Region& region, unsigned index) const;
            virtual void AddExtraFields(Dumper::Region& region, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const;
        };
 
        class TextBlock : public Block
        {
        public:
            std::string name;
 
            TextBlock(block_type type, std::string name = "")
                : Block(type), name(name)
            {
            }
 
            void Read(Linker::Reader& rd) override;
            void Write(Linker::Writer& wr) const override;
            offset_t FileSize() const override;
        };
 
        class HeaderBlock : public Block
        {
        public:
            std::vector<std::string> library_names;
            uint32_t table_size = 0;
            uint32_t first_hunk = 0;
            std::vector<uint32_t> hunk_sizes;
 
            HeaderBlock()
                : Block(HUNK_HEADER)
            {
            }
 
            void Read(Linker::Reader& rd) override;
            void Write(Linker::Writer& wr) const override;
            offset_t FileSize() const override;
 
            void Dump(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
            void AddExtraFields(Dumper::Region& region, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
        };
 
        class RelocatableBlock : public Block
        {
        public:
            enum
            {
                FlagMask      = 0xE0000000,
                BitAdvisory   = 0x20000000,
                BitChipMem    = 0x40000000,
                BitFastMem    = 0x80000000,
                BitAdditional = 0xC0000000,
            };
 
            enum flag_type
            {
                LoadAny      = 0x00000000,
                LoadPublic   = 0x00000001, /* default, not stored */
                LoadChipMem  = 0x00000002,
                LoadFastMem  = 0x00000004,
                LoadLocalMem = 0x00000008,
                Load24BitDma = 0x00000010,
                LoadClear    = 0x00010000,
            };
            flag_type flags;
            bool loaded_with_additional_flags = false;
 
            RelocatableBlock(block_type type, uint32_t flags = LoadAny)
                : Block(type), flags(flag_type(flags | LoadPublic))
            {
            }
 
            uint32_t GetSizeField() const;
 
            bool RequiresAdditionalFlags() const;
 
            uint32_t GetAdditionalFlags() const;
 
            void Read(Linker::Reader& rd) override;
            void Write(Linker::Writer& wr) const override;
            offset_t FileSize() const override;
 
            void AddExtraFields(Dumper::Region& region, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
 
        protected:
            virtual uint32_t GetSize() const = 0;
            virtual void ReadBody(Linker::Reader& rd, uint32_t longword_count);
            virtual void WriteBody(Linker::Writer& wr) const;
        };
 
        class LoadBlock : public RelocatableBlock
        {
        public:
            std::shared_ptr<Linker::Image> image;
 
            LoadBlock(block_type type, uint32_t flags = LoadAny)
                : RelocatableBlock(type, flags)
            {
            }
 
            void Dump(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
 
        protected:
            uint32_t GetSize() const override;
            void ReadBody(Linker::Reader& rd, uint32_t longword_count) override;
            void WriteBody(Linker::Writer& wr) const override;
        };
 
        class BssBlock : public RelocatableBlock
        {
        public:
            uint32_t size;
 
            BssBlock(uint32_t size = 0, uint32_t flags = LoadAny)
                : RelocatableBlock(HUNK_BSS, flags), size(size)
            {
            }
 
            offset_t FileSize() const override;
 
            void AddExtraFields(Dumper::Region& region, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
 
        protected:
            uint32_t GetSize() const override;
            void ReadBody(Linker::Reader& rd, uint32_t longword_count) override;
        };
 
        class RelocationBlock : public Block
        {
        public:
            struct RelocationData
            {
                uint32_t hunk;
                std::vector<uint32_t> offsets;
            };
            std::vector<RelocationData> relocations;
 
            RelocationBlock(block_type type, bool is_executable = false)
                : Block(type, is_executable)
            {
            }
 
            bool IsShortRelocationBlock() const;
 
            size_t GetRelocationSize() const;
 
            Relocation::relocation_type GetRelocationType() const;
 
            void Read(Linker::Reader& rd) override;
            void Write(Linker::Writer& wr) const override;
            offset_t FileSize() const override;
 
            void Dump(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
        };
 
        class SymbolBlock : public Block
        {
        public:
            class Unit
            {
            public:
                enum symbol_type
                {
                    EXT_SYMB = 0,
                    EXT_DEF = 1,
                    EXT_ABS = 2,
                    EXT_RES = 3,
 
                    EXT_ABSREF32 = 129,
                    EXT_COMMON = 130,
                    EXT_RELREF16 = 131,
                    EXT_RELREF8 = 132,
                    EXT_DREF32 = 133,
                    EXT_DREF16 = 134,
                    EXT_DREF8 = 135,
                    EXT_RELREF32 = 136,
                    EXT_RELCOMMON = 137,
                    EXT_ABSREF16 = 138,
                    EXT_ABSREF8 = 139,
                    EXT_RELREF26 = 229,
                };
                symbol_type type;
                std::string name;
 
                Unit(symbol_type type, std::string name)
                    : type(type), name(name)
                {
                }
 
                static std::unique_ptr<Unit> ReadData(Linker::Reader& rd);
 
                virtual ~Unit() = default;
                virtual void Read(Linker::Reader& rd);
                virtual void Write(Linker::Writer& wr) const;
                virtual offset_t FileSize() const;
                virtual void DumpContents(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const;
                virtual void AddExtraFields(Dumper::Dumper& dump, Dumper::Entry& entry, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const;
            };
 
            class Definition : public Unit
            {
            public:
                uint32_t value;
 
                Definition(symbol_type type, std::string name, uint32_t value = 0)
                    : Unit(type, name), value(value)
                {
                }
 
                void Read(Linker::Reader& rd) override;
                void Write(Linker::Writer& wr) const override;
                offset_t FileSize() const override;
                void AddExtraFields(Dumper::Dumper& dump, Dumper::Entry& entry, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
            };
 
            class References : public Unit
            {
            public:
                std::vector<uint32_t> references;
 
                References(symbol_type type, std::string name)
                    : Unit(type, name)
                {
                }
 
                void Read(Linker::Reader& rd) override;
                void Write(Linker::Writer& wr) const override;
                offset_t FileSize() const override;
                void DumpContents(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
            };
 
            class CommonReferences : public References
            {
            public:
                uint32_t size;
 
                CommonReferences(symbol_type type, std::string name, uint32_t size = 0)
                    : References(type, name), size(size)
                {
                }
 
                void Read(Linker::Reader& rd) override;
                void Write(Linker::Writer& wr) const override;
                offset_t FileSize() const override;
                void AddExtraFields(Dumper::Dumper& dump, Dumper::Entry& entry, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
            };
 
            std::vector<std::unique_ptr<Unit>> symbols;
 
            SymbolBlock(block_type type)
                : Block(type)
            {
            }
 
            void Read(Linker::Reader& rd) override;
            void Write(Linker::Writer& wr) const override;
            offset_t FileSize() const override;
            void Dump(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
        };
 
        class DebugBlock : public Block
        {
        public:
            // TODO: untested
            std::shared_ptr<Linker::Image> image;
 
            DebugBlock()
                : Block(HUNK_DEBUG)
            {
            }
 
            void Read(Linker::Reader& rd) override;
            void Write(Linker::Writer& wr) const override;
            offset_t FileSize() const override;
 
            void Dump(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
        };
 
        class OverlayBlock : public Block
        {
        public:
            // TODO: untested
            uint32_t maximum_level = 2;
 
            struct OverlaySymbol
            {
                uint32_t offset;
                uint32_t res1, res2;
                uint32_t level;
                uint32_t ordinate;
                uint32_t first_hunk;
                uint32_t symbol_hunk;
                uint32_t symbol_offset;
            };
 
            std::vector<OverlaySymbol> overlay_data_table;
 
            OverlayBlock()
                : Block(HUNK_OVERLAY)
            {
            }
 
            void Read(Linker::Reader& rd) override;
            void Write(Linker::Writer& wr) const override;
            offset_t FileSize() const override;
 
            void Dump(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
        };
 
        class LibraryBlock : public Block
        {
        public:
            // TODO: untested
 
            std::unique_ptr<Module> hunks;
 
            LibraryBlock()
                : Block(HUNK_LIB)
            {
            }
 
            void Read(Linker::Reader& rd) override;
            void Write(Linker::Writer& wr) const override;
            offset_t FileSize() const override;
 
            void Dump(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
        };
 
        class IndexBlock : public Block
        {
        public:
            // TODO: untested
 
            class Definition
            {
            public:
                uint16_t string_offset = 0;
                uint16_t symbol_offset = 0;
                uint16_t type = 0;
 
                static Definition Read(Linker::Reader& rd);
                void Write(Linker::Writer& wr) const;
            };
 
            class HunkEntry
            {
            public:
                uint16_t string_offset = 0;
                uint16_t hunk_size = 0; // in longwords
                uint16_t hunk_type = 0;
                std::vector<uint16_t> references;
                std::vector<Definition> definitions;
 
                static HunkEntry Read(Linker::Reader& rd);
                void Write(Linker::Writer& wr) const;
                offset_t FileSize() const;
            };
 
            class ProgramUnit
            {
            public:
                int16_t string_offset = 0;
                uint16_t first_hunk_offset = 0; // in longwords
                std::vector<HunkEntry> hunks;
 
                static ProgramUnit Read(Linker::Reader& rd);
                void Write(Linker::Writer& wr) const;
                offset_t FileSize() const;
            };
 
            std::vector<std::string> strings;
            std::vector<ProgramUnit> units;
 
            IndexBlock()
                : Block(HUNK_INDEX)
            {
            }
 
            offset_t StringTableSize() const;
 
            void Read(Linker::Reader& rd) override;
            void Write(Linker::Writer& wr) const override;
            offset_t FileSize() const override;
 
            void Dump(Dumper::Dumper& dump, const Module& module, const Hunk * hunk, unsigned index, offset_t current_offset) const override;
        };
 
        class Hunk
        {
        public:
            std::vector<std::shared_ptr<Block>> blocks;
 
            enum hunk_type : uint32_t
            {
                Undefined = 0,
                Invalid = uint32_t(-1),
 
                Code = Block::HUNK_CODE,
                CodePPC = Block::HUNK_PPC_CODE,
                Data = Block::HUNK_DATA,
                Bss = Block::HUNK_BSS,
            };
            hunk_type type = Undefined;
 
            // TODO: implement advisory flag
 
            LoadBlock::flag_type flags = LoadBlock::LoadPublic;
            std::shared_ptr<Linker::Image> image;
            offset_t image_size = 0;
 
            std::string name;
 
            explicit Hunk()
                : type(Undefined), flags(LoadBlock::LoadAny), image(nullptr)
            {
            }
 
            Hunk(hunk_type type, std::string name = "image", unsigned flags = LoadBlock::LoadAny)
                : type(hunk_type(type)), flags(LoadBlock::flag_type(flags)), image(std::make_shared<Linker::Segment>(name))
            {
            }
 
            Hunk(hunk_type type, std::shared_ptr<Linker::Segment> segment, unsigned flags = LoadBlock::LoadAny)
                : type(hunk_type(type)), flags(LoadBlock::flag_type(flags)), image(segment)
            {
            }
 
            std::map<uint32_t, std::set<Relocation>> relocations;
 
            void ProduceBlocks();
 
            uint32_t GetMemorySize() const;
 
            uint32_t GetFileSize() const;
 
            uint32_t GetSizeField();
 
            void AppendBlock(std::shared_ptr<Block> block);
        };
 
        class Module
        {
        public:
            std::shared_ptr<Block> start_block;
            std::vector<Hunk> hunks;
            std::shared_ptr<Block> end_block;
 
            bool IsExecutable() const;
            offset_t ImageSize() const;
            void ReadFile(Linker::Reader& rd, std::shared_ptr<Block>& next_block, offset_t end);
            void WriteFile(Linker::Writer& wr) const;
            void Dump(Dumper::Dumper& dump, offset_t current_offset, unsigned index) const;
 
            offset_t GetHunkSizeInHeader(uint32_t index) const;
        };
 
        std::vector<Module> modules;
 
        bool IsExecutable() const;
 
        offset_t ImageSize() const override;
 
        void ReadFile(Linker::Reader& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        static std::string ReadString(uint32_t longword_count, Linker::Reader& rd);
        static std::string ReadString(Linker::Reader& rd, uint32_t& longword_count);
        static std::string ReadString(Linker::Reader& rd);
        static void WriteStringContents(Linker::Writer& wr, std::string name);
        static void WriteString(Linker::Writer& wr, std::string name);
        static offset_t MeasureString(std::string name);
 
        /* * * Writer members * * */
 
        enum cpu_type
        {
            CPU_M68K = Block::HUNK_CODE,
            CPU_PPC = Block::HUNK_PPC_CODE,
        };
        cpu_type cpu = CPU_PPC;
 
        /* @brief Convenience map to make it easier to look up the indices of segments */
        std::map<std::shared_ptr<Linker::Segment>, size_t> segment_index;
 
        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;
 
        enum flags
        {
            FastMemory = Linker::Section::CustomFlag,
            ChipMemory = Linker::Section::CustomFlag << 1,
        };
 
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        void AddHunk(const Hunk& hunk);
 
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
 
        std::unique_ptr<Script::List> GetScript(Linker::Module& module);
 
        void Link(Linker::Module& module);
 
        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) const override;
 
    };
 
}
 
#endif /* HUNK_H */