module.h

#ifndef MODULE_H
#define MODULE_H
 
#include <map>
#include <memory>
#include <vector>
#include <string>
#include "../common.h"
#include "location.h"
#include "relocation.h"
 
namespace Linker
{
    class Section;
 
    class Module
    {
    public:
        enum cpu_type
        {
            NONE,
            I80, /* also Z80 */
            I86,
            I386,
            X86_64,
            M6800,
            M6809,
            M68K,
            MOS6502,
            W65K,
            Z8K,
            PPC,
            PPC64,
            ARM,
            ARM64,
            PDP11,
            MIPS,
            SPARC,
            SH,
        };
 
        cpu_type cpu = NONE;
    private:
        std::vector<std::shared_ptr<Section>> sections;
        std::map<std::string, std::shared_ptr<Section>> section_names;
        std::map<std::string, Location> symbols;
        std::map<std::string, Location> local_symbols;
        std::map<std::string, CommonSymbol> unallocated_symbols;
        std::vector<SymbolName> imported_symbols;
        std::map<ExportedSymbol, Location> exported_symbols;
    public:
        std::vector<Relocation> relocations;
 
        void SetupOptions(char special_char, std::shared_ptr<OutputFormat> output_format, std::shared_ptr<InputFormat> input_format);
 
    private:
        /* GNU assembler can use '$', NASM must use '?' */
        char special_prefix_char = '$';
        std::weak_ptr<Linker::OutputFormat> output_format;
        std::weak_ptr<Linker::InputFormat> input_format;
 
        /* symbols */
        std::string segment_prefix();
        std::string segment_of_prefix();
        std::string segment_at_prefix();
        std::string with_respect_to_segment_prefix();
        std::string segment_difference_prefix();
        std::string import_prefix();
        std::string segment_of_import_prefix();
        std::string export_prefix();
        std::string fix_byte_prefix();
 
        /* sections */
        std::string resource_prefix();
 
        bool parse_imported_name(std::string reference_name, Linker::SymbolName& symbol);
        bool parse_exported_name(std::string reference_name, Linker::ExportedSymbol& symbol);
 
    public:
        void AddLocalSymbol(std::string name, Location location);
    private:
        void _AddLocalSymbol(std::string name, Location location);
 
    public:
        void AddGlobalSymbol(std::string name, Location location);
    private:
        void _AddGlobalSymbol(std::string name, Location location);
 
    public:
        void AddCommonSymbol(std::string name, CommonSymbol symbol);
 
        void AddImportedSymbol(SymbolName name);
 
        void AddExportedSymbol(ExportedSymbol name, Location symbol);
 
        void AddUndefinedSymbol(std::string symbol_name);
 
        void AddRelocation(Relocation relocation);
 
        const std::vector<SymbolName>& GetImportedSymbols() const;
 
        const std::map<ExportedSymbol, Location>& GetExportedSymbols() const;
 
        bool FindLocalSymbol(std::string name, Location& location);
 
        bool FindGlobalSymbol(std::string name, Location& location);
 
        void AddSection(std::shared_ptr<Section> section);
 
    private:
        void _AddSection(std::shared_ptr<Section> section);
 
    public:
        const std::vector<std::shared_ptr<Section>>& Sections() const;
 
        void DeleteSection(size_t index);
 
        void RemoveSections();
 
        std::shared_ptr<Section> FindSection(std::string name);
 
        std::shared_ptr<Section> FetchSection(std::string name, unsigned default_flags);
 
        void ResolveRelocations();
 
        void Append(std::shared_ptr<Section> dst, std::shared_ptr<Section> src);
 
        void Append(Module& other);
 
        void AllocateSymbols(std::shared_ptr<Section> section);
 
        void AllocateSymbols();
    };
}
 
#endif /* MODULE_H */