pefexe.h

#ifndef PEFEXE_H
#define PEFEXE_H
 
#include "macos.h"
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/buffer.h"
#include "../linker/reader.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
 
namespace Linker
{
    class Position;
}
 
namespace Apple
{
    class PEFHeaderBase
    {
    public:
        // values are stored as the bigendian 32-bit word
        enum cpu_type
        {
            M68K = 0x6D36386B, // 'm68k'
            PPC  = 0x70777063, // 'pwpc'
        };
        cpu_type architecture;
        uint32_t format_version = 1;
        ::Timestamp<Macintosh_clock> date_time_stamp = { };
        uint32_t old_def_version = 0;
        uint32_t old_imp_version = 0;
        uint32_t current_version = 0;
        uint16_t section_count = 0;
        uint16_t inst_section_count = 0;
        // only for PEF stored in the resource fork
        uint32_t memory_address = 0;
        uint32_t exported_symbol_count = 0;
        uint16_t secondary_resource_id = 0;
        uint16_t last_valid_code_resource = 0;
        uint32_t below_a5_size = 0;
 
        enum binary_type
        {
            UnknownBinary = -1,
            ImportLibrary = 0,
            Application = 1,
            UnflattenedLibrary = 0x100,
        };
        binary_type type;
 
        PEFHeaderBase(binary_type type = UnknownBinary, cpu_type architecture = PPC)
            : architecture(architecture), type(type)
        {
        }
 
        PEFHeaderBase(const PEFHeaderBase&) = default;
 
        void ReadBaseFields(const std::shared_ptr<Linker::Reader>& rd);
        void WriteBaseFields(const std::shared_ptr<Linker::Writer>& wr) const;
        void AddBaseFields(Dumper::Region& header_region) const;
    };
 
    class PEFFormat : public virtual Linker::SegmentManager
    {
    public:
        std::shared_ptr<PEFHeaderBase> header;
 
        enum target_system_type
        {
            MacOS,
            Carbon,
            BeOS, // TODO: unimplemented
        };
        target_system_type system_type = MacOS;
 
        PEFFormat(PEFHeaderBase::binary_type type = PEFHeaderBase::UnknownBinary, PEFHeaderBase::cpu_type architecture = PEFHeaderBase::PPC)
            : header(std::make_shared<PEFHeaderBase>(type, architecture))
        {
        }
 
        PEFFormat(const PEFHeaderBase& base)
            : header(std::make_shared<PEFHeaderBase>(base))
        {
        }
 
        uint32_t reserved = 0;
 
        class PatternInitialization
        {
        public:
            enum opcode_type
            {
                Zero = 0,
                BlockCopy = 1,
                RepeatedBlock = 2,
                InterleaveRepeatBlockWithBlockCopy = 3,
                InterleaveRepeatBlockWithZero = 4,
            };
            offset_t file_offset;
            opcode_type opcode;
            uint32_t count;
            std::vector<uint8_t> common_data;
            std::vector<std::vector<uint8_t>> custom_data;
 
            static uint32_t ReadValue(const std::shared_ptr<Linker::Reader>& rd);
            static size_t GetValueSize(uint32_t value, size_t size_hint = 0);
            static void WriteValue(const std::shared_ptr<Linker::Writer>& wr, uint32_t value, size_t size_hint = 0);
 
            void ReadFile(const std::shared_ptr<Linker::Reader>& rd);
            void WriteFile(const std::shared_ptr<Linker::Writer>& wr) const;
            offset_t CodeSize() const;
            offset_t DataSize() const;
            void ExpandData(Linker::Buffer& buffer) const;
        };
 
        class Section;
        class ImportedSymbol;
        class ImportedLibrary;
 
