aout.h

#ifndef AOUT_H
#define AOUT_H
 
#include "mzexe.h"
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/module.h"
#include "../linker/options.h"
#include "../linker/segment.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
 
namespace AOut
{
    class AOutFormat : public virtual Linker::InputFormat, public virtual Linker::SegmentManager
    {
    public:
        /* * * General members * * */
        ::EndianType endiantype = ::UndefinedEndian;
 
        enum system_type
        {
            UNSPECIFIED,
            UNIX_V1_V2,
            UNIX,
            SYSTEM_V,
            BSD,
            LINUX, /* TODO: not fully supported */
            FREEBSD, /* TODO */
            NETBSD, /* TODO */
            DJGPP1,
            PDOS386,
            EMX,
        };
 
        static constexpr system_type DEFAULT = system_type(-1);
 
        system_type system;
 
        enum magic_type
        {
            OMAGIC = 0x0107,
            MAGIC_IMPURE = OMAGIC,
 
            NMAGIC = 0x0108,
            MAGIC_ROTEXT = NMAGIC,
            MAGIC_PURE = NMAGIC,
 
            ZMAGIC = 0x010B,
            MAGIC_DEMAND_PAGED = ZMAGIC,
 
            QMAGIC = 0x00CC,
            MAGIC_UNMAPPED_ZERO = QMAGIC,
 
            // PDP-11 specific
 
            MAGIC_V1 = 0x0105 | 0xFFFF0000,
 
            MAGIC_OVERLAY = 0x0105,
 
            IMAGIC = 0x0109,
            MAGIC_SEPARATE = IMAGIC,
 
            MAGIC_AUTO_OVERLAY_NONSEPARATE = 0x0118,
 
            MAGIC_AUTO_OVERLAY_SEPARATE = 0x0119,
        };
        magic_type magic;
 
        static constexpr magic_type GetDefaultMagic(system_type system)
        {
            switch(system)
            {
            case UNIX_V1_V2:
                return MAGIC_V1;
            case UNIX:
            case SYSTEM_V:
            case UNSPECIFIED: // TODO: which should we pick?
                return OMAGIC;
            case BSD:
            case LINUX: // TODO: check default
            case FREEBSD: // TODO: check default
            case NETBSD: // TODO: check default
                return ZMAGIC;
            case DJGPP1:
            case EMX:
                return ZMAGIC;
            case PDOS386:
                return OMAGIC;
            }
            return OMAGIC; // TODO: make sure it is the same as UNSPECIFIED
        }
 
        ::EndianType midmag_endiantype;
 
    protected:
        AOutFormat(system_type system, magic_type magic)
            : system(system), magic(magic)
        {
        }
 
    public:
        AOutFormat()
            : system(UNSPECIFIED), magic(magic_type(0))
        {
        }
 
        uint16_t mid_value = 0;
 
        uint8_t flags = 0;
 
        static constexpr uint16_t MID_UNKNOWN = 0x000;
        static constexpr uint16_t MID_68010 = 0x001;
        static constexpr uint16_t MID_68020 = 0x002;
        static constexpr uint16_t MID_PC386 = 0x064; // mentioned for Linux and NetBSD
        static constexpr uint16_t MID_I386 = 0x086; // mentioned for FreeBSD and NetBSD
        static constexpr uint16_t MID_ARM6 = 0x08F; // mentioned for FreeBSD and NetBSD
        static constexpr uint16_t MID_MIPS1 = 0x097; // mentioned for Linux and NetBSD
        static constexpr uint16_t MID_MIPS2 = 0x098; // mentioned for Linux and NetBSD
        static constexpr uint16_t MID_HP200 = 0x0C8; // mentioned for FreeBSD and NetBSD
        static constexpr uint16_t MID_HP300 = 0x12C; // mentioned for FreeBSD and NetBSD
        static constexpr uint16_t MID_HPUX800 = 0x20B; // mentioned for FreeBSD and NetBSD
        static constexpr uint16_t MID_HPUX = 0x20C; // mentioned for FreeBSD and NetBSD
 
        // according to a.out.h
        static constexpr uint16_t MID_LINUX_OLDSUN2 = 0x000;
        static constexpr uint16_t MID_LINUX_SPARC = 0x003;
 
        // according to imgact_aout.h
        static constexpr uint16_t MID_FREEBSD_SPARC = 0x08C;
 
