Class Context

include/recompiler/context.h:211–590

    };

    class Context {
    private:
        //// Reference symbols (used for populating relocations for patches)
        // A list of the sections that contain the reference symbols.
        std::vector<ReferenceSection> reference_sections;
        // A list of the reference symbols.
        std::vector<ReferenceSymbol> reference_symbols;
        // Mapping of symbol name to reference symbol index.
        std::unordered_map<std::string, SymbolReference> reference_symbols_by_name;
        // Whether all reference sections should be treated as relocatable (used in live recompilation).
        bool all_reference_sections_relocatable = false;
    public:
        std::vector<Section> sections;
        std::vector<Function> functions;
        // A list of the list of each function (by index in `functions`) in a given section
        std::vector<std::vector<size_t>> section_functions;
        // A mapping of vram address to every function with that address.
        std::unordered_map<uint32_t, std::vector<size_t>> functions_by_vram;
        // A mapping of bss section index to the corresponding non-bss section index.
        std::unordered_map<uint16_t, uint16_t> bss_section_to_section;
        // The target ROM being recompiled, TODO move this outside of the context to avoid making a copy for mod contexts.
        // Used for reading relocations and for the output binary feature.
        std::vector<uint8_t> rom;
        // Whether reference symbols should be validated when emitting function calls during recompilation.
        bool skip_validating_reference_symbols = true;
        // Whether all function calls (excluding reference symbols) should go through lookup.
        bool use_lookup_for_all_function_calls = false;

        //// Only used by the CLI, TODO move this to a struct in the internal headers.
        // A mapping of function name to index in the functions vector
        std::unordered_map<std::string, size_t> functions_by_name;

        //// Mod dependencies and their symbols
        
        //// Imported values
        // Dependency names.
        std::vector<std::string> dependencies;
        // Mapping of dependency name to dependency index.
        std::unordered_map<std::string, size_t> dependencies_by_name;
        // List of symbols imported from dependencies.
        std::vector<ImportSymbol> import_symbols;
        // List of events imported from dependencies.
        std::vector<DependencyEvent> dependency_events;
        // Mappings of dependency event name to the index in dependency_events, all indexed by dependency.
        std::vector<std::unordered_map<std::string, size_t>> dependency_events_by_name;
        // Mappings of dependency import name to index in import_symbols, all indexed by dependency.
        std::vector<std::unordered_map<std::string, size_t>> dependency_imports_by_name;

        //// Exported values
        // List of function replacements, which contains the original function to replace and the function index to replace it with.
        std::vector<FunctionReplacement> replacements;
        // Indices of every exported function.
        std::vector<size_t> exported_funcs;
        // List of callbacks, which contains the function for the callback and the dependency event it attaches to.
        std::vector<Callback> callbacks;
        // List of symbols from events, which contains the names of events that this context provides.
        std::vector<EventSymbol> event_symbols;
        // List of hooks, which contains the original function to hook and the function index to call at the hook.