        class Relocation
        {
        public:
            // add 32-bit section start to offset
            enum target_type
            {
                Section,
                Symbol,
            };
            target_type type = Section;
            bool compiled = true;
            // section: section number, symbol: symbol number
            uint32_t number = 0;
            // only for section targets
            std::weak_ptr<PEFFormat::Section> section;
            // only for symbol targets
            std::weak_ptr<ImportedSymbol> symbol;
 
            static inline Relocation ToSection(uint32_t section_number)
            {
                Relocation relocation;
                relocation.type = Section;
                relocation.number = section_number;
                return relocation;
            }
 
            static inline Relocation ToSection(std::weak_ptr<PEFFormat::Section> section)
            {
                Relocation relocation;
                relocation.type = Section;
                relocation.compiled = false;
                relocation.section = section;
                return relocation;
            }
 
            static inline Relocation ToSymbol(uint32_t symbol_number)
            {
                Relocation relocation;
                relocation.type = Symbol;
                relocation.number = symbol_number;
                return relocation;
            }
 
            static inline Relocation ToSymbol(std::weak_ptr<ImportedSymbol> symbol)
            {
                Relocation relocation;
                relocation.type = Symbol;
                relocation.compiled = false;
                relocation.symbol = symbol;
                return relocation;
            }
        };
 
        class RelocOpcode;
 
        class RelocationProcessor
        {
        public:
            const PEFFormat& pef_format;
 
            size_t reloc_instr_ptr = 0;
            uint32_t reloc_address = 0;
            uint32_t import_index = 0;
            uint32_t section_c = 0;
            uint32_t section_d = 0;
            uint32_t current_repeat_count = 0;
 
            std::vector<RelocOpcode>& reloc_opcodes;
            std::map<uint32_t, Relocation>& relocations;
 
            void Initialize();
 
            RelocationProcessor(const PEFFormat& pef_format, std::vector<RelocOpcode>& reloc_opcodes, std::map<uint32_t, Relocation>& relocations)
                : pef_format(pef_format), reloc_opcodes(reloc_opcodes), relocations(relocations)
            {
                Initialize();
            }
 
            void Advance(uint32_t offset)
            {
                reloc_address += offset;
            }
 
            void AddRelocation(Relocation relocation)
            {
                relocations[reloc_address] = relocation;
                Advance(4);
            }
 
            void AddSection(uint32_t section_number)
            {
                AddRelocation(Relocation::ToSection(section_number));
            }
 
            void AddSectionC()
            {
                AddSection(section_c);
            }
 
            void AddSectionD()
            {
                AddSection(section_d);
            }
 
            void AddSymbol()
            {
                AddRelocation(Relocation::ToSymbol(import_index));
                import_index ++;
            }
 
            void Regress(uint32_t block_count);
 
            void Repeat(uint32_t block_count, uint32_t repeat_count)
            {
                // unless this is the last iteration of this block
                if(current_repeat_count != 1)
                {
                    // jump over this (already processed) instruction and the block
                    reloc_instr_ptr --;
                    Regress(block_count);
                }
 
                if(current_repeat_count == 0)
                {
                    // iteration starts
                    current_repeat_count = repeat_count;
                }
                else
                {
                    current_repeat_count --;
                }
            }
 
            void GenerateRelocations();
        };
 
        class RelocOpcode
        {
        public:
            /* the values are chosen so that they can be bitwise or'd to the opcode word */
            enum opcode_type
            {
                SmInvalid = -1,
                //LgInvalid = -2,
                BySectDWithSkip = 0x0000,
                BySectC = 0x4000,
                BySectD = 0x4200,
                TVector12 = 0x4400,
                TVector8 = 0x4600,
                VTable8 = 0x4800,
                ImportRun = 0x4A00,
                SmByImport = 0x6000,
                SmSetSectC = 0x6200,
                SmSetSectD = 0x6400,
                SmBySection = 0x6600,
                IncrPosition = 0x8000,
                SmRepeat = 0x9000,
                SetPosition = 0xA000,
                LgByImport = 0xA400,
                LgRepeat = 0xB000,
                LgBySection = 0xB400,
                LgSetSectC = 0xB440,
                LgSetSectD = 0xB480,
            };
            uint32_t offset = 0; // within file
            opcode_type opcode = SmInvalid;
 