        // according to aout_mids.h
        static constexpr uint16_t MID_NETBSD_M68K = 0x087;
        static constexpr uint16_t MID_NETBSD_M68K4K = 0x088;
        static constexpr uint16_t MID_NETBSD_NS32532K = 0x089;
        static constexpr uint16_t MID_NETBSD_SPARC = 0x08A;
        static constexpr uint16_t MID_NETBSD_PMAX = 0x08B;
        static constexpr uint16_t MID_NETBSD_VAX1K = 0x08C;
        static constexpr uint16_t MID_NETBSD_ALPHA = 0x08D;
        static constexpr uint16_t MID_NETBSD_MIPS = 0x08E;
        static constexpr uint16_t MID_NETBSD_M680002K = 0x090;
        static constexpr uint16_t MID_NETBSD_SH3 = 0x091;
        static constexpr uint16_t MID_NETBSD_POWERPC64 = 0x094;
        static constexpr uint16_t MID_NETBSD_POWERPC = 0x095;
        static constexpr uint16_t MID_NETBSD_VAX = 0x096;
        static constexpr uint16_t MID_NETBSD_M88K = 0x099;
        static constexpr uint16_t MID_NETBSD_HPPA = 0x09A;
        static constexpr uint16_t MID_NETBSD_SH5_64 = 0x09B;
        static constexpr uint16_t MID_NETBSD_SPARC64 = 0x09C;
        static constexpr uint16_t MID_NETBSD_X86_64 = 0x09D;
        static constexpr uint16_t MID_NETBSD_SH5_32 = 0x09E;
        static constexpr uint16_t MID_NETBSD_IA64 = 0x09F;
        static constexpr uint16_t MID_NETBSD_AARCH64 = 0x0B7;
        static constexpr uint16_t MID_NETBSD_OR1K = 0x0B8;
        static constexpr uint16_t MID_NETBSD_RISCV = 0x0B9;
 
        static constexpr uint16_t MID_BFD_ARM = 0x067;
 
        enum word_size_t
        {
            WordSize16 = 2,
            WordSize32 = 4,
            WordSize64 = 8,
        };
 
        word_size_t word_size = word_size_t(0);
 
        constexpr uint32_t GetHeaderSize() const
        {
            switch(magic)
            {
            case MAGIC_V1:
                return word_size * 6;
            case MAGIC_AUTO_OVERLAY_NONSEPARATE:
            case MAGIC_AUTO_OVERLAY_SEPARATE:
                return word_size * (8 + 16);
            default:
                return std::min(4, int(word_size)) + 7 * word_size;
            }
        }
 
        constexpr offset_t GetRelocationSize() const
        {
            switch(word_size)
            {
            case WordSize16:
                // TODO: MAGIC_V1 has different format
                return 2;
            default:
                return word_size + 4;
            }
        }
 
        enum cpu_type
        {
            UNKNOWN,
            M68K,
            SPARC,
            SPARC64,
            I386,
            AMD64,
            ARM,
            AARCH64,
            MIPS,
            PARISC,
            PDP11,
            NS32K,
            VAX,
            ALPHA,
            SUPERH,
            SUPERH64,
            PPC,
            PPC64,
            M88K,
            IA64,
            OR1K,
            RISCV,
            SYS360,
            SYS390_64,
        };
        cpu_type cpu = UNKNOWN;
 
        ::EndianType GetEndianType() const;
 
        word_size_t GetWordSize() const;
 
        uint32_t code_size = 0;
        uint32_t data_size = 0;
        uint32_t bss_size = 0;
        uint32_t symbol_table_size = 0;
        uint32_t entry_address = 0;
        // only for 16-bit format
        uint16_t reserved = 0;
        uint16_t relocations_suppressed = 0;
        // only for 32-bit format
        uint32_t code_relocation_size = 0;
        uint32_t data_relocation_size = 0;
        // AT&T specifi
        uint16_t environment_stamp = 0;
 
        class Relocation
        {
        public:
            uint32_t address = 0;
            uint32_t symbol = 0;
            bool relative = false;
            size_t size = 0;
            enum segment_type
            {
                Undefined,
                External,
                Absolute,
                Text,
                Data,
                Bss,
                FileName,
                Illegal,
            };
            segment_type segment = Undefined;
            uint32_t literal_entry = 0;
 
            static Relocation ReadFile16Bit(Linker::Reader& rd, uint16_t offset);
            void WriteFile16Bit(Linker::Writer& wr) const;
 
            static Relocation ReadFile32Bit(Linker::Reader& rd, word_size_t word_size = WordSize32);
            void WriteFile32Bit(Linker::Writer& wr, word_size_t word_size = WordSize32) const;
        };
 
        std::vector<Relocation> code_relocations, data_relocations;
 
        std::shared_ptr<Linker::Contents> code, data, bss;
 
    private:
        bool AttemptFetchMagic(uint8_t signature[4]);
 
        bool CheckFileSizes(Linker::Reader& rd, offset_t image_size);
 
        bool AttemptReadFileWithCurrentSettings(Linker::Reader& rd, uint8_t signature[4], offset_t image_size);
 
        struct read_attempt_type
        {
            word_size_t word_size;
            ::EndianType midmag_endiantype;
        };
 
