Class LiveGeneratorOutput

include/recompiler/live_recompiler.h:16–68

        uint32_t section_offset;
    };
    struct LiveGeneratorOutput {
        LiveGeneratorOutput() = default;
        LiveGeneratorOutput(const LiveGeneratorOutput& rhs) = delete;
        LiveGeneratorOutput(LiveGeneratorOutput&& rhs) { *this = std::move(rhs); }
        LiveGeneratorOutput& operator=(const LiveGeneratorOutput& rhs) = delete;
        LiveGeneratorOutput& operator=(LiveGeneratorOutput&& rhs) {
            good = rhs.good;
            string_literals = std::move(rhs.string_literals);
            jump_tables = std::move(rhs.jump_tables);
            code = rhs.code;
            code_size = rhs.code_size;
            functions = std::move(rhs.functions);
            reference_symbol_jumps = std::move(rhs.reference_symbol_jumps);
            import_jumps_by_index = std::move(rhs.import_jumps_by_index);
            executable_offset = rhs.executable_offset;

            rhs.good = false;
            rhs.code = nullptr;
            rhs.code_size = 0;
            rhs.reference_symbol_jumps.clear();
            rhs.executable_offset = 0;

            return *this;
        }
        ~LiveGeneratorOutput();
        size_t num_reference_symbol_jumps() const;
        void set_reference_symbol_jump(size_t jump_index, recomp_func_t* func);
        ReferenceJumpDetails get_reference_symbol_jump_details(size_t jump_index);
        void populate_import_symbol_jumps(size_t import_index, recomp_func_t* func);
        bool good = false;
        // Storage for string literals referenced by recompiled code. These are allocated as unique_ptr arrays
        // to prevent them from moving, as the referenced address is baked into the recompiled code.
        std::vector<std::unique_ptr<char[]>> string_literals;
        // Storage for jump tables referenced by recompiled code (vector of arrays of pointers). These are also
        // allocated as unique_ptr arrays for the same reason as strings.
        std::vector<std::unique_ptr<void*[]>> jump_tables;
        // Recompiled code.
        void* code;
        // Size of the recompiled code.
        size_t code_size;
        // Pointers to each individual function within the recompiled code.
        std::vector<recomp_func_t*> functions;
    private:
        // List of jump details and the corresponding jump instruction address. These jumps get populated after recompilation is complete
        // during dependency resolution.
        std::vector<std::pair<ReferenceJumpDetails, void*>> reference_symbol_jumps;
        // Mapping of import symbol index to any jumps to that import symbol.
        std::unordered_multimap<size_t, void*> import_jumps_by_index;
        // sljit executable offset.
        int64_t executable_offset;

        friend class LiveGenerator;
    };
    struct LiveGeneratorInputs {
        uint32_t base_event_index;
        void (*cop0_status_write)(recomp_context* ctx, gpr value);