            uint32_t value = 0;
 
            /*union
            {
                uint32_t run_length; // BySectDWithSkip, BySect*, TVector*, VTable8, ImportRun
                uint32_t repeat_count; // *Repeat
            };*/
            uint32_t repeat = 0;
 
            RelocOpcode(opcode_type opcode = SmInvalid)
                : opcode(opcode)
            {
            }
 
            RelocOpcode(opcode_type opcode, uint32_t value, uint32_t repeat)
                : opcode(opcode), value(value), repeat(repeat)
            {
            }
 
            void ReadFile(const std::shared_ptr<Linker::Reader>& rd);
            uint32_t GetWord() const;
            offset_t CodeSize() const;
            void WriteFile(const std::shared_ptr<Linker::Writer>& wr)
            {
                wr->WriteWord(CodeSize(), GetWord());
            }
            void GenerateRelocations(RelocationProcessor& processor) const;
 
            void Dump(Dumper::Dumper& dump, const PEFFormat& pef_format, uint32_t opcode_index, int display_options = 0) const;
        };
 
        class Section
        {
        public:
            enum section_type
            {
                Code = 0,
                UnpackedData = 1,
                PatternInitializedData = 2,
                Constant = 3,
                Loader = 4,
                Debug = 5,
                ExecutableData = 6,
                Exception = 7,
                Traceback = 8,
            };
            enum share_type
            {
                ProcessShare = 1,
                GlobalShare = 4,
                ProtectedShare = 5,
            };
            static constexpr uint32_t NoNameOffset = uint32_t(-1);
            uint32_t name_offset = NoNameOffset;
            std::string name = "";
            uint32_t default_address = 0;
            uint32_t total_size = 0;
            uint32_t unpacked_size = 0;
            uint32_t packed_size = 0;
            uint32_t container_offset = 0;
            section_type section_kind = Code;
            share_type share_kind = ProcessShare;
            uint8_t alignment = 0;
            uint8_t reserved = 0;
            // convenience field to determine index of symbol in table
            uint32_t section_number = uint32_t(-1);
 
            std::shared_ptr<Linker::Contents> image;
            std::vector<PatternInitialization> patterns;
            // only appearing in sections with relocations
            std::map<uint32_t, Relocation> relocations;
            std::vector<RelocOpcode> reloc_opcodes;
            bool contains_relocations = false;
            uint16_t reserved_a = 0;
            uint32_t reloc_instr_size = 0;
            uint32_t first_reloc_offset = 0;
 
            Section() = default;
            Section(section_type section_kind, share_type share_kind, std::shared_ptr<Linker::Contents> image)
                : section_kind(section_kind), share_kind(share_kind), image(image)
            {
                alignment = ExpectedAlignment();
            }
 
            bool IsInstantiated() const
            {
                switch(section_kind)
                {
                case Code:
                case UnpackedData:
                case PatternInitializedData:
                case Constant:
                case ExecutableData:
                    return true;
                default:
                    return false;
                }
            }
 
            offset_t ExpectedAlignment() const
            {
                switch(section_kind)
                {
                case Code:
                case UnpackedData:
                case Constant:
                case ExecutableData:
                    return 4;
                case PatternInitializedData:
                case Loader:
                    return 1;
                default:
                    return 0;
                }
            }
 
            enum compression_level
            {
                Compression_None,
                Compression_Trivial,
            };
            static compression_level DefaultCompressionLevel;
 
            void CompressData();
            void CompressData(compression_level level);
 