        bool AttemptReadFile(Linker::Reader& rd, uint8_t signature[4], offset_t image_size, read_attempt_type first_attempt)
        {
            return false;
        }
 
        template <typename ... read_attempt_types>
            bool AttemptReadFile(Linker::Reader& rd, uint8_t signature[4], offset_t image_size, read_attempt_type first_attempt, read_attempt_types ... remaining_attempts)
        {
            midmag_endiantype = endiantype = first_attempt.midmag_endiantype;
            word_size = first_attempt.word_size;
 
            if(!AttemptReadFileWithCurrentSettings(rd, signature, image_size))
            {
                return AttemptReadFile(rd, signature, image_size, remaining_attempts...);
            }
            else
            {
                return true;
            }
        }
 
    public:
        enum symbol_format_type
        {
            SYMBOL_FORMAT_ATT,
            SYMBOL_FORMAT_BSD,
        };
        symbol_format_type symbol_format = SYMBOL_FORMAT_BSD;
 
        class Symbol
        {
        public:
            std::string name;
            offset_t name_offset = 0;
            uint32_t type_etc = 0;
            offset_t value = 0;
 
            enum segment_type
            {
                Undefined = 0,
                Absolute = 1,
                Text = 2,
                Data = 3,
                Bss = 4,
                Common = 9,
                Register = 20,
                FileName = 31,
            };
 
            uint16_t GetTypeByte(const AOutFormat& aout) const;
            segment_type GetType(const AOutFormat& aout) const;
            bool IsExternal(const AOutFormat& aout) const;
        };
 
        std::vector<Symbol> symbols;
 
        mutable uint32_t page_size = 0; // GetPageSize will set this if it is 0, and so it needs to be declared mutable
 
        uint32_t GetPageSize() const;
        uint32_t GetTextOffset() const;
        uint32_t GetTextAddress() const;
        uint32_t GetDataOffsetAlign() const;
        uint32_t GetDataAddressAlign() const;
 
        void ReadHeader(Linker::Reader& rd);
 
        void ReadFile(Linker::Reader& rd) override;
 
        offset_t ImageSize() const override;
 
        void WriteHeader(Linker::Writer& wr) const;
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
 
        void Dump(Dumper::Dumper& dump) const override;
 
        /* * * Reader members * * */
 
        static std::shared_ptr<AOutFormat> CreateReader(word_size_t word_size, ::EndianType endiantype, system_type system = UNSPECIFIED);
 
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
 
        /* * * Writer members * * */
 
        std::optional<offset_t> force_magic_number;
 
        static std::shared_ptr<AOutFormat> CreateWriter(system_type system, magic_type magic);
        static std::shared_ptr<AOutFormat> CreateWriter(system_type system);
 
        enum unix_version
        {
            DefaultVersion,
            Version1,
            Version2,
            Version3,
            Version4,
            Version5,
            Version6,
            Version7,
            SystemIII,
            SystemV,
            AnyBSD,
        };
        unix_version target_unix_version = DefaultVersion;
 
        static constexpr bool SupportedMagicType(unix_version version, magic_type magic)
        {
            switch(version)
            {
            default:
                return false;
            case Version1:
                return magic == MAGIC_V1;
            case Version2:
                return magic == OMAGIC;
            case Version3:
            case Version4:
            case Version5:
                return magic == OMAGIC || magic == NMAGIC;
            case Version6:
                return magic == OMAGIC || magic == NMAGIC || magic == MAGIC_SEPARATE;
            case Version7:
            case SystemIII:
            case SystemV:
                return magic == OMAGIC || magic == NMAGIC || magic == MAGIC_SEPARATE || magic == MAGIC_OVERLAY;
            case AnyBSD:
                return magic == OMAGIC || magic == NMAGIC
                    /* 16-bit only */
                    || magic == MAGIC_SEPARATE || magic == MAGIC_OVERLAY || magic == MAGIC_AUTO_OVERLAY_NONSEPARATE || magic == MAGIC_AUTO_OVERLAY_SEPARATE
                    /* 32-bit only */
                    || magic == ZMAGIC;
            case DefaultVersion:
                return true;
            }
        }
 
