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"
#include "symbol_definition.h"
#include "symbol_name.h"
 
namespace Linker
{
    class InputFormat;
    class OutputFormat;
    class Section;
 
    class Module
    {
    public:
        std::string file_name;
 
        Module(std::string file_name = "")
            : file_name(file_name)
        {
        }
 
        enum cpu_type
        {
            NONE,
            I80,
            I86,
            I386,
            X86_64,
            M6800,
            M6809,
            M68K,
            MOS6502,
            W65K,
            Z8K,
            PPC,
            PPC64,
            ARM,
            ARM64,
            PDP11,
            MIPS,
            SPARC,
            SH,
            ALPHA,
            IA64,
        };
 
        cpu_type cpu = NONE;
        ::EndianType endiantype = ::UndefinedEndian;
        std::vector<SymbolDefinition> symbol_sequence;
    private:
        std::vector<std::shared_ptr<Section>> sections;
        std::map<std::string, std::shared_ptr<Section>> section_names;
        std::map<std::string, SymbolDefinition> global_symbols; // includes Weak and Common symbols
        std::map<std::string, SymbolDefinition> local_symbols;
        std::vector<SymbolName> imported_symbols;
        std::map<ExportedSymbolName, Location> exported_symbols;
 
        friend class ModuleCollector;
 
    private:
        bool AddSymbol(const SymbolDefinition& symbol);
        void AppendSymbolDefinition(const SymbolDefinition& symbol);
        void DeleteSymbolDefinition(const SymbolDefinition& symbol);
        SymbolDefinition * FetchSymbolDefinition(const SymbolDefinition& symbol);
    public:
        bool HasSymbolDefinition(const SymbolDefinition& symbol);
 
    private:
        std::vector<Relocation> relocations;
 
        std::map<Location, size_t> relocation_indexes;
 
    public:
        std::vector<Relocation>& GetRelocations();
 
        bool is_included = false;
 
        void SetupOptions(char special_char, std::shared_ptr<OutputFormat> output_format, std::shared_ptr<const InputFormat> input_format);
 
    private:
        /* GNU assembler can use '$', NASM must use '?' */
        char special_prefix_char = '$';
        std::weak_ptr<OutputFormat> output_format;
        std::weak_ptr<const InputFormat> input_format;
 
        /* symbols */
        std::string section_prefix();
        std::string segment_prefix();
        std::string segment_of_prefix();
        std::string segment_at_prefix();
        std::string segment_at_section_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, SymbolName& symbol);
        bool parse_exported_name(std::string reference_name, ExportedSymbolName& symbol);
 
    public:
        bool AddLocalSymbol(std::string name, Location location);
    private:
        bool AddLocalSymbol(const SymbolDefinition& symbol);
 
    public:
        bool AddGlobalSymbol(std::string name, Location location);
    private:
        bool AddGlobalSymbol(const SymbolDefinition& symbol);
 
    public:
        bool AddWeakSymbol(std::string name, Location location);
    private:
        bool AddWeakSymbol(const SymbolDefinition& symbol);
 
    public:
        bool AddCommonSymbol(SymbolDefinition symbol);
 
        bool AddLocalCommonSymbol(SymbolDefinition symbol);
 
        void AddImportedSymbol(SymbolName name);
 
        void AddExportedSymbol(ExportedSymbolName name, Location symbol);
 
        bool AddUndefinedSymbol(std::string symbol_name);
    private:
        bool AddUndefinedSymbol(const SymbolDefinition& symbol);
 
    public:
        void AddRelocation(Relocation relocation);
 
        const std::vector<SymbolName>& GetImportedSymbols() const;
 
        const std::map<ExportedSymbolName, 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 ResolveLocalRelocations();
 
        void Append(std::shared_ptr<Section> dst, std::shared_ptr<Section> src);
 
        void Append(Module& other);
 
        void AllocateSymbols(std::string default_section_name = ".bss", bool force_create_segment = false);
 
        void AllocateStack(offset_t stack_size, std::string default_section_name = ".stack");
    };
}
 
#endif /* MODULE_H */