            void ReadHeader(const std::shared_ptr<Linker::Reader>& rd);
            void ReadFile(PEFFormat& pef_format, const std::shared_ptr<Linker::Reader>& rd);
            size_t GetImageSize(PEFFormat& pef_format);
            void CalculateValues(PEFFormat& pef_format);
            void WriteHeader(const std::shared_ptr<Linker::Writer>& wr) const;
            void WriteFile(const PEFFormat& pef_format, const std::shared_ptr<Linker::Writer>& wr) const;
        };
 
        // container header information
 
        std::vector<std::shared_ptr<Section>> sections;
        std::vector<std::string> section_name_table;
        uint32_t section_name_table_end = 0;
        offset_t image_size = 0;
 
        static constexpr uint32_t ContainerHeaderSize = 40;
        static constexpr uint32_t SectionHeaderSize = 28;
 
        uint32_t GetSectionNameTableOffset() const
        {
            return ContainerHeaderSize + SectionHeaderSize * sections.size();
        }
 
        // loader section information
        uint32_t loader_section_offset = 0; // duplicate value of sections[*]->container_offset for sections[*]->section_kind == Section::Loader
 
        static constexpr uint32_t NoSection = uint32_t(-1);
        static constexpr uint32_t Absolute = uint32_t(-2);
        static constexpr uint32_t Reexported = uint32_t(-3);
 
        struct Reference
        {
            std::weak_ptr<Section> section_pointer;
            uint32_t section = NoSection;
            uint32_t offset = 0;
 
            void SetPosition(PEFFormat& pef_format, const Linker::Position& position);
 
            bool IsPresent() const { return section != NoSection; }
            void StoreSectionIndex()
            {
                auto actual_section = section_pointer.lock();
                section = actual_section ? actual_section->section_number : NoSection;
            }
        };
        Reference main_symbol, init_symbol, term_symbol;
 
        class Name
        {
        public:
            uint32_t name_offset = 0;
            std::string name = "";
            std::string LoadNameString(const PEFFormat& pef_format, const std::shared_ptr<Linker::Reader>& rd);
            std::string LoadNameString(const PEFFormat& pef_format, const std::shared_ptr<Linker::Reader>& rd, uint16_t length);
            void StoreNameString(PEFFormat& pef_format);
            void StoreNameStringNoNull(PEFFormat& pef_format);
 
            Name() = default;
 
            Name(std::string name)
                : name(name)
            {
            }
        };
 
        class ImportedLibrary;
 
        enum symbol_class_type
        {
            Code = 0,
            Data = 1,
            TVect = 2,
            TOC = 3,
            Glue = 4,
        };
        static inline constexpr bool IsValidSymbolClass(int value)
        {
            switch(value)
            {
            case Code:
            case Data:
            case TVect:
            case TOC:
            case Glue:
                return true;
            default:
                return false;
            }
        }
 
        class ImportedSymbol : public Name
        {
        public:
            symbol_class_type symbol_class = TVect;
            uint8_t flags = 0;
            // convenience field to determine index of symbol in table
            uint32_t symbol_number = uint32_t(-1);
 
            ImportedSymbol() = default;
            ImportedSymbol(std::string name) : Name(name) { }
            ImportedSymbol(std::string name, uint8_t flags) : Name(name), symbol_class(symbol_class_type(flags & 0x0F)), flags(flags & 0xF0) { }
 
            std::weak_ptr<ImportedLibrary> library; // back link to library that includes it
        };
 
        class ImportedLibrary : public Name
        {
        public:
            uint32_t old_imp_version = 0;
            uint32_t current_version = 0;
            uint32_t imported_symbol_count = 0;
            uint32_t first_imported_symbol = 0;
            std::vector<std::shared_ptr<ImportedSymbol>> imported_symbols;
            // only used for generation
            std::map<std::tuple<std::string, uint8_t>, std::shared_ptr<ImportedSymbol>> named_imported_symbols;
            uint8_t options = 0;
            uint8_t reserved_a = 0;
            uint16_t reserved_b = 0;
 