        class AOutOptionCollector : public Linker::OptionCollector
        {
        public:
            class UnixVersionEnumeration : public Linker::Enumeration<unix_version>
            {
            public:
                UnixVersionEnumeration()
                    : Enumeration(
                        "V1", Version1,
                        "V2", Version2,
                        "V3", Version3,
                        "V4", Version4,
                        "V5", Version5,
                        "V6", Version6,
                        "V7", Version7,
                        "SYSIII", SystemIII,
                        "SYS3", SystemIII,
                        "SIII", SystemIII,
                        "S3", SystemIII,
                        "SYSV", SystemV,
                        "SYS5", SystemV,
                        "SV", SystemV,
                        "S5", SystemV,
                        "BSD", AnyBSD,
                        "2.11BSD", AnyBSD,
                        "211BSD", AnyBSD,
                        "2.9BSD", AnyBSD,
                        "29BSD", AnyBSD,
                        "2BSD", AnyBSD,
                        "4.3BSD", AnyBSD,
                        "43BSD", AnyBSD,
                        "4BSD", AnyBSD)
                {
                    descriptions = {
                        { Version1, "UNIX Version 1" },
                        { Version2, "UNIX Version 2" },
                        { Version3, "UNIX Version 3" },
                        { Version4, "UNIX Version 4" },
                        { Version5, "UNIX Version 5" },
                        { Version6, "UNIX Version 6" },
                        { Version7, "UNIX Version 7" },
                        { SystemIII, "UNIX System III" },
                        { SystemV, "UNIX System V" },
                        { AnyBSD, "2.11BSD (16-bit) or 4.3BSD (32-bit)" },
                    };
                }
            };
 
            class MagicEnumeration : public Linker::Enumeration<magic_type>
            {
            public:
                MagicEnumeration()
                    : Enumeration(
                        "OMAGIC", OMAGIC,
                        "IMPURE", OMAGIC,
                        "NMAGIC", NMAGIC,
                        "ROTEXT", NMAGIC,
                        "PURE", NMAGIC,
                        "ZMAGIC", ZMAGIC,
                        "DEMANDPAGED", ZMAGIC,
                        "QMAGIC", QMAGIC,
                        "UNMAPPED", QMAGIC,
                        "OVERLAY", MAGIC_OVERLAY,
                        "SEPARATE", MAGIC_SEPARATE,
                        "AUTOOVL", MAGIC_AUTO_OVERLAY_NONSEPARATE,
                        "AUTOOVLNS", MAGIC_AUTO_OVERLAY_NONSEPARATE,
                        "AUTOOVLS", MAGIC_AUTO_OVERLAY_SEPARATE,
                        "AUTOOVLSEP", MAGIC_AUTO_OVERLAY_SEPARATE)
                {
                    descriptions = {
                        { OMAGIC, "Impure executable (OMAGIC)" },
                        { NMAGIC, "Pure executable (NMAGIC)" },
                        { ZMAGIC, "Demand paged (ZMAGIC)" },
                        { QMAGIC, "Demand paged with unmapped page zero (QMAGIC)" },
                        { MAGIC_SEPARATE, "Separate instruction and data spaces (PDP-11 only)" },
                        { MAGIC_OVERLAY, "Overlay (PDP-11 BSD only)" },
                        { MAGIC_AUTO_OVERLAY_NONSEPARATE, "Auto-overlay, non-separate (PDP-11 BSD only)" },
                        { MAGIC_AUTO_OVERLAY_SEPARATE, "Auto-overlay, separate (PDP-11 BSD only)" },
                    };
                }
            };
 
            Linker::Option<std::string> stub{"stub", "Filename for stub that gets prepended to executable (DJGPP only)"};
            Linker::Option<Linker::ItemOf<UnixVersionEnumeration>> unix_v{"version", "Targeted UNIX version (UNIX only)"};
            Linker::Option<Linker::ItemOf<MagicEnumeration>> type{"type", "Executable type"};
            Linker::Option<std::optional<offset_t>> magic{"magic", "Explicit magic type specification"};
            Linker::Option<bool> Nflag{"N", "OMAGIC"};
            Linker::Option<bool> nflag{"n", "NMAGIC"};
            Linker::Option<bool> iflag{"i", "Generate separated executable"};
            Linker::Option<bool> zflag{"z", "Demand paged executable (identical to -i for PDP-11)"};
            Linker::Option<bool> Oflag{"O", "Generate text overlay"};
 
            AOutOptionCollector()
            {
                InitializeFields(stub, unix_v, type, magic, Nflag, nflag, iflag, zflag, Oflag);
            }
        };
 
        // for old DJGPP executables
        mutable Microsoft::MZSimpleStubWriter stub;
 
        static std::vector<Linker::OptionDescription<void> *> ParameterNames;
        std::vector<Linker::OptionDescription<void> *> GetLinkerScriptParameterNames() override;
 
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
 
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
 
        void CreateDefaultSegments();
 
        std::unique_ptr<Script::List> GetScript(Linker::Module& module);
 
        void Link(Linker::Module& module);
 
        std::shared_ptr<Linker::Segment> GetCodeSegment();
 
        std::shared_ptr<Linker::Segment> GetDataSegment();
 
        std::shared_ptr<Linker::Segment> GetBssSegment();
 
        void ProcessModule(Linker::Module& module) override;
 
        void CalculateValues() override;
 
        void GenerateFile(std::string filename, Linker::Module& module) override;
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;
        std::string GetDefaultExtension(Linker::Module& module) const override;
    };
 
}
 
#endif /* AOUT_H */