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"
 
/* TODO: UNIX v1 a.out
    magic
    header_size + text_size + data_size
    symtab_size
    relocations_size
    bss_size
    0
 
TODO: PDP-11 a.out
*/
 
namespace AOut
{
    class AOutFormat : public virtual Linker::InputFormat, public virtual Linker::SegmentManager
    {
    public:
        /* * * General members * * */
        ::EndianType endiantype;
        unsigned word_size;
 
        enum magic_type
        {
            OMAGIC = 0x0107,
            NMAGIC = 0x0108,
            ZMAGIC = 0x010B,
            QMAGIC = 0x00CC,
        };
        magic_type magic = magic_type(0);
 
        enum cpu_type
        {
            UNKNOWN = 0x00,
            M68010  = 0x01,
            M68020  = 0x02,
            SPARC   = 0x03,
            I80386  = 0x64,
            ARM     = 0x67, /* according to BFD */
            MIPS1   = 0x97,
            MIPS2   = 0x98,
            PDP11   = 0xFF, /* not a real magic number */
        };
        cpu_type cpu = UNKNOWN;
 
        ::EndianType GetEndianType() const;
 
        unsigned 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;
        uint32_t code_relocation_size = 0;
        uint32_t data_relocation_size = 0;
        std::map<uint32_t, uint32_t> code_relocations, data_relocations; /* only used by PDOS386 OMAGIC */
 
        std::shared_ptr<Linker::Image> code, data, bss;
 
    private:
        bool AttemptFetchMagic(uint8_t signature[4]);
 
        bool AttemptReadFile(Linker::Reader& rd, uint8_t signature[4], offset_t image_size);
 
    public:
        class Symbol
        {
        public:
            std::string name;
            uint16_t unknown = 0;
            uint16_t name_offset = 0;
            uint16_t type = 0;
            uint16_t value = 0;
        };
 
        std::vector<Symbol> symbols;
 
        void ReadFile(Linker::Reader& rd) override;
 
        offset_t ImageSize() const override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
 
        void Dump(Dumper::Dumper& dump) const override;
 
        /* * * Reader members * * */
 
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
 
        /* * * Writer members * * */
 
        class AOutOptionCollector : public Linker::OptionCollector
        {
        public:
            Linker::Option<std::string> stub{"stub", "Filename for stub that gets prepended to executable"};
 
            AOutOptionCollector()
            {
                InitializeFields(stub);
            }
        };
 
        // for old DJGPP executables
        mutable Microsoft::MZSimpleStubWriter stub;
 
        enum system_type
        {
            UNIX, /* also Linux */ /* TODO */
            DJGPP1, /* early DJGPP */
            PDOS386, /* http://pdos.sourceforge.net/ */
        };
        system_type system = system_type(0);
 
        static std::shared_ptr<AOutFormat> CreateWriter(system_type system, magic_type magic);
 
        static std::shared_ptr<AOutFormat> CreateWriter(system_type system);
 
        static magic_type GetDefaultMagic(system_type system);
 
        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 */