            ImportedLibrary() = default;
            ImportedLibrary(std::string name) : Name(name) { }
 
            std::shared_ptr<ImportedSymbol> GetImportByName(std::string name, uint8_t symbol_class = TVect)
            {
                auto key = std::make_tuple(name, symbol_class);
                auto symbol_iter = named_imported_symbols.find(key);
                if(symbol_iter == named_imported_symbols.end())
                {
                    auto symbol = std::make_shared<ImportedSymbol>(name, symbol_class);
                    imported_symbols.push_back(symbol);
                    named_imported_symbols[key] = symbol;
                    return symbol;
                }
                else
                {
                    return symbol_iter->second;
                }
            }
        };
        std::vector<std::shared_ptr<ImportedLibrary>> imported_libraries;
        // only for CFM-68K
        std::shared_ptr<MacintoshResourceFileFormat::JumpTableCodeResource> jump_table;
        std::shared_ptr<Section> jump_table_section;
        // only used for generation
        std::map<std::string, std::shared_ptr<ImportedLibrary>> named_imported_libraries;
        std::vector<std::shared_ptr<ImportedSymbol>> imported_symbols;
        std::vector<uint32_t> reloc_section_indexes;
        uint32_t reloc_instr_offset = 0;
        uint32_t loader_strings_offset = 0;
        uint32_t export_hash_offset = 0;
        std::vector<RelocOpcode> relocs_area;
        uint32_t relocs_area_size = 0;
        std::vector<std::string> loader_string_table;
        uint32_t loader_string_table_size = 0;
 
        struct ExportedSymbol;
 
        struct HashTableEntry
        {
            uint16_t chain_count = 0;
            uint32_t first_index = 0;
 
            // used only for generation
            std::vector<std::shared_ptr<ExportedSymbol>> chain;
        };
        std::vector<HashTableEntry> hash_table;
 
        struct ExportedSymbol : public Name, public Reference
        {
            uint16_t symbol_length = 0;
            uint16_t hash_value = 0;
            symbol_class_type symbol_class = Data;
 
            ExportedSymbol() = default;
 
            ExportedSymbol(std::string name)
                : Name(name)
            {
            }
 
            ExportedSymbol(std::string name, symbol_class_type symbol_class)
                : Name(name), symbol_class(symbol_class)
            {
            }
 
            using Name::LoadNameString;
            std::string LoadNameString(const PEFFormat& pef_format, const std::shared_ptr<Linker::Reader>& rd);
        };
        std::vector<std::shared_ptr<ExportedSymbol>> exported_symbols;
 
        static uint32_t ComputeHashWord(std::string name);
        static uint32_t HashTableIndex(uint32_t hash_word, uint32_t export_hash_table_power);
        static uint8_t ComputeHashTableExponent(uint32_t hash_table_size);
 
        std::shared_ptr<ImportedLibrary> FetchImportLibrary(std::string name)
        {
            auto library_iter = named_imported_libraries.find(name);
            if(library_iter == named_imported_libraries.end())
            {
                auto library = std::make_shared<ImportedLibrary>(name);
                imported_libraries.push_back(library);
                named_imported_libraries[name] = library;
                return library;
            }
            else
            {
                return library_iter->second;
            }
        }
 
        static constexpr uint32_t LoaderHeaderSize = 56;
        static constexpr uint32_t LibraryDescriptionSize = 28;
        uint32_t GetLibraryDescriptionsSize() const
        {
            return LibraryDescriptionSize * imported_libraries.size();
        }
        uint32_t GetSymbolTablesSize() const
        {
            uint32_t size = 0;
            for(auto library : imported_libraries)
            {
                size += 4 * library->imported_symbols.size();
            }
            return size;
        }
        uint32_t GetRelocationHeadersSize() const
        {
            return 12 * reloc_section_indexes.size();
        }
        uint32_t GetRelocationAreaSize() const
        {
            return relocs_area_size;
        }
        uint32_t GetLoaderStringAreaSize() const
        {
            return loader_string_table_size;
        }
        uint32_t GetExportHashTableSize() const
        {
            return 4 * hash_table.size();
        }
        uint32_t GetExportKeyTableSize() const
        {
            return 4 * exported_symbols.size();
        }
        uint32_t GetExportSymbolTableSize() const
        {
            return 10 * exported_symbols.size();
        }
 
        uint32_t GetMinimumRelocInstrOffset() const
        {
            return LoaderHeaderSize
                    + GetLibraryDescriptionsSize()
                    + GetSymbolTablesSize()
                    + GetRelocationHeadersSize();
        }
 
        uint32_t GetLoaderSectionSize() const
        {
            return
                std::max({LoaderHeaderSize
                    + GetLibraryDescriptionsSize()
                    + GetSymbolTablesSize()
                    + GetRelocationHeadersSize(),
                    reloc_instr_offset + GetRelocationAreaSize(),
                    loader_strings_offset + GetLoaderStringAreaSize(),
                    export_hash_offset
                        + GetExportHashTableSize()
                        + GetExportKeyTableSize()
                        + GetExportSymbolTableSize()});
        }
 
        // temporary structure to map linker segments to PEF sections
        std::map<std::shared_ptr<Linker::Segment>, std::shared_ptr<Section>> segment_to_section_map;
 
        uint32_t GetSectionNumber(std::shared_ptr<Section> section, uint32_t fallback)
        {
            size_t result = std::find(sections.begin(), sections.end(), section) - sections.begin();
            if(result == sections.size())
                return fallback;
            else
                return result;
        }
 
        bool FormatSupportsLibraries() const override;
        bool FormatSupportsResources() const override;
        bool FormatSupportsEntryTable() const override; // TODO: not yet implemented
        bool FormatSupportsTransitionVectors() const override; // TODO: not yet implemented
 
        void ReadLoaderSection(const std::shared_ptr<Linker::Reader>& rd);
        void WriteLoaderSection(const std::shared_ptr<Linker::Writer>& wr) const;
 
    private:
        bool effect_handled = false;
    public:
        void ReparseResource(MacintoshResourceFileFormat& format, const std::shared_ptr<Linker::Reader>& rd, offset_t offset, offset_t length);
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        void CalculateValues() override;
        offset_t ImageSize() const override;
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        class PEFOptionCollector : public Linker::OptionCollector
        {
        public:
            Linker::Option<bool> carbon{"carbon", "Generate Carbon binary"};
 
            PEFOptionCollector()
            {
                InitializeFields(carbon);
            }
        };
 
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
        std::unique_ptr<Script::List> GetScript(Linker::Module& module);
        void Link(Linker::Module& module);
        void SortImports();
        void ProcessRelocations(Linker::Module& module);
        void ProcessModule(Linker::Module& module) override;
        void GenerateFile(std::string filename, Linker::Module& module) override;
 
        std::shared_ptr<MacintoshResourceFileFormat> resource_fork;
    };
 
    std::optional<
        std::variant<
            std::shared_ptr<MacintoshResourceFileFormat::CodeResource>,
            std::shared_ptr<PEFFormat::Section>>>
        FindSegment(std::shared_ptr<Linker::Segment> segment, MacintoshResourceFileFormat * resource_fork, PEFFormat * pef_container = nullptr);
 
    bool CheckSimpleRelocation(const Linker::Relocation& rel);
    void ProcessRelocations(Linker::Module& module, MacintoshResourceFileFormat * resource_fork, PEFFormat * pef_container = nullptr);
 
    class PEFHeader
    {
    private:
        bool effect_handled = false;
    public:
        std::shared_ptr<PEFHeaderBase> header;
 
        PEFHeader(PEFHeaderBase::binary_type type = PEFHeaderBase::UnknownBinary, PEFHeaderBase::cpu_type architecture = PEFHeaderBase::PPC)
            : header(std::make_shared<PEFHeaderBase>(type, architecture))
        {
        }
 
        PEFHeader(std::shared_ptr<PEFHeaderBase> header)
            : header(header)
        {
        }
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd);
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const;
        void AddFields(Dumper::Region& header_region) const;
 
        void ReparseResource(MacintoshResourceFileFormat& format, const std::shared_ptr<Linker::Reader>& rd, offset_t offset, offset_t length);
    };
 
    class RSegResource : public MacintoshResourceFileFormat::Resource
    {
    public:
        std::variant<std::shared_ptr<PEFFormat>, std::shared_ptr<PEFHeader>> structured_data;
        std::shared_ptr<MacintoshResourceFileFormat::Resource> raw_data;
 
        RSegResource(std::shared_ptr<PEFHeader> structured_data, std::shared_ptr<MacintoshResourceFileFormat::Resource> raw_data = nullptr)
            : Resource(
                raw_data ? raw_data->type       : "rseg",
                raw_data ? raw_data->id         : 0,
                raw_data ? raw_data->name       : std::optional<std::string>{},
                raw_data ? raw_data->attributes : 0),
            structured_data(structured_data), raw_data(raw_data)
        {
        }
 
        RSegResource(std::shared_ptr<PEFFormat> structured_data, std::shared_ptr<MacintoshResourceFileFormat::Resource> raw_data = nullptr)
            : Resource(
                raw_data ? raw_data->type       : "rseg",
                raw_data ? raw_data->id         : 1,
                raw_data ? raw_data->name       : std::optional<std::string>{},
                raw_data ? raw_data->attributes : 0),
            structured_data(structured_data), raw_data(raw_data)
        {
        }
 
        void CalculateValues() override;
 
        offset_t ImageSize() const override;
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd, offset_t length) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        int GetDisplayOptions() const override;
        using Linker::Format::Dump;
        void Dump(Dumper::Dumper& dump, offset_t file_offset) const override;
        void AddFields(Dumper::Dumper& dump, Dumper::Region& region, offset_t file_offset) const override;
        std::unique_ptr<Dumper::Region> CreateRegion(std::string name, offset_t offset, offset_t length, unsigned display_width) const override;
 
        void ReparseResource(MacintoshResourceFileFormat& format, const std::shared_ptr<Linker::Reader>& rd, offset_t offset, offset_t length);
        void EffectFormat(MacintoshResourceFileFormat& format, const std::shared_ptr<Linker::Reader>& rd) override;
    };
 
    class PEFOutputDriver : public MacintoshOutputDriver
    {
    public:
        // TODO: very preliminary
 
        PEFOutputDriver(target_format_t target = TARGET_DATA_FORK)
            : MacintoshOutputDriver(target)
        {
        }
 
        PEFOutputDriver(target_format_t target, int produce)
            : MacintoshOutputDriver(target, produce)
        {
        }
 
        bool FormatSupportsLibraries() const override;
        bool FormatSupportsResources() const override;
        bool FormatSupportsEntryTable() const override; // TODO: not yet implemented
        bool FormatSupportsTransitionVectors() const override; // TODO: not yet implemented
 
        class CodeFragment
        {
        public:
            std::shared_ptr<MacintoshResourceFileFormat::CodeFragmentResource::Member> member;
            std::shared_ptr<PEFFormat> pef_format;
            std::shared_ptr<PEFHeader> pef_header;
 
            CodeFragment(MacintoshResourceFileFormat::CodeFragmentResource::Member::architecture_type architecture)
                : member(std::make_shared<MacintoshResourceFileFormat::CodeFragmentResource::Member>(architecture))
            {
            }
 
            CodeFragment(std::shared_ptr<MacintoshResourceFileFormat::CodeFragmentResource::Member> member, std::shared_ptr<PEFFormat> pef_format = nullptr, std::shared_ptr<PEFHeader> pef_header = nullptr)
                : member(member), pef_format(pef_format), pef_header(pef_header)
            {
            }
 
            static CodeFragment CreateEmptyPEF();
        protected:
            static CodeFragment CreateWithHeader(std::shared_ptr<MacintoshResourceFileFormat::CodeFragmentResource::Member> member, std::shared_ptr<PEFFormat> pef_format);
        public:
            static CodeFragment CreateApplication(MacintoshResourceFileFormat::CodeFragmentResource::Member::architecture_type architecture, std::string name);
            static CodeFragment CreateLibrary(MacintoshResourceFileFormat::CodeFragmentResource::Member::architecture_type architecture, std::string name, uint32_t current_version, uint32_t old_def_version);
        };
 
        class DataFork : public Linker::OutputFormat
        {
        public:
            std::vector<CodeFragment> fragments;
 
            offset_t ImageSize() const override;
            void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
            offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
            void Dump(Dumper::Dumper& dump) const override;
        };
 
    private:
        std::shared_ptr<DataFork> data_fork;
        std::shared_ptr<FinderInfo> finder_info;
 
        std::map<std::string, std::string> options;
        std::string model;
        std::string script_file;
        std::map<std::string, std::string> script_options;
 
    public:
        // TODO: duplicated from Classic68K::DriverOptionCollector
        // TODO: extend OutputDriver::DriverOptionCollector
        class DriverOptionCollector : public PEFFormat::PEFOptionCollector
        {
        public:
            class MacBinaryVersionEnumerator : public Linker::Enumeration<MacBinary::version_t>
            {
            public:
                MacBinaryVersionEnumerator()
                    : Enumeration(
                        "1", MacBinary::MACBIN1,
                        "GETINFO", MacBinary::MACBIN1_GETINFO,
                        "2", MacBinary::MACBIN2,
                        "3", MacBinary::MACBIN3)
                {
                    descriptions = {
                        { MacBinary::MACBIN1, "Revision 1 (1985)" },
                        { MacBinary::MACBIN1_GETINFO, "Revision 1 (1985) with Get Info extension" },
                        { MacBinary::MACBIN2, "MacBinary II, Revision 2 (1987)" },
                        { MacBinary::MACBIN3, "MacBinary III, Revision 3 (1987)" },
                    };
                }
            };
 
            Linker::Option<std::optional<offset_t>> asver{"asver", "Version of the AppleSingle/AppleDouble container (recognized values: 1, 2)"};
            Linker::Option<std::optional<offset_t>> adver{"adver", "Version of the AppleSingle/AppleDouble container (recognized values: 1, 2)"};
            Linker::Option<std::optional<Linker::ItemOf<MacBinaryVersionEnumerator>>> mbinver{"mbinver", "Version of the MacBinary container"};
            Linker::Option<std::optional<Linker::ItemOf<MacBinaryVersionEnumerator>>> minmbinver{"minmbinver", "Minimum required version for the MacBinary container"};
 
            DriverOptionCollector()
                : PEFOptionCollector()
                // TODO: if OutputDriver::DriverOptionCollector is created, call its too constructor
            {
                InitializeFields(asver, adver, mbinver, minmbinver);
            }
        };
 
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        std::vector<Linker::OptionDescription<void>> GetMemoryModelNames() override;
        void SetModel(std::string model) override;
 
        void SetLinkScript(std::string script_file, std::map<std::string, std::string>& options) override;
 
        void GenerateFile(std::string filename, Linker::Module& module) override;
 
        void CalculateValues() override;
 
    protected:
        void OnContainerCreated() override;
        void OnReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        offset_t OnWriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void OnDump(Dumper::Dumper& dump) const override;
 
    public:
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
 
        std::string GetDefaultExtension(Linker::Module& module) const override;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;
    };
}
 
#endif /* PEFEXE_H */