Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

// main.cpp #include "Emulator.h" #include "fileutils.h" #include "elfloader.h" #include…

  1. User

    // main.cpp #include "Emulator.h" #include "file_utils.h" #include "elf_loader.h" #include #include #include #include

    bool run_program_from_file(const std::string& filename) { Emulator emulator(1024 * 1024); // 1 MB памяти

    // Загрузка программы из бинарного файла
    std::vector<uint8_t> program = load_program_from_file(filename);
    if (program.empty()) {
        std::cerr << "Ошибка: Не удалось загрузить программу из файла: " << filename << "\n";
        return false;
    }
    
    // Загрузка программы в память по адресу 0x0000 и установка EIP
    emulator.load_program(program, 0x7C00, true);
    // Set CS:IP to 0x0000:0x7C00
    emulator.regs.CS = 0x0000;
    emulator.regs.EIP = 0x7C00; // Starting execution at 0x7C00
    // Запуск эмулятора
    emulator.run();
    
    // Проверка на ошибки
    return !emulator.has_error();
    

    }

    bool run_program_from_elf(const std::string& filename) { Emulator emulator(1024 * 1024 * 1024); // 1 GB памяти

    // Загрузка ELF-файла
    bool load_result = load_elf(filename, emulator);
    if (!load_result) {
        std::cerr << "Ошибка: Не удалось загрузить ELF-файл.\n";
        return false;
    }
    //emulator.print_registers(true);
    // Запуск эмулятора
    emulator.run();
    
    // Проверка на ошибки
    return !emulator.has_error();
    

    }

    int main(int argc, char* argv[]) { // Проверка наличия аргумента командной строки if (argc > 1) { std::string program_filename = argv[1]; std::cout << "\nЗапуск программы из файла: " << program_filename << "...\n";

        // Определение типа файла по расширению
        if (program_filename.size() >= 4 &&
            program_filename.substr(program_filename.size() - 4) == ".elf") {
            // Запуск как ELF-файл
            bool elf_result = run_program_from_elf(program_filename);
    
            if (elf_result) {
                std::cout << "\nПрограмма из ELF-файла успешно выполнена!\n";
            }
            else {
                std::cout << "\nПрограмма из ELF-файла не выполнена.\n";
            }
        }
        else {
            // Запуск как flat binary
            bool file_result = run_program_from_file(program_filename);
    
            if (file_result) {
                std::cout << "\nПрограмма из файла успешно выполнена!\n";
            }
            else {
                std::cout << "\nПрограмма из файла не выполнена.\n";
            }
        }
    }
    else {
        // Если файл не указан, можно запустить тесты или вывести инструкции
        std::cout << "Использование: " << argv[0] << " <имя_файла.(elf|bin)>\n";
    }
    
    return 0;
    

    } // Instructions.cpp #include "Emulator.h" #include #include <stdint.h> #include // Реализация обработчиков инструкций

    // MOV EAX, imm32 void Emulator::instr_MOV_EAX_imm32() { uint32_t imm = fetch_dword(); regs.EAX = imm; }

    void Emulator::instr_PUSH_EAX() { push(regs.EAX); }

    void Emulator::instr_PUSH_ECX() { push(regs.ECX); }

    void Emulator::instr_PUSH_EDX() { push(regs.EDX); }

    void Emulator::instr_PUSH_EBX() { push(regs.EBX); }

    void Emulator::instr_PUSH_ESP() { push(regs.ESP); }

    void Emulator::instr_PUSH_EBP() { push(regs.EBP); }

    void Emulator::instr_PUSH_ESI() { push(regs.ESI); }

    void Emulator::instr_PUSH_EDI() { push(regs.EDI); } void Emulator::instr_CLD() { // Clear the Direction Flag (DF), which is bit 10 in EFLAGS regs.EFLAGS &= ~DF;

    // Optionally, print debug information
    std::cout << "Выполнена инструкция CLD (Direction Flag сброшен).\n";
    

    } void Emulator::instr_PUSH_imm8() { int8_t imm8 = static_cast<int8_t>(fetch_byte()); // Получаем 8-битное значение push(static_cast<uint32_t>(imm8)); // Преобразуем в 32-битное знаковое значение и помещаем в стек } void Emulator::push(uint32_t value) { if (regs.ESP < 4) { std::cerr << "Stack overflow при попытке записать в стек.\n"; error_flag = true; running = false; return; } regs.ESP -= 4; // Уменьшаем указатель стека write_memory_dword(regs.ESP, value); // Записываем значение в стек } void Emulator::instr_NOP_EAX() { // Эта инструкция ничего не делает, можно просто вывести сообщение std::cout << "Выполнен NOP [EAX]\n"; } void Emulator::instr_STI() { // Устанавливаем флаг прерываний (IF) regs.EFLAGS |= IF_FLAG; std::cout << "Выполнен STI: Установлен флаг прерываний (IF).\n"; } void Emulator::instr_POP_ESP() { if (regs.ESP + 4 > memory.size()) { std::cerr << "Stack underflow on POP ESP.\n"; error_flag = true; running = false; return; } regs.ESP = read_memory_dword(regs.ESP); regs.ESP += 4; } void Emulator::instr_POP_EBX() { if (regs.ESP + 4 > memory.size()) { std::cerr << "Stack underflow on POP EBX.\n"; error_flag = true; running = false; return; } regs.EBX = read_memory_dword(regs.ESP); regs.ESP += 4; } void Emulator::instr_POP_EDX() { if (regs.ESP + 4 > memory.size()) { std::cerr << "Stack underflow on POP EDX.\n"; error_flag = true; running = false; return; } regs.EDX = read_memory_dword(regs.ESP); regs.ESP += 4; } void Emulator::instr_POP_ECX() { if (regs.ESP + 4 > memory.size()) { std::cerr << "Stack underflow on POP ECX.\n"; error_flag = true; running = false; return; } regs.ECX = read_memory_dword(regs.ESP); regs.ESP += 4; } void Emulator::instr_POP_EAX() { if (regs.ESP + 4 > memory.size()) { std::cerr << "Stack underflow on POP EAX.\n"; error_flag = true; running = false; return; } regs.EAX = read_memory_dword(regs.ESP); regs.ESP += 4; } void Emulator::instr_POP_ESI() { if (regs.ESP + 4 > memory.size()) { std::cerr << "Stack underflow on POP ESI.\n"; error_flag = true; running = false; return; }

    // Считываем значение со стека и сохраняем его в регистр ESI
    regs.ESI = read_memory_dword(regs.ESP);
    regs.ESP += 4;  // Увеличиваем указатель стека
    
    std::cout << "Выполнен POP ESI. Значение в регистре ESI: " << std::hex << regs.ESI << "\n";
    

    } void Emulator::instr_POP_EDI() { if (regs.ESP + 4 > memory.size()) { std::cerr << "Stack underflow on POP EDI.\n"; error_flag = true; running = false; return; } regs.EDI = read_memory_dword(regs.ESP); regs.ESP += 4; } void Emulator::instr_MOV_Ev_Iv() { uint8_t modrm = fetch_byte(); Operand operand = decode_operand(modrm);

    uint32_t immediate = fetch_dword();
    
    if (operand.is_memory) {
        write_memory_dword(operand.address, immediate);
    } else {
        uint32_t* reg = get_register_by_code(operand.register_code);
        if (!reg) {
            std::cout << "Unknown register in MOV Ev, Iv.\n";
            error_flag = true;
            running = false;
            return;
        }
        *reg = immediate;
    }
    

    } // Реализация инструкции INC r/m32 void Emulator::instr_INC_rm32(uint8_t modrm) { Operand operand = decode_operand(modrm); if (operand.is_memory) { uint32_t value = read_memory_dword(operand.address); value++; write_memory_dword(operand.address, value); } else { uint32_t* reg = get_register_by_code(operand.register_code); (*reg)++; } update_ZF(operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code)); }

    // Реализация инструкции DEC r/m32 void Emulator::instr_DEC_rm32(uint8_t modrm) { Operand operand = decode_operand(modrm); if (operand.is_memory) { uint32_t value = read_memory_dword(operand.address); value--; write_memory_dword(operand.address, value); } else { uint32_t* reg = get_register_by_code(operand.register_code); (*reg)--; } update_ZF(operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code)); } void Emulator::instr_LEAVE() { // Set ESP to EBP regs.ESP = regs.EBP;

    // POP EBP
    if (regs.ESP + 4 > memory.size()) {
        std::cerr << "Stack underflow on LEAVE.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    regs.EBP = read_memory_dword(regs.ESP);
    regs.ESP += 4;
    
    std::cout << "Выполнена инструкция LEAVE. ESP: 0x" << std::hex << regs.ESP
        << ", EBP: 0x" << regs.EBP << "\n";
    

    } // Реализация инструкции CALL r/m32 void Emulator::instr_CALL_rm32(uint8_t modrm) { Operand operand = decode_operand(modrm); uint32_t address = operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code);

    // Сохраняем текущий адрес возврата в стек
    push(regs.EIP);
    
    // Переходим к новому адресу
    regs.EIP = address;
    

    }

    // Реализация инструкции JMP r/m32 void Emulator::instr_JMP_rm32(uint8_t modrm) { Operand operand = decode_operand(modrm); uint32_t address = operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code); regs.EIP = address; }

    // Реализация инструкции PUSH r/m32 void Emulator::instr_PUSH_rm32(uint8_t modrm) { Operand operand = decode_operand(modrm); uint32_t value = operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code); push(value); } void Emulator::instr_PUSH_imm32() { uint32_t imm32 = fetch_dword(); // Чтение 32-битного непосредственного значения push(imm32); // Помещение значения в стек } void Emulator::instr_GROUP5() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm >> 6) & 0x03; uint8_t reg = (modrm >> 3) & 0x07; // Поле reg в ModR/M указывает на операцию uint8_t rm = modrm & 0x07;

    switch (reg) {
    case 0: // INC r/m32
        instr_INC_rm32(modrm);
        break;
    case 1: // DEC r/m32
        instr_DEC_rm32(modrm);
        break;
    case 2: // CALL r/m32
        instr_CALL_rm32(modrm);
        break;
    case 3: // CALL far
        std::cout << "CALL far не поддерживается.\n";
        error_flag = true;
        running = false;
        break;
    case 4: // JMP r/m32
        instr_JMP_rm32(modrm);
        break;
    case 5: // JMP far
        std::cout << "JMP far не поддерживается.\n";
        error_flag = true;
        running = false;
        break;
    case 6: // PUSH r/m32
        instr_PUSH_rm32(modrm);
        break;
    case 7: // NOT r/m32
        instr_NOT_rm32(modrm);
        break;
    default:
        std::cout << "Неизвестный подтип команды 0xFF: " << (int)reg << "\n";
        error_flag = true;
        running = false;
        break;
    }
    

    } void Emulator::instr_TEST_rm32_r32() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm >> 6) & 0x03; uint8_t reg = (modrm >> 3) & 0x07; // Второй операнд (r32) uint8_t rm = modrm & 0x07; // Первый операнд (r/m32)

    uint32_t operand1 = 0;
    uint32_t operand2 = 0;
    
    // Получаем второй операнд из регистра
    uint32_t* reg_operand2 = get_register_by_code(reg);
    if (!reg_operand2) {
        std::cout << "Unknown register in TEST r/m32, r32.\n";
        error_flag = true;
        running = false;
        return;
    }
    operand2 = *reg_operand2;
    
    if (mod == 3) {
        // Режим регистр-регистр
        uint32_t* reg_operand1 = get_register_by_code(rm);
        if (!reg_operand1) {
            std::cout << "Unknown register in TEST r/m32, r32.\n";
            error_flag = true;
            running = false;
            return;
        }
        operand1 = *reg_operand1;
    }
    else {
        // Операнд из памяти
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        operand1 = read_memory_dword(address);
    }
    
    // Выполняем побитовое И без сохранения результата
    uint32_t result = operand1 & operand2;
    
    // Обновляем флаги
    // Флаги CF и OF сбрасываются
    regs.EFLAGS &= ~(CF | OF);
    
    // Zero Flag (ZF)
    if (result == 0)
        regs.EFLAGS |= ZF;
    else
        regs.EFLAGS &= ~ZF;
    
    // Sign Flag (SF)
    if (result & 0x80000000)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;
    
    // Parity Flag (PF)
    update_PF(static_cast<uint8_t>(result & 0xFF));
    
    // Флаг Auxiliary Carry (AF) не определен для инструкции TEST и может быть оставлен без изменений
    
    std::cout << "Выполнена инструкция TEST r/m32, r32.\n";
    

    } void Emulator::instr_ENDBR32() { // ENDBR32 is 4 bytes: F3 0F 1E FB // We have already processed F3 (prefix) and 0F (escape opcode) // 1E has been fetched and identified as opcode for ENDBR32 // Now, we need to fetch the last byte, which should be 0xFB uint8_t last_byte = fetch_byte(); if (last_byte != 0xFB) { std::cout << "Expected byte 0xFB not found after opcode 0x1E for ENDBR32, found: 0x" << std::hex << (int)last_byte << ".\n"; error_flag = true; running = false; return; } // ENDBR32 correctly recognized; treat as NOP std::cout << "ENDBR32 instruction executed (treated as NOP).\n"; } void Emulator::instr_STD() { // Set the Direction Flag (DF), which is bit 10 in EFLAGS regs.EFLAGS |= DF; std::cout << "Выполнена инструкция STD (Direction Flag установлен).\n"; } void Emulator::instr_NOP() { // NOP does nothing std::cout << "Выполнена инструкция NOP.\n"; } void Emulator::instr_PUSHAD() { uint32_t temp_esp = regs.ESP; push(regs.EAX); push(regs.ECX); push(regs.EDX); push(regs.EBX); push(temp_esp); // Original value of ESP push(regs.EBP); push(regs.ESI); push(regs.EDI); std::cout << "Выполнена инструкция PUSHAD.\n"; } void Emulator::instr_REP_MOVSB() { while (regs.ECX != 0) { uint8_t byte = read_memory_byte(regs.ESI); write_memory_byte(regs.EDI, byte);

        // Update ESI and EDI based on the Direction Flag
        if (regs.EFLAGS & DF) {
            regs.ESI -= 1;
            regs.EDI -= 1;
        }
        else {
            regs.ESI += 1;
            regs.EDI += 1;
        }
    
        regs.ECX -= 1;
    }
    std::cout << "Выполнена инструкция REP MOVSB.\n";
    

    } void Emulator::instr_NOT_rm32(uint8_t modrm) { Operand operand = decode_operand(modrm);

    if (operand.is_memory) {
        uint32_t value = read_memory_dword(operand.address);
        value = ~value;
        write_memory_dword(operand.address, value);
    }
    else {
        uint32_t* reg = get_register_by_code(operand.register_code);
        if (!reg) {
            std::cout << "Unknown register in NOT r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
        *reg = ~(*reg);
    }
    // Инструкция NOT не изменяет флаги
    std::cout << "Выполнена инструкция NOT r/m32.\n";
    

    } void Emulator::instr_NOP_m16_m32() { // Инструкция NOP m16/32 имеет модификатор размера операнда // Если установлен префикс 0x66, то размер операнда 16 бит, иначе 32 бита bool operand_size = regs.operand_size_override;

    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    
    if (mod == 3) {
        // Mod == 3 означает, что операнд — регистр
        // В этом случае NOP не делает ничего
        uint8_t rm = modrm & 0x07;
        // Можно просто считать регистр для эмуляции чтения
        uint32_t* reg = get_register_by_code(rm);
        if (reg) {
            uint32_t temp = *reg;
            // NOP ничего не делает, поэтому не изменяем значение
        }
        else {
            std::cout << "Неизвестный регистр в NOP r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else {
        // Если Mod != 3, то вычисляем адрес и читаем операнд из памяти
        uint32_t address = calculate_address(modrm);
    
        if (operand_size) {
            // Чтение 16-битного операнда для NOP m16
            uint16_t temp = read_memory_byte(address) | (read_memory_byte(address + 1) << 8);
            // NOP не изменяет ничего, просто читаем для эмуляции
        }
        else {
            // Чтение 32-битного операнда для NOP m32
            uint32_t temp = read_memory_dword(address);
            // NOP не изменяет ничего, просто читаем для эмуляции
        }
    }
    
    // NOP ничего не делает, поэтому ничего не изменяем
    

    } // MOV EBX, imm32 void Emulator::instr_MOV_EBX_imm32() { uint32_t imm = fetch_dword(); regs.EBX = imm; }

    // MOV ECX, imm32 void Emulator::instr_MOV_ECX_imm32() { uint32_t imm = fetch_dword(); regs.ECX = imm; }

    // MOV EDX, imm32 void Emulator::instr_MOV_EDX_imm32() { uint32_t imm = fetch_dword(); regs.EDX = imm; }

    // ADD EAX, imm32 void Emulator::instr_ADD_EAX_imm32() { if (regs.rep_prefix || regs.repne_prefix) { std::cout << "Warning: REP prefix is ignored for ADD EAX, imm32.\n"; reset_prefixes(); } uint32_t imm = fetch_dword(); std::cout << "Executing ADD EAX, " << imm << " (Before EAX: " << regs.EAX << ")\n"; regs.EAX += imm; std::cout << "After EAX: " << regs.EAX << "\n"; update_ZF(regs.EAX); }

    // SUB EAX, imm32 void Emulator::instr_SUB_EAX_imm32() { uint32_t imm = fetch_dword(); regs.EAX -= imm; update_ZF(regs.EAX); }

    // INC EAX void Emulator::instr_INC_EAX() { regs.EAX += 1; update_ZF(regs.EAX); }

    // DEC EAX void Emulator::instr_DEC_EAX() { regs.EAX -= 1; update_ZF(regs.EAX); }

    // MUL EAX void Emulator::instr_MUL_EAX() { uint8_t modrm = fetch_byte(); // Для простоты реализуем только MUL EAX if ((modrm & 0x38) == 0x20) { // Проверяем, что это MUL r/m32 regs.EAX *= regs.EAX; update_ZF(regs.EAX); } else { std::cout << "MUL instruction with unsupported operand.\n"; // Можно установить флаг ошибки или завершить выполнение } }

    // JMP rel32 void Emulator::instr_JMP_rel32() { int32_t rel = fetch_dword(); regs.EIP += rel; }

    // CMP регистр, imm8 void Emulator::instr_CMP_reg_imm8() { uint8_t modrm = fetch_byte(); uint8_t reg = (modrm >> 3) & 0x07; uint8_t imm8 = fetch_byte(); uint32_t* reg_ptr = get_register_by_code(regm_rm(modrm)); if (reg_ptr) { uint32_t result = *reg_ptr - imm8;

        // Zero Flag
        if (result == 0)
            regs.EFLAGS |= ZF;
        else
            regs.EFLAGS &= ~ZF;
    
        // Carry Flag
        if (*reg_ptr < imm8)
            regs.EFLAGS |= CF;
        else
            regs.EFLAGS &= ~CF;
    
        // Sign Flag (SF)
        if (result & (1 << 31))
            regs.EFLAGS |= (1 << 7); // Предполагаем, что SF находится в бит 7
        else
            regs.EFLAGS &= ~(1 << 7);
    
        // Overflow Flag (OF) - необходимо корректно реализовать
        // Здесь может быть упрощение, для точной реализации требуется дополнительная логика
    }
    else {
        std::cout << "CMP instruction with unsupported register.\n";
        // Можно установить флаг ошибки или завершить выполнение
    }
    

    }

    // JE rel8 void Emulator::instr_JE_rel8() { int8_t rel = fetch_byte(); if (regs.EFLAGS & ZF) { regs.EIP += rel; } }

    // JNE rel8 void Emulator::instr_JNE_rel8() { int8_t rel = fetch_byte(); if (!(regs.EFLAGS & ZF)) { regs.EIP += rel; } }

    // AND EAX, imm32 void Emulator::instr_AND_EAX_imm32() { uint32_t imm = fetch_dword(); regs.EAX &= imm; update_ZF(regs.EAX); }

    // AND ECX, imm32 void Emulator::instr_AND_ECX_imm32() { uint32_t imm = fetch_dword(); regs.ECX &= imm; update_ZF(regs.ECX); }

    // OR EAX, imm32 void Emulator::instr_OR_EAX_imm32() { uint32_t imm = fetch_dword(); regs.EAX |= imm; update_ZF(regs.EAX); }

    // OR ECX, imm32 void Emulator::instr_OR_ECX_imm32() { uint32_t imm = fetch_dword(); regs.ECX |= imm; update_ZF(regs.ECX); }

    // XOR EAX, imm32 void Emulator::instr_XOR_EAX_imm32() { uint32_t imm = fetch_dword(); regs.EAX ^= imm; update_ZF(regs.EAX); }

    // SUB EBX, imm32 void Emulator::instr_SUB_EBX_imm32() { uint32_t imm = fetch_dword(); regs.EBX -= imm; update_ZF(regs.EBX); }

    // CMP EAX, imm32 void Emulator::instr_CMP_EAX_imm32() { uint32_t imm = fetch_dword(); uint32_t result = regs.EAX - imm; if (regs.EAX == imm) regs.EFLAGS |= ZF; else regs.EFLAGS &= ~ZF; // Дополнительно можно установить другие флаги (CF, OF и т.д.) }

    // Обработчик инструкции RET void Emulator::instr_RET() { if (regs.ESP + 4 > memory.size()) { std::cout << "Stack underflow on RET.\n"; error_flag = true; running = false; return; }

    // Pop the return address from the stack
    uint32_t return_address = read_memory_dword(regs.ESP);
    regs.ESP += 4;
    
    // Jump to the return address
    regs.EIP = return_address;
    

    }

    // Обработчик инструкции SUB r32, imm32 void Emulator::instr_SUB_r32_imm32() { uint8_t modrm = fetch_byte(); uint8_t reg_opcode = (modrm >> 3) & 0x07; // Извлекаем поле reg из ModRM

    if (reg_opcode != 5) { // Для инструкции SUB reg, imm32, reg_opcode должен быть 5
        std::cout << "Unsupported SUB instruction with reg opcode: " << (int)reg_opcode << "\n";
        return;
    }
    
    uint32_t imm32 = fetch_dword(); // Извлекаем непосредственное значение
    uint8_t rm = regm_rm(modrm); // Извлекаем регистр назначения из ModRM
    uint32_t* reg_ptr = get_register_by_code(rm);
    
    if (reg_ptr) {
        *reg_ptr -= imm32;
        update_ZF(*reg_ptr);
    }
    else {
        std::cout << "SUB instruction with unsupported register.\n";
    }
    

    } void Emulator::instr_CMP_r32_rm32() { uint8_t modrm = fetch_byte();

    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_code = (modrm >> 3) & 0x07; // Источник: r32
    uint8_t rm_code = modrm & 0x07;         // Назначение: r/m32
    
    uint32_t* reg = get_register_by_code(reg_code); // Источник
    uint32_t* rm;
    
    if (mod == 3) {
        rm = get_register_by_code(rm_code);
    
        if (!rm) {
            std::cout << "Неизвестный регистр в CMP r/m32, r32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else {
        // Для простоты реализуем только регистровый режим
        std::cout << "Поддерживается только регистровый режим для CMP r/m32, r32.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    // Выполняем сравнение
    uint32_t result = *rm - *reg;
    
    // Обновляем флаги
    // Zero Flag (ZF)
    if (result == 0)
        regs.EFLAGS |= ZF;
    else
        regs.EFLAGS &= ~ZF;
    
    // Sign Flag (SF)
    if (result & 0x80000000)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;
    
    // Carry Flag (CF)
    if (*rm < *reg)
        regs.EFLAGS |= CF;
    else
        regs.EFLAGS &= ~CF;
    
    // Overflow Flag (OF)
    uint32_t sign_rm = *rm & 0x80000000;
    uint32_t sign_reg = *reg & 0x80000000;
    uint32_t sign_result = result & 0x80000000;
    if ((sign_rm != sign_reg) && (sign_rm != sign_result))
        regs.EFLAGS |= OF;
    else
        regs.EFLAGS &= ~OF;
    

    } // Обработчик инструкции JE rel32 (0x0F 0x84) void Emulator::instr_JE_rel32() { int32_t rel32 = fetch_dword(); // Читаем относительное смещение if (regs.EFLAGS & ZF) { // Проверка флага равенства regs.EIP += rel32; } }

    // Обработчик инструкции JNE rel32 (0x0F 0x85) void Emulator::instr_JNE_rel32() { int32_t rel32 = fetch_dword(); // Читаем относительное смещение if (!(regs.EFLAGS & ZF)) { // Проверка флага неравенства regs.EIP += rel32; } }

    // Обработчик инструкции JG rel32 (0x0F 0x8F) void Emulator::instr_JG_rel32() { int32_t rel32 = fetch_dword(); // Читаем относительное смещение bool zf = (regs.EFLAGS & ZF) != 0; bool sf = (regs.EFLAGS & SF) != 0; bool of = (regs.EFLAGS & OF) != 0; if (!zf && (sf == of)) { regs.EIP += rel32; } } void Emulator::instr_MOV_rm8_imm8() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm & 0xC0) >> 6; // uint8_t reg = (modrm & 0x38) >> 3; // Не используется для MOV r/m8, imm8 uint8_t rm = (modrm & 0x07); // Назначение: r/m8

    uint8_t imm8 = fetch_byte();
    
    if (mod == 3) { // Регистр
        uint32_t* dest_reg = get_register_by_code(rm);
        if (dest_reg) {
            // Только младший байт регистра
            uint8_t* dest_reg_byte = reinterpret_cast<uint8_t*>(dest_reg);
            dest_reg_byte[0] = imm8;
        }
        else {
            std::cout << "Неизвестный регистр в MOV r/m8, imm8.\n";
            error_flag = true;
            running = false;
        }
    }
    else { // Память
        uint32_t address = calculate_address(modrm);
        if (error_flag) {
            return; // Ошибка уже установлена в calculate_address
        }
    
        if (address >= memory.size()) {
            std::cout << "Memory access out of bounds in MOV r/m8, imm8.\n";
            error_flag = true;
            running = false;
            return;
        }
    
        memory[address] = imm8;
    }
    

    }

    // Обработчик инструкции MUL r/m32 void Emulator::instr_MUL_rm32(uint8_t modrm) { uint8_t mod = (modrm & 0xC0) >> 6; // uint8_t reg = (modrm & 0x38) >> 3; // Не используется для MUL r/m32 uint8_t rm = (modrm & 0x07); // Источник: r/m32

    uint32_t operand = 0;
    
    if (mod == 3) { // Регистр
        uint32_t* src_reg = get_register_by_code(rm);
        if (src_reg) {
            operand = *src_reg;
        }
        else {
            std::cout << "Неизвестный регистр в MUL r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else {
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        operand = read_memory_dword(address);
    }
    
    // Выполнение умножения: EDX:EAX = EAX * operand
    uint64_t result = static_cast<uint64_t>(regs.EAX) * static_cast<uint64_t>(operand);
    regs.EAX = static_cast<uint32_t>(result & 0xFFFFFFFF);
    regs.EDX = static_cast<uint32_t>((result >> 32) & 0xFFFFFFFF);
    
    update_ZF(regs.EAX);
    

    }

    // Реализация обработчика для DIV r/m32 void Emulator::instr_DIV_rm32(uint8_t modrm) { uint8_t mod = (modrm >> 6) & 0x03; uint8_t rm = modrm & 0x07;

    uint32_t operand = 0;
    
    if (mod == 3) { // Регистровый операнд
        uint32_t* src_reg = get_register_by_code(rm);
        if (src_reg) {
            operand = *src_reg;
        }
        else {
            std::cout << "Неизвестный регистр в DIV r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else { // Операнд из памяти
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        operand = read_memory_dword(address); // Чтение операнда из памяти
    }
    
    if (operand == 0) {
        std::cout << "Деление на ноль.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    // Выполнение деления: EDX:EAX = EAX / operand
    uint64_t dividend = (static_cast<uint64_t>(regs.EDX) << 32) | regs.EAX;
    regs.EAX = static_cast<uint32_t>(dividend / operand);
    regs.EDX = static_cast<uint32_t>(dividend % operand);
    
    //std::cout << "DIV instruction: Dividend = " << dividend << ", Operand = " << operand
        //<< ", EAX = " << regs.EAX << ", EDX = " << regs.EDX << "\n";
    
    update_ZF(regs.EAX);
    

    } void Emulator::instr_LEA_r32_m() { uint8_t modrm = fetch_byte(); uint8_t mod = modrm >> 6; uint8_t reg = (modrm >> 3) & 0x07; // Destination register code uint8_t rm = modrm & 0x07; // Source operand

    // LEA is invalid with mod == 3 (register-direct mode)
    if (mod == 3) {
        std::cout << "Invalid LEA instruction with mod == 3.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    // Calculate the effective address
    uint32_t address = calculate_address(modrm);
    if (error_flag)
        return;
    
    // Get the destination register
    uint32_t* dest_reg = get_register_by_code(reg);
    if (!dest_reg) {
        std::cout << "Unknown destination register in LEA.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    // Store the effective address into the destination register
    *dest_reg = address;
    

    } void Emulator::instr_IDIV_rm32(uint8_t modrm) { uint8_t mod = (modrm & 0xC0) >> 6; uint8_t rm = (modrm & 0x07); // Источник: r/m32

    int32_t operand = 0;
    
    if (mod == 3) { // Регистр
        int32_t* src_reg = reinterpret_cast<int32_t*>(get_register_by_code(rm));
        if (src_reg) {
            operand = *src_reg;
        }
        else {
            std::cout << "Неизвестный регистр в IDIV r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else { // Операнд из памяти
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        operand = read_memory_dword(address); // Чтение операнда из памяти
    }
    
    if (operand == 0) {
        std::cout << "Деление на ноль.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    // Выполнение деления: EDX:EAX = EAX / operand
    int64_t dividend = (static_cast<int64_t>(regs.EDX) << 32) | regs.EAX;
    regs.EAX = static_cast<uint32_t>(dividend / operand);
    regs.EDX = static_cast<uint32_t>(dividend % operand);
    
    update_ZF(regs.EAX);
    

    }

    // Общий обработчик для opcode 0xF7 void Emulator::instr_F7() { uint8_t modrm = fetch_byte(); uint8_t reg = (modrm >> 3) & 0x07; // /digit

    switch (reg) {
    case 4: // MUL r/m32
        instr_MUL_rm32(modrm);
        break;
    case 6: // DIV r/m32
        instr_DIV_rm32(modrm);
        break;
    case 7: // IDIV r/m32
        instr_IDIV_rm32(modrm);
        break;
    default:
        std::cout << "F7 instruction with unsupported /digit: " << static_cast<int>(reg) << "\n";
        error_flag = true;
        running = false;
        break;
    }
    

    }

    void Emulator::instr_MOV_rm8_r8() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm >> 6) & 0x03; uint8_t rm = modrm & 0x07; uint8_t reg = (modrm >> 3) & 0x07;

    uint8_t* src_reg = get_register8_by_code(reg);
    if (!src_reg) {
        std::cout << "Unknown source register in MOV r/m8, r8.\n";
        error_flag = true;
        running = false;
        return;
    }
    uint8_t value = *src_reg;
    
    if (mod == 3) {
        // Режим регистр-регистр
        uint8_t* dest_reg = get_register8_by_code(rm);
        if (!dest_reg) {
            std::cout << "Unknown destination register in MOV r/m8, r8.\n";
            error_flag = true;
            running = false;
            return;
        }
        *dest_reg = value;
    }
    
    else {
        // Режим регистр-память
        uint32_t address = 0;
        if (rm == 4) {
            // SIB байт
            uint8_t sib = fetch_byte();
            int32_t displacement = 0;
            if (mod == 1) {
                displacement = static_cast<int8_t>(fetch_byte());
            }
            else if (mod == 2) {
                displacement = static_cast<int32_t>(fetch_dword());
            }
            address = calculate_sib_address(mod, sib, displacement);
        }
        else {
            int32_t displacement = 0;
            if (mod == 1) {
                displacement = static_cast<int8_t>(fetch_byte());
            }
            else if (mod == 2) {
                displacement = static_cast<int32_t>(fetch_dword());
            }
            address = *get_register_by_code(rm) + displacement;
        }
        if (address >= memory.size()) {
            std::cout << "Memory access out of bounds in MOV r/m8, r8.\n";
            error_flag = true;
            running = false;
            return;
        }
        memory[address] = value;
    }
    

    }

    void Emulator::instr_ADD_AL_imm8() { uint8_t imm8 = fetch_byte(); uint8_t* al = reinterpret_cast<uint8_t*>(&regs.EAX); *al += imm8; update_ZF(*al); // Обновляем флаг ZF на основе 8-битного результата } void Emulator::instr_POP_EBP() { if (regs.ESP + 4 > memory.size()) { std::cerr << "Stack underflow on POP EBP.\n"; error_flag = true; running = false; return; } // Pop the value from the stack into EBP regs.EBP = read_memory_dword(regs.ESP); regs.ESP += 4;

    std::cout << "Выполнен POP EBP. Значение в регистре EBP: 0x" << std::hex << regs.EBP << "\n";
    

    } void Emulator::instr_MOV_ESI_imm32() { regs.ESI = fetch_dword(); }

    // INT n (0xCD) void Emulator::instr_INT() { uint8_t int_number = fetch_byte(); if (int_number == 0x80) { // Обработка системного вызова Linux uint32_t syscall_number = regs.EAX; switch (syscall_number) { case 1: // sys_exit running = false; break; case 3: { // sys_read uint32_t fd = regs.EBX; uint32_t buf = regs.ECX; uint32_t count = regs.EDX;

            if (fd == 0) { // stdin
                std::string input;
                std::getline(std::cin, input);
    
                // Читаем не более count байтов
                input = input.substr(0, count);
    
                // Записываем введённые данные в память
                for (size_t i = 0; i < input.size(); ++i) {
                    memory[buf + i] = static_cast<uint8_t>(input[i]);
                }
    
                // Если введённых данных меньше, чем запрошено, заполняем оставшиеся нулями
                for (size_t i = input.size(); i < count; ++i) {
                    memory[buf + i] = 0;
                }
    
                // Возвращаем количество прочитанных байтов в EAX
                regs.EAX = input.size();
            }
            else {
                std::cout << "Unsupported file descriptor in sys_read: " << fd << "\n";
                regs.EAX = -1; // Возвращаем -1 в случае ошибки
            }
        }
        case 4: { // sys_write
            uint32_t fd = regs.EBX;
            uint32_t buf = regs.ECX;
            uint32_t count = regs.EDX;
            // Debug output
            std::cout << "sys_write called with fd=" << fd
                << ", buf=0x" << std::hex << buf
                << ", count=" << std::dec << count << "\n";
            if (fd == 1) { // stdout
                // Ensure the buffer address is within memory bounds
                if (buf + count > memory.size()) {
                    std::cout << "Buffer out of bounds in sys_write.\n";
                    regs.EAX = -1; // Return -1 on error
                    break;
                }
                std::string output;
                for (uint32_t i = 0; i < count; ++i) {
                    output += static_cast<char>(memory[buf + i]);
                }
                std::cout << output; // Output the string
    
                // Return the number of bytes written
                regs.EAX = count;
            }
    
            else {
                std::cout << "Unsupported file descriptor in sys_write: " << fd << "\n";
                regs.EAX = -1; // Return -1 on error
            }
            break;
        }
        case 45: { // sys_brk
            uint32_t addr = regs.EBX;
            if (addr == 0) {
                // Возвращаем текущий адрес brk
                regs.EAX = current_brk;
            }
            else {
                // Устанавливаем новый адрес brk
                if (addr >= data_segment_start && addr < memory.size()) {
                    current_brk = addr;
                    regs.EAX = current_brk;
                }
                else {
                    // Ошибка: попытка установить brk за пределами памяти
                    regs.EAX = 0; // Ошибка
                }
            }
            break;
        }
        case 90: // sys_mmap
            // Реализация sys_mmap
            break;
        case 91: { // sys_munmap
            uint32_t addr = regs.EBX;
            uint32_t length = regs.ECX;
            // Для простоты, можно игнорировать освобождение памяти
            regs.EAX = 0;
            break;
        }
        case 5: { // sys_open
            const char* filename = reinterpret_cast<const char*>(&memory[regs.EBX]); // Путь к файлу
            uint32_t flags = regs.ECX;
            uint32_t mode = regs.EDX;
            // Для простоты, возвращаем фиктивный файловый дескриптор, например 3
            regs.EAX = 3;
            break;
        }
        case 6: { // sys_close
            uint32_t fd = regs.EBX;
            // Ничего не делаем, возвращаем успех
            regs.EAX = 0;
            break;
        }
        case 192: { // sys_mmap2
            uint32_t addr = regs.EBX;
            uint32_t length = regs.ECX;
            uint32_t prot = regs.EDX;
            uint32_t flags = regs.ESI;
            uint32_t fd = regs.EDI;
            uint32_t pgoffset = regs.EBP;
    
            // Если addr равен 0, выбираем свободный адрес
            if (addr == 0) {
                addr = allocate_memory(0, length);
            }
            else {
                // Проверяем, можем ли мы выделить память по запрошенному адресу
                addr = allocate_memory(addr, length);
            }
    
            if (addr == 0) {
                // Ошибка при выделении памяти
                regs.EAX = -1;
            }
            else {
                // Успешное выделение памяти
                regs.EAX = addr;
            }
            break;
        }
        case 195: // sys_fstat
            // Реализация sys_fstat
            break;
        case 197: { // sys_fstat64
            uint32_t fd = regs.EBX;
            uint32_t buf = regs.ECX;
            // Возвращаем фиктивные данные
            // В структуре struct stat64 около 104 байт
            memset(&memory[buf], 0, 104);
            regs.EAX = 0;
            break;
        }
        default:
            std::cout << "Неизвестный системный вызов: " << syscall_number << "\n";
            running = false;
            break;
        }
    }
    else {
        std::cout << "Неизвестное прерывание: INT " << (int)int_number << "\n";
        error_flag = true;
        running = false;
    }
    

    }

    void Emulator::instr_MOV_MEM_EAX() { uint32_t address = fetch_dword(); if (address + 4 > memory.size()) { throw std::runtime_error("Выход за пределы памяти при MOV [address], EAX"); } memory[address] = regs.EAX & 0xFF; memory[address + 1] = (regs.EAX >> 8) & 0xFF; memory[address + 2] = (regs.EAX >> 16) & 0xFF; memory[address + 3] = (regs.EAX >> 24) & 0xFF; }

    void Emulator::instr_MOV_EAX_MEM() { uint32_t address = fetch_dword(); if (address + 4 > memory.size()) { throw std::runtime_error("Выход за пределы памяти при MOV EAX, [address]"); } regs.EAX = memory[address] | (memory[address + 1] << 8) | (memory[address + 2] << 16) | (memory[address + 3] << 24); } // CMP EAX, EBX void Emulator::instr_CMP_EAX_EBX() { uint8_t modrm = fetch_byte(); // Получаем ModRM байт uint8_t reg = (modrm >> 3) & 0x07; // Извлекаем регистры uint8_t rm = modrm & 0x07;

    // Проверяем, что регистры соответствуют EAX и EBX
    if (reg == 0 && rm == 3) { // 0 для EAX и 3 для EBX
        uint32_t result = regs.EAX - regs.EBX;
    
        // Zero Flag (ZF)
        if (result == 0)
            regs.EFLAGS |= ZF;
        else
            regs.EFLAGS &= ~ZF;
    
        // Sign Flag (SF)
        if (result & (1 << 31))
            regs.EFLAGS |= SF;
        else
            regs.EFLAGS &= ~SF;
    
        // Остальная обработка флагов
    }
    else {
        std::cout << "CMP instruction with unsupported register combination.\n";
        error_flag = true;
        running = false;
    }
    

    }

    void Emulator::instr_JG_rel8() { int8_t rel = fetch_byte();

    bool zf = (regs.EFLAGS & ZF) != 0;
    bool sf = (regs.EFLAGS & SF) != 0;
    bool of = (regs.EFLAGS & OF) != 0;
    
    // JG переходит, если ZF = 0 и SF = OF
    if (!zf && (sf == of)) {
        regs.EIP += rel;
    }
    

    } // Реализация инструкции IMUL reg, r/m32, imm32 void Emulator::instr_IMUL_reg_rm32_imm32() { // Before reading ModRM byte, EIP points to it std::cout << "EIP before fetch_byte (ModRM): 0x" << std::hex << regs.EIP << "\n";

    uint8_t modrm = fetch_byte(); // Read ModRM byte
    uint8_t mod = modrm >> 6;
    uint8_t reg_code = (modrm >> 3) & 0x07; // Destination register
    uint8_t rm_code = modrm & 0x07;         // Source operand
    
    // Debug output
    std::cout << "Executing IMUL with modrm: 0x" << std::hex << (int)modrm << "\n";
    std::cout << "Destination reg code: " << (int)reg_code << ", Source rm code: " << (int)rm_code << "\n";
    std::cout << "EIP after fetch_byte (ModRM): 0x" << std::hex << regs.EIP << "\n";
    
    uint32_t* dest_reg = get_register_by_code(reg_code);
    uint32_t* src_reg = nullptr;
    
    if (mod == 3) { // Register-register mode
        src_reg = get_register_by_code(rm_code);
        if (!src_reg) {
            std::cout << "Unknown source register in IMUL.\n";
            error_flag = true;
            running = false;
            return;
        }
    }
    else {
        std::cout << "Unsupported addressing mode in IMUL.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    // Check if dest_reg is valid
    if (!dest_reg) {
        std::cout << "Unknown destination register in IMUL.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    // Before reading imm32, EIP points to it
    std::cout << "EIP before fetch_dword (imm32): 0x" << std::hex << regs.EIP << "\n";
    
    uint32_t imm32 = fetch_dword(); // Read immediate value imm32
    
    // After reading imm32, EIP should have been incremented by 4
    std::cout << "EIP after fetch_dword (imm32): 0x" << std::hex << regs.EIP << "\n";
    // Debug output of imm32
    std::cout << "Immediate value: " << std::dec << imm32 << "\n";
    
    // Perform signed multiplication
    int32_t result = static_cast<int32_t>(*src_reg) * static_cast<int32_t>(imm32);
    *dest_reg = static_cast<uint32_t>(result);
    
    // Update flags appropriately
    update_ZF(*dest_reg);
    // Update other flags (CF, OF) if necessary
    

    }

    void Emulator::instr_SUB_AL_imm8() { uint8_t imm8 = fetch_byte(); uint8_t* al = reinterpret_cast<uint8_t*>(&regs.EAX); *al -= imm8; update_ZF(*al); } void Emulator::instr_JMP_rel8() { int8_t rel = fetch_byte(); regs.EIP += rel; } void Emulator::instr_JB_rel8() { int8_t rel = fetch_byte(); if (regs.EFLAGS & CF) { regs.EIP += rel; } }

    void Emulator::instr_JA_rel8() { int8_t rel = fetch_byte(); bool cf = (regs.EFLAGS & CF) != 0; bool zf = (regs.EFLAGS & ZF) != 0; if (!cf && !zf) { regs.EIP += rel; } } void Emulator::instr_INC_ECX() { regs.ECX += 1; update_ZF(regs.ECX); } void Emulator::instr_MOV_r8_imm8() { uint8_t opcode = memory[regs.EIP - 1]; // Последний прочитанный опкод uint8_t reg_code = opcode - 0xB0; // Регистры AL, CL, DL, BL, AH, CH, DH, BH идут от 0xB0 до 0xB7

    uint8_t imm8 = fetch_byte();
    uint8_t* reg = get_register8_by_code(reg_code);
    
    if (!reg) {
        std::cout << "Unknown register in MOV r8, imm8.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    *reg = imm8;
    

    } void Emulator::instr_SUB_rm8_imm8() { uint8_t modrm = fetch_byte(); uint8_t opcode = (modrm >> 3) & 0x07; uint8_t rm_code = modrm & 0x07;

    if (opcode != 5) {
        std::cout << "Unsupported opcode in SUB rm8, imm8.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    uint8_t imm8 = fetch_byte();
    uint8_t* dest = get_register8_by_code(rm_code);
    
    if (!dest) {
        std::cout << "Unknown register in SUB rm8, imm8.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    *dest -= imm8;
    
    update_ZF(*dest);
    

    } void Emulator::instr_MOV_r8_rm8() { uint8_t modrm = fetch_byte(); uint8_t mod = modrm >> 6; uint8_t reg_code = (modrm >> 3) & 0x07; // Назначение: r8 uint8_t rm = modrm & 0x07; // Источник: r/m8

    uint8_t* reg = get_register8_by_code(reg_code);
    if (!reg) {
        std::cout << "Unknown register in MOV r8, rm8.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    uint32_t address = 0;
    
    if (mod == 0) {
        if (rm == 4) {
            // Обработка SIB байта
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, 0);
        }
        else if (rm == 5) {
            // [disp32]
            address = fetch_dword();
        }
        else {
            // [reg]
            uint32_t* rm_reg = get_register_by_code(rm);
            if (rm_reg) {
                address = *rm_reg;
            }
            else {
                std::cout << "Unknown base register in MOV r8, rm8.\n";
                error_flag = true;
                running = false;
                return;
            }
        }
    }
    else if (mod == 1) {
        int8_t disp8 = static_cast<int8_t>(fetch_byte());
        if (rm == 4) {
            // Обработка SIB байта
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, disp8);
        }
        else {
            // [reg + disp8]
            uint32_t* rm_reg = get_register_by_code(rm);
            if (rm_reg) {
                address = *rm_reg + disp8;
            }
            else {
                std::cout << "Unknown base register in MOV r8, rm8.\n";
                error_flag = true;
                running = false;
                return;
            }
        }
    }
    else if (mod == 2) {
        int32_t disp32 = static_cast<int32_t>(fetch_dword());
        if (rm == 4) {
            // Обработка SIB байта
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, disp32);
        }
        else {
            // [reg + disp32]
            uint32_t* rm_reg = get_register_by_code(rm);
            if (rm_reg) {
                address = *rm_reg + disp32;
            }
            else {
                std::cout << "Unknown base register in MOV r8, rm8.\n";
                error_flag = true;
                running = false;
                return;
            }
        }
    }
    else if (mod == 3) {
        // MOV r8, r8
        uint8_t* rm_reg = get_register8_by_code(rm);
        if (rm_reg) {
            *reg = *rm_reg;
        }
        else {
            std::cout << "Unknown register in MOV r8, rm8.\n";
            error_flag = true;
            running = false;
        }
        return;
    }
    else {
        std::cout << "Unsupported mod in MOV r8, rm8.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    if (address >= memory.size()) {
        std::cout << "Memory access out of bounds in MOV r8, [address].\n";
        error_flag = true;
        running = false;
        return;
    }
    
    *reg = memory[address];
    

    } // MOV EBP, imm32 void Emulator::instr_MOV_EBP_imm32() { uint32_t imm = fetch_dword(); regs.EBP = imm; } // MOV ESP, imm32 void Emulator::instr_MOV_ESP_imm32() { uint32_t imm = fetch_dword(); regs.ESP = imm; }

    // MOV EDI, imm32 void Emulator::instr_MOV_EDI_imm32() { uint32_t imm = fetch_dword(); regs.EDI = imm; } void Emulator::instr_MOV_r32_r_m32() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm >> 6) & 0x03; uint8_t reg = (modrm >> 3) & 0x07; // Destination register (r32) uint8_t rm = modrm & 0x07; // Source (r/m32)

    uint32_t* dest_reg = get_register_by_code(reg);
    
    if (mod == 3) { // Register-register mode
        uint32_t* src_reg = get_register_by_code(rm);
        if (dest_reg && src_reg) {
            *dest_reg = *src_reg;
        }
        else {
            std::cout << "Unknown register in MOV r32, r/m32.\n";
            error_flag = true;
            running = false;
        }
    }
    else { // Memory to register
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
    
        uint32_t value = read_memory_dword(address);
        if (dest_reg) {
            *dest_reg = value;
        }
        else {
            std::cout << "Unknown destination register in MOV r32, r/m32.\n";
            error_flag = true;
            running = false;
        }
    }
    

    } void Emulator::instr_ADD_r32_rm32() { uint8_t modrm = fetch_byte(); Operand operand = decode_operand(modrm); // Предполагается, что вы реализовали структуру Operand

    uint8_t reg_code = (modrm >> 3) & 0x07;
    uint8_t rm_code = modrm & 0x07;
    
    uint32_t* reg = get_register_by_code(reg_code);
    
    if (!reg) {
        std::cout << "Unknown destination register in ADD r32, r/m32.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    if (operand.is_memory) {
        uint32_t value = read_memory_dword(operand.address);
        *reg += value;
    }
    else {
        uint32_t* src_reg = get_register_by_code(rm_code);
        if (!src_reg) {
            std::cout << "Unknown source register in ADD r32, r/m32.\n";
            error_flag = true;
            running = false;
            return;
        }
        *reg += *src_reg;
    }
    
    update_ZF(*reg);
    // Обновите другие флаги при необходимости
    

    }

    void Emulator::instr_ADD_rm32_r32() { bool is_locked = regs.lock_prefix;

    uint8_t modrm = fetch_byte();
    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_code = (modrm >> 3) & 0x07; // Source register (r32)
    uint8_t rm_code = modrm & 0x07;         // Destination (r/m32)
    
    uint32_t* src_reg = get_register_by_code(reg_code);
    
    if (mod == 3) { // Register-register mode
        uint32_t* dest_reg = get_register_by_code(rm_code);
        if (src_reg && dest_reg) {
            if (is_locked) {
                std::cout << "LOCK prefix applied to ADD r32, r/m32.\n";
            }
            *dest_reg += *src_reg;
            update_ZF(*dest_reg);
            // Update other flags as needed
        }
        else {
            std::cout << "Unknown register in ADD r/m32, r32.\n";
            error_flag = true;
            running = false;
        }
    }
    else { // Memory operand
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
    
        uint32_t value = read_memory_dword(address);
        value += *src_reg;
        write_memory_dword(address, value);
        update_ZF(value);
        // Update other flags as needed
    }
    reset_prefixes();
    

    } void Emulator::instr_CMP_AL_imm8() { uint8_t imm8 = fetch_byte(); uint8_t al = regs.EAX & 0xFF; uint8_t result = al - imm8;

    // Update Zero Flag (ZF)
    if (result == 0)
        regs.EFLAGS |= ZF;
    else
        regs.EFLAGS &= ~ZF;
    
    // Update Sign Flag (SF)
    if (result & 0x80)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;
    
    // Update Carry Flag (CF)
    if (al < imm8)
        regs.EFLAGS |= CF;
    else
        regs.EFLAGS &= ~CF;
    
    // Update Overflow Flag (OF)
    bool overflow = ((al ^ imm8) & (al ^ result) & 0x80) != 0;
    if (overflow)
        regs.EFLAGS |= OF;
    else
        regs.EFLAGS &= ~OF;
    

    } void Emulator::instr_JL_rel8() { int8_t rel = fetch_byte();

    bool sf = (regs.EFLAGS & SF) != 0;
    bool of = (regs.EFLAGS & OF) != 0;
    
    // JL переходит, если SF != OF
    if (sf != of) {
        regs.EIP += rel;
    }
    

    }

    void Emulator::instr_XOR_r32_rm32() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm >> 6) & 0x03; uint8_t reg = (modrm >> 3) & 0x07; // Source register (r32) uint8_t rm = modrm & 0x07; // Destination (r/m32)

    if (mod == 3) { // Register-register mode
        uint32_t* src_reg = get_register_by_code(reg);
        uint32_t* dest_reg = get_register_by_code(rm);
    
        if (src_reg && dest_reg) {
            *dest_reg ^= *src_reg;
            update_ZF(*dest_reg);
        }
        else {
            std::cout << "Unknown register in XOR r/m32, r32.\n";
            error_flag = true;
            running = false;
        }
    }
    // ...
    

    } void Emulator::instr_CALL_rel32() { int32_t rel32 = fetch_dword(); // Push the next instruction address onto the stack push(regs.EIP); // Jump to the target address regs.EIP += rel32; } // Обработчик для opcode 0x81 (32-битное непосредственное значение) void Emulator::instr_GROUP1_Ev_Iz_81() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm >> 6) & 0x03; uint8_t reg_opcode = (modrm >> 3) & 0x07; // Поле reg в ModRM uint8_t rm = modrm & 0x07;

    uint32_t* dest_reg = nullptr;
    if (mod == 3) { // Режим регистр-регистр
        dest_reg = get_register_by_code(rm);
    }
    else {
        // Обработка памяти (не реализовано)
        std::cout << "Memory operands not implemented for opcode 0x81.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    uint32_t imm32 = fetch_dword(); // Чтение 32-битного непосредственного значения
    
    switch (reg_opcode) {
    case 0: // ADD
        *dest_reg += imm32;
        update_ZF(*dest_reg);
        break;
    case 1: // OR
        *dest_reg |= imm32;
        update_ZF(*dest_reg);
        break;
    case 2: // ADC
        // Реализуйте ADC при необходимости
        break;
    case 3: // SBB
        // Реализуйте SBB при необходимости
        break;
    case 4: // AND
        *dest_reg &= imm32;
        update_ZF(*dest_reg);
        break;
    case 5: // SUB
        *dest_reg -= imm32;
        update_ZF(*dest_reg);
        break;
    case 6: // XOR
        *dest_reg ^= imm32;
        update_ZF(*dest_reg);
        break;
    case 7: // CMP
    {
        uint32_t result = *dest_reg - imm32;
        update_ZF(result);
        // Обновите другие флаги при необходимости
    }
    break;
    default:
        std::cout << "Unsupported reg opcode in opcode 0x81: " << (int)reg_opcode << "\n";
        error_flag = true;
        running = false;
        break;
    }
    

    }

    // Обработчик для opcode 0x83 (8-битное непосредственное значение) void Emulator::instr_GROUP1_Ev_Iz_83() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm >> 6) & 0x03; uint8_t reg_opcode = (modrm >> 3) & 0x07; // Поле reg в ModRM uint8_t rm = modrm & 0x07;

    uint32_t* dest_reg = nullptr;
    if (mod == 3) { // Режим регистр-регистр
        dest_reg = get_register_by_code(rm);
    }
    else {
        // Обработка памяти (не реализовано)
        std::cout << "Memory operands not implemented for opcode 0x83.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    int8_t imm8 = static_cast<int8_t>(fetch_byte()); // Чтение 8-битного непосредственного значения
    
    // Знаковое расширение до 32 бит
    int32_t sign_extended_imm = static_cast<int32_t>(imm8);
    
    switch (reg_opcode) {
    case 0: // ADD
        *dest_reg += sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 1: // OR
        *dest_reg |= sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 2: // ADC
        // Реализуйте ADC при необходимости
        break;
    case 3: // SBB
        // Реализуйте SBB при необходимости
        break;
    case 4: // AND
        *dest_reg &= sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 5: // SUB
        *dest_reg -= sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 6: // XOR
        *dest_reg ^= sign_extended_imm;
        update_ZF(*dest_reg);
        break;
    case 7: // CMP
    {
        uint32_t result = *dest_reg - sign_extended_imm;
        update_ZF(result);
        // Обновите другие флаги при необходимости
    }
    break;
    default:
        std::cout << "Unsupported reg opcode in opcode 0x83: " << (int)reg_opcode << "\n";
        error_flag = true;
        running = false;
        break;
    }
    

    } void Emulator::instr_JL_rel32() { int32_t rel32 = fetch_dword(); // Читаем относительное смещение bool sf = (regs.EFLAGS & SF) != 0; bool of = (regs.EFLAGS & OF) != 0; if (sf != of) { regs.EIP += rel32; } } void Emulator::instr_MOVSB() { // Обработка префиксов REP/REPE/REPNE if (regs.rep_prefix || regs.repne_prefix) { // Определяем тип префикса bool is_rep = regs.rep_prefix; bool is_repne = regs.repne_prefix;

        while (regs.ECX != 0) {
            uint8_t byte = read_memory_byte(regs.ESI);
            write_memory_byte(regs.EDI, byte);
            regs.ESI += 1;
            regs.EDI += 1;
            regs.ECX -= 1;
    
            // Обновление флагов по необходимости
            update_ZF(byte);
    
            // Для `REPNE` можно добавить условия выхода
            if (is_repne && (regs.EFLAGS & ZF)) {
                break;
            }
    
            if (is_rep && regs.ECX == 0) {
                break;
            }
        }
    
        // Сброс префиксов после выполнения
        reset_prefixes();
    }
    else {
        // Обычное выполнение MOVSB без повторения
        uint8_t byte = read_memory_byte(regs.ESI);
        write_memory_byte(regs.EDI, byte);
        regs.ESI += 1;
        regs.EDI += 1;
    
        // Обновление флагов по необходимости
        update_ZF(byte);
    }
    

    } void Emulator::instr_ADD_rm8_r8() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm >> 6) & 0x03; uint8_t reg_code = (modrm >> 3) & 0x07; // Source register (r8) uint8_t rm = modrm & 0x07; // Destination (r/m8)

    uint8_t* src_reg = get_register8_by_code(reg_code);
    if (!src_reg) {
        std::cout << "Unknown source register in ADD r/m8, r8.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    if (mod == 3) { // Register to register
        uint8_t* dest_reg = get_register8_by_code(rm);
        if (!dest_reg) {
            std::cout << "Unknown destination register in ADD r/m8, r8.\n";
            error_flag = true;
            running = false;
            return;
        }
        *dest_reg += *src_reg;
        update_ZF(*dest_reg);
    }
    else {
        // Memory operand
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        uint8_t value = read_memory_byte(address);
        value += *src_reg;
        write_memory_byte(address, value);
        update_ZF(value);
    }
    // Update other flags (CF, OF, etc.) as necessary
    

    } // XOR AL, imm8 void Emulator::instr_XOR_AL_imm8() { uint8_t imm8 = fetch_byte(); uint8_t* al = reinterpret_cast<uint8_t*>(&regs.EAX); // Access the AL register *al ^= imm8; // Perform XOR operation

    // Update Zero Flag (ZF)
    if (*al == 0)
        regs.EFLAGS |= ZF;
    else
        regs.EFLAGS &= ~ZF;
    
    // Update Sign Flag (SF)
    if (*al & 0x80)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;
    
    // Parity Flag (PF)
    update_PF(*al);
    
    // Clear Carry Flag (CF) and Overflow Flag (OF) as XOR resets them
    regs.EFLAGS &= ~CF;
    regs.EFLAGS &= ~OF;
    
    std::cout << "Выполнена инструкция XOR AL, imm8. AL: 0x" << std::hex << static_cast<int>(*al) << "\n";
    

    }

    // Function to update Parity Flag based on the result void Emulator::update_PF(uint8_t result) { // Count the number of set bits result ^= result >> 4; result &= 0xF; bool parity = (0x6996 >> result) & 1; if (parity) regs.EFLAGS |= PF; // PF is set if parity is even else regs.EFLAGS &= ~PF; } void Emulator::instr_AND_rm8_r8() { uint8_t modrm = fetch_byte();

    uint8_t mod = (modrm >> 6) & 0x03;
    uint8_t reg_code = (modrm >> 3) & 0x07; // r8
    uint8_t rm = modrm & 0x07;              // r/m8 (может быть регистром или памятью)
    
    uint8_t* reg = get_register8_by_code(reg_code);
    if (!reg) {
        std::cout << "Unknown source register in AND r/m8, r8.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    uint8_t value; // Объявляем переменную value
    
    if (mod == 3) { // Режим регистр-регистр
        uint8_t* dest_reg = get_register8_by_code(rm);
        if (!dest_reg) {
            std::cout << "Unknown destination register in AND r/m8, r8.\n";
            error_flag = true;
            running = false;
            return;
        }
        *dest_reg &= *reg;
        value = *dest_reg; // Сохраняем результат операции
        update_ZF(value);
    }
    else {
        // Операнд - память
        uint32_t address = calculate_address(modrm);
        if (error_flag) return;
        value = read_memory_byte(address);
        value &= *reg;
        write_memory_byte(address, value);
        update_ZF(value);
    }
    
    // Обновление флагов
    // Флаги CF и OF сбрасываются при логических операциях
    regs.EFLAGS &= ~(CF | OF);
    
    // Обновление SF
    if ((value & 0x80) != 0)
        regs.EFLAGS |= SF;
    else
        regs.EFLAGS &= ~SF;
    
    // Обновление PF
    update_PF(value);
    
    std::cout << "Выполнена инструкция AND r/m8, r8.\n";
    

    } void Emulator::instr_MOV_r32_rm32() { uint8_t modrm = fetch_byte(); uint8_t mod = (modrm >> 6) & 0x03; uint8_t reg = (modrm >> 3) & 0x07; // Source register (r32) uint8_t rm = modrm & 0x07; // Destination (r/m32)

    if (mod == 3) { // Register-register mode
        uint32_t* src_reg = get_register_by_code(reg);
        uint32_t* dest_reg = get_register_by_code(rm);
    
        if (src_reg && dest_reg) {
            *dest_reg = *src_reg;
        }
        else {
            std::cout << "Unknown register in MOV r/m32, r32.\n";
            error_flag = true;
            running = false;
        }
    }
    

    } // Emulator.cpp #include "Emulator.h" #include #include

    // Конструктор Emulator::Emulator(size_t memory_size) { memory.resize(memory_size, 0); initialize_instruction_set(); regs.ESP = static_cast<uint32_t>(memory_size - 16); // Отступаем на 16 байт от конца памяти initialize_stack(); regs.CS = 0; regs.DS = 0; regs.SS = 0; regs.ES = 0; regs.FS = 0; regs.GS = 0;

    current_data_segment = &regs.DS;
    current_code_segment = &regs.CS;
    current_brk = data_segment_start;
    

    } uint32_t Emulator::allocate_memory(uint32_t addr, uint32_t length) { // Простая реализация: просто сдвигаем brk if (addr == 0) { addr = current_brk; }

    uint32_t new_brk = addr + length;
    if (new_brk > memory.size()) {
        // Недостаточно памяти в эмуляторе
        return 0;
    }
    
    current_brk = new_brk;
    return addr;
    

    } void Emulator::set_segment_override(uint8_t prefix) { switch (prefix) { case 0x2E: // CS current_code_segment = &regs.CS; break; case 0x36: // SS current_data_segment = &regs.SS; break; case 0x3E: // DS current_data_segment = &regs.DS; break; case 0x26: // ES current_data_segment = &regs.ES; break; case 0x64: // FS current_data_segment = &regs.FS; break; case 0x65: // GS current_data_segment = &regs.GS; break; default: // Неизвестный префикс сегмента, можно игнорировать или установить ошибку std::cout << "Неизвестный сегментный префикс: 0x" << std::hex << (int)prefix << "\n"; break; } } // Реализация метода write_memory void Emulator::write_memory(uint32_t address, const uint8_t* data, size_t size) { if (address + size > memory.size()) { std::cerr << "Ошибка: Пытаетесь записать за пределы памяти. Адрес: 0x" << std::hex << address << ", Размер: " << std::dec << size << "\n"; error_flag = true; running = false; return; } std::memcpy(&memory[address], data, size); } // Реализация метода set_eip void Emulator::set_eip(uint32_t address) { if (address >= memory.size()) { std::cerr << "Ошибка: Установка EIP за пределами памяти. Адрес: 0x" << std::hex << address << "\n"; error_flag = true; running = false; return; } regs.EIP = address; } uint8_t Emulator::read_memory_byte(uint32_t address) const { if (address >= memory.size()) { throw std::runtime_error("Чтение памяти вне границ"); } return memory[address]; }

    uint32_t Emulator::read_memory_dword(uint32_t address) const { if (address + 4 > memory.size()) { throw std::runtime_error("Чтение памяти вне границ"); } uint32_t value = 0; value |= static_cast<uint32_t>(memory[address]); value |= static_cast<uint32_t>(memory[address + 1]) << 8; value |= static_cast<uint32_t>(memory[address + 2]) << 16; value |= static_cast<uint32_t>(memory[address + 3]) << 24; return value; }

    // Метод load_program void Emulator::load_program(const std::vector<uint8_t>& program, size_t load_address, bool set_eip) { if (load_address + program.size() > memory.size()) { throw std::runtime_error("Размер программы превышает лимиты памяти"); } std::copy(program.begin(), program.end(), memory.begin() + load_address); if (set_eip) { regs.EIP = load_address; } }

    // Метод run void Emulator::run() { running = true; while (running) { try { std::cout << "EIP: 0x" << std::hex << regs.EIP << "\n"; std::cout << "ESP: 0x" << std::hex << regs.ESP << "\n";

            // Fetch prefixes
            bool prefix_present;
            do {
                prefix_present = false;
                uint8_t opcode = fetch_byte();
                
                switch (opcode) {
                case 0xF3:
                    regs.rep_prefix = true;
                    prefix_present = true;
                    break;
                    // Handle other prefixes similarly
                default:
                    // Opcode is not a prefix; adjust EIP back
                    regs.EIP--;
                    prefix_present = false;
                    break;
                }
            } while (prefix_present);
    
            // Fetch and print the opcode
            uint8_t opcode = fetch_byte();
            std::cout << "Opcode: 0x" << std::hex << (int)opcode << "\n";
            // Handle extended opcodes
            if (opcode == 0x0F) {
                opcode = fetch_byte();
                auto it = extended_instruction_set.find(opcode);
                if (it != extended_instruction_set.end()) {
                    InstructionHandler handler = it->second;
                    (this->*handler)();
                }
                else {
                    std::cout << "Unknown extended opcode: 0x0F 0x"
                        << std::hex << (int)opcode << "\n";
                    error_flag = true;
                    running = false;
                }
            }
            else {
                // Standard one-byte opcode
                auto it = instruction_set.find(opcode);
                if (it != instruction_set.end()) {
                    InstructionHandler handler = it->second;
                    (this->*handler)();
                }
                else {
                    std::cout << "Unknown opcode: 0x" << std::hex << (int)opcode << "\n";
                    error_flag = true;
                    running = false;
                }
            }
    
            // After executing the instruction, print register values
            print_registers(true);
            // Reset prefixes after instruction execution
            reset_prefixes();
    
        }
        catch (const std::exception& e) {
            std::cerr << "Exception caught: " << e.what() << "\n";
            error_flag = true;
            running = false;
        }
    }
    

    }

    void Emulator::reset_prefixes() { regs.lock_prefix = false; regs.rep_prefix = false; regs.repne_prefix = false; regs.operand_size_override = false; regs.address_size_override = false; // Сброс других префиксов при необходимости } void Emulator::reset_segment_override() { // Сброс текущих сегментов к стандартным значениям current_data_segment = &regs.DS; current_code_segment = &regs.CS; } // Метод print_registers void Emulator::print_registers(bool hex_output) const { if (hex_output) { std::cout << std::hex; std::cout << "EAX: 0x" << regs.EAX << "\n"; std::cout << "EBX: 0x" << regs.EBX << "\n"; std::cout << "ECX: 0x" << regs.ECX << "\n"; std::cout << "EDX: 0x" << regs.EDX << "\n"; std::cout << "ESI: 0x" << regs.ESI << "\n"; std::cout << "EDI: 0x" << regs.EDI << "\n"; std::cout << "ESP: 0x" << regs.ESP << "\n"; std::cout << "EBP: 0x" << regs.EBP << "\n"; std::cout << "EIP: 0x" << regs.EIP << "\n"; std::cout << "EFLAGS: 0x" << regs.EFLAGS << "\n"; std::cout << std::dec; // Возвращаемся к десятичной системе счисления } else { std::cout << "EAX: " << regs.EAX << "\n"; std::cout << "EBX: " << regs.EBX << "\n"; std::cout << "ECX: " << regs.ECX << "\n"; std::cout << "EDX: " << regs.EDX << "\n"; std::cout << "ESI: " << regs.ESI << "\n"; std::cout << "EDI: " << regs.EDI << "\n"; std::cout << "ESP: " << regs.ESP << "\n"; std::cout << "EBP: " << regs.EBP << "\n"; std::cout << "EIP: " << regs.EIP << "\n"; std::cout << "EFLAGS: " << regs.EFLAGS << "\n"; } }

    uint32_t Emulator::calculate_sib_address(uint8_t mod, uint8_t sib, int32_t displacement) { uint8_t scale = (sib >> 6) & 0x03; uint8_t index = (sib >> 3) & 0x07; uint8_t base = sib & 0x07;

    uint32_t base_value = 0;
    uint32_t index_value = 0;
    
    // Получаем значение base
    if (base == 5) {
        if (mod == 0) {
            // base = 0, disp32 используется вместо base
            base_value = 0;
            displacement += fetch_dword(); // Дополнительный disp32
        }
        else {
            base_value = *get_register_by_code(base);
        }
    }
    else {
        base_value = *get_register_by_code(base);
    }
    
    // Получаем значение index
    if (index != 4) { // Если index не равно 4 (4 означает, что index не используется)
        index_value = *get_register_by_code(index) << scale;
    }
    
    uint32_t address = base_value + index_value + displacement;
    return address;
    

    }

    uint32_t Emulator::calculate_address(uint8_t modrm) { uint8_t mod = (modrm >> 6) & 0x03; uint8_t rm = modrm & 0x07; //std::cout << "calculate_address called with mod=" << (int)mod << ", rm=" << (int)rm << "\n"; uint32_t address = 0;

    if (mod == 0) {
        if (rm == 5) {
            // [disp32]
            uint32_t disp32 = fetch_dword();
            address = disp32;
        }
        else if (rm == 4) {
            // SIB byte
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, 0);
        }
        else {
            // [reg]
            address = *get_register_by_code(rm);
        }
    }
    else if (mod == 1) {
        int8_t disp8 = static_cast<int8_t>(fetch_byte());
        if (rm == 4) {
            // SIB byte с disp8
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, disp8);
        }
        else {
            // [reg + disp8]
            address = *get_register_by_code(rm) + disp8;
        }
    }
    else if (mod == 2) {
        int32_t disp32 = static_cast<int32_t>(fetch_dword());
        if (rm == 4) {
            // SIB byte с disp32
            uint8_t sib = fetch_byte();
            address = calculate_sib_address(mod, sib, disp32);
        }
        else {
            // [reg + disp32]
            address = *get_register_by_code(rm) + disp32;
        }
    }
    else if (mod == 3) {
        // Mod == 3 indicates register-direct mode, address calculation is not applicable.
        std::cout << "Error: calculate_address() called with mod == 3 (register-direct mode) which is invalid for memory addressing.\n";
        error_flag = true;
        running = false;
        return 0;
    }
    else {
        std::cout << "Unsupported ModR/M mod value in calculate_address.\n";
        error_flag = true;
        running = false;
        return 0;
    }
    
    // Добавьте базу сегмента к вычисленному адресу
    // Для Data Segment
    address += *current_data_segment;
    
    if (address >= memory.size()) {
        std::cout << "Address out of bounds: 0x" << std::hex << address << "\n";
        error_flag = true;
        running = false;
    }
    
    return address;
    

    }

    // Инициализация таблицы инструкций void Emulator::initialize_instruction_set() { instruction_set[0xB8] = &Emulator::instr_MOV_EAX_imm32; instruction_set[0x20] = &Emulator::instr_AND_rm8_r8; instruction_set[0xC7] = &Emulator::instr_MOV_Ev_Iv; instruction_set[0x34] = &Emulator::instr_XOR_AL_imm8; instruction_set[0x50] = &Emulator::instr_PUSH_EAX; instruction_set[0x51] = &Emulator::instr_PUSH_ECX; instruction_set[0x52] = &Emulator::instr_PUSH_EDX; instruction_set[0x53] = &Emulator::instr_PUSH_EBX; instruction_set[0x54] = &Emulator::instr_PUSH_ESP; instruction_set[0x55] = &Emulator::instr_PUSH_EBP; instruction_set[0x56] = &Emulator::instr_PUSH_ESI; instruction_set[0x57] = &Emulator::instr_PUSH_EDI; instruction_set[0x6A] = &Emulator::instr_PUSH_imm8; instruction_set[0x58] = &Emulator::instr_POP_EAX; instruction_set[0x59] = &Emulator::instr_POP_ECX; instruction_set[0x5A] = &Emulator::instr_POP_EDX; instruction_set[0x5B] = &Emulator::instr_POP_EBX; instruction_set[0x5C] = &Emulator::instr_POP_ESP; instruction_set[0x5D] = &Emulator::instr_POP_EBP; instruction_set[0x5E] = &Emulator::instr_POP_ESI; instruction_set[0x5F] = &Emulator::instr_POP_EDI; instruction_set[0xB9] = &Emulator::instr_MOV_ECX_imm32; instruction_set[0xBA] = &Emulator::instr_MOV_EDX_imm32; instruction_set[0x05] = &Emulator::instr_ADD_EAX_imm32; instruction_set[0x2D] = &Emulator::instr_SUB_EAX_imm32; instruction_set[0x40] = &Emulator::instr_INC_EAX; instruction_set[0x48] = &Emulator::instr_DEC_EAX; instruction_set[0xF7] = &Emulator::instr_F7; instruction_set[0xE9] = &Emulator::instr_JMP_rel32; instruction_set[0x83] = &Emulator::instr_GROUP1_Ev_Iz_83; instruction_set[0x74] = &Emulator::instr_JE_rel8; instruction_set[0x75] = &Emulator::instr_JNE_rel8; instruction_set[0x25] = &Emulator::instr_AND_EAX_imm32; instruction_set[0x21] = &Emulator::instr_AND_ECX_imm32; instruction_set[0x0D] = &Emulator::instr_OR_EAX_imm32; instruction_set[0x35] = &Emulator::instr_XOR_EAX_imm32; instruction_set[0x81] = &Emulator::instr_GROUP1_Ev_Iz_81; instruction_set[0x3D] = &Emulator::instr_CMP_EAX_imm32; instruction_set[0x0E] = &Emulator::instr_OR_ECX_imm32; instruction_set[0xC3] = &Emulator::instr_RET; instruction_set[0xA3] = &Emulator::instr_MOV_MEM_EAX; instruction_set[0xA1] = &Emulator::instr_MOV_EAX_MEM; instruction_set[0xCD] = &Emulator::instr_INT; instruction_set[0x89] = &Emulator::instr_MOV_r32_rm32; instruction_set[0x31] = &Emulator::instr_XOR_r32_rm32; instruction_set[0x04] = &Emulator::instr_ADD_AL_imm8; instruction_set[0x88] = &Emulator::instr_MOV_rm8_r8; instruction_set[0xC6] = &Emulator::instr_MOV_rm8_imm8; instruction_set[0x39] = &Emulator::instr_CMP_r32_rm32; instruction_set[0x7F] = &Emulator::instr_JG_rel8; instruction_set[0x7C] = &Emulator::instr_JL_rel8;
    instruction_set[0x8A] = &Emulator::instr_MOV_r8_rm8; instruction_set[0x80] = &Emulator::instr_SUB_rm8_imm8; instruction_set[0xB7] = &Emulator::instr_MOV_r8_imm8; instruction_set[0x69] = &Emulator::instr_IMUL_reg_rm32_imm32; instruction_set[0x72] = &Emulator::instr_JB_rel8; instruction_set[0x77] = &Emulator::instr_JA_rel8; instruction_set[0x41] = &Emulator::instr_INC_ECX; instruction_set[0xEB] = &Emulator::instr_JMP_rel8; instruction_set[0x2C] = &Emulator::instr_SUB_AL_imm8; instruction_set[0x3C] = &Emulator::instr_CMP_AL_imm8; instruction_set[0x01] = &Emulator::instr_ADD_rm32_r32; instruction_set[0x03] = &Emulator::instr_ADD_r32_rm32; instruction_set[0x6B] = &Emulator::instr_IMUL_reg_rm32_imm8; instruction_set[0x8B] = &Emulator::instr_MOV_r32_r_m32; instruction_set[0xBB] = &Emulator::instr_MOV_EBX_imm32; instruction_set[0xBD] = &Emulator::instr_MOV_EBP_imm32; instruction_set[0xBC] = &Emulator::instr_MOV_ESP_imm32; instruction_set[0xBE] = &Emulator::instr_MOV_ESI_imm32; instruction_set[0xBF] = &Emulator::instr_MOV_EDI_imm32; instruction_set[0xE8] = &Emulator::instr_CALL_rel32; instruction_set[0x8D] = &Emulator::instr_LEA_r32_m; instruction_set[0xA4] = &Emulator::instr_MOVSB; instruction_set[0x5E] = &Emulator::instr_POP_ESI; instruction_set[0xFF] = &Emulator::instr_GROUP5; instruction_set[0x68] = &Emulator::instr_PUSH_imm32; instruction_set[0x00] = &Emulator::instr_ADD_rm8_r8; instruction_set[0xFC] = &Emulator::instr_CLD; instruction_set[0x90] = &Emulator::instr_NOP; instruction_set[0xFD] = &Emulator::instr_STD; instruction_set[0x60] = &Emulator::instr_PUSHAD; instruction_set[0x5D] = &Emulator::instr_POP_EBP; instruction_set[0xFB] = &Emulator::instr_STI; instruction_set[0xC9] = &Emulator::instr_LEAVE; instruction_set[0x85] = &Emulator::instr_TEST_rm32_r32; extended_instruction_set[0x84] = &Emulator::instr_JE_rel32; extended_instruction_set[0x85] = &Emulator::instr_JNE_rel32; extended_instruction_set[0x8F] = &Emulator::instr_JG_rel32; extended_instruction_set[0x8C] = &Emulator::instr_JL_rel32; extended_instruction_set[0x1E] = &Emulator::instr_ENDBR32;
    } void Emulator::initialize_stack() { // Set stack top a bit below the end of memory uint32_t stack_top = memory.size() - 16;

    // Let's assume argc = 0 for simplicity
    uint32_t argc = 0;
    
    // Set up the initial stack:
    // [ESP + 0]: argc (0)
    // [ESP + 4]: null pointer (argv terminator)
    // [ESP + 8]: null pointer (envp terminator)
    
    regs.ESP = stack_top - 12; // Move ESP to leave space for 3 values
    
    // Push envp terminator (null pointer)
    write_memory_dword(regs.ESP + 8, 0);
    
    // Push argv terminator (null pointer)
    write_memory_dword(regs.ESP + 4, 0);
    
    // Push argc (0)
    write_memory_dword(regs.ESP + 0, argc);
    
    // Optionally, you can show what's on the stack now for debugging
    std::cout << "Stack initialized with argc and null terminators.\n";
    

    } Emulator::Operand Emulator::decode_operand(uint8_t modrm) { Operand operand; uint8_t mod = (modrm >> 6) & 0x03; uint8_t rm = modrm & 0x07;

    if (mod == 3) { // Регистр-режим
        operand.is_memory = false;
        operand.register_code = rm;
    }
    else { // Память
        operand.is_memory = true;
        operand.address = calculate_address(modrm);
    }
    
    return operand;
    

    } void Emulator::instr_IMUL_reg_rm32_imm8() { // Fetch ModRM byte uint8_t modrm = fetch_byte(); uint8_t mod = modrm >> 6; uint8_t reg_code = (modrm >> 3) & 0x07; // Destination register uint8_t rm_code = modrm & 0x07; // Source operand

    uint32_t* dest_reg = get_register_by_code(reg_code);
    uint32_t operand = 0;
    
    // Determine the operand based on addressing mode
    if (mod == 3) { // Register-direct mode
        uint32_t* src_reg = get_register_by_code(rm_code);
        if (!src_reg) {
            std::cout << "Unknown source register in IMUL.\n";
            error_flag = true;
            running = false;
            return;
        }
        operand = *src_reg;
    }
    else {
        // For simplicity, handle only register-direct mode
        std::cout << "Unsupported addressing mode in IMUL.\n";
        error_flag = true;
        running = false;
        return;
    }
    
    // Fetch immediate 8-bit value
    int8_t imm8 = static_cast<int8_t>(fetch_byte());
    
    // Perform multiplication
    int32_t result = static_cast<int32_t>(operand) * imm8;
    *dest_reg = static_cast<uint32_t>(result);
    
    // Update flags as necessary
    update_ZF(*dest_reg);
    // Update other flags (CF, OF) if necessary
    

    } void Emulator::write_memory_byte(uint32_t address, uint8_t value) { if (address >= memory.size()) { std::cerr << "Ошибка: Пытаетесь записать byte за пределы памяти. Адрес: 0x" << std::hex << address << std::dec << "\n"; error_flag = true; // Устанавливаем флаг ошибки running = false; // Останавливаем выполнение эмулятора return; } memory[address] = value; // Записываем байт в память } void Emulator::write_memory_dword(uint32_t address, uint32_t value) { if (address + 4 > memory.size()) { std::cerr << "Ошибка: Память для записи dword выходит за пределы. Адрес: 0x" << std::hex << address << "\n"; error_flag = true; running = false; return; } memory[address] = value & 0xFF; memory[address + 1] = (value >> 8) & 0xFF; memory[address + 2] = (value >> 16) & 0xFF; memory[address + 3] = (value >> 24) & 0xFF; }

    // Обновление Zero Flag (ZF) void Emulator::update_ZF(uint32_t result) { if (result == 0) regs.EFLAGS |= ZF; else regs.EFLAGS &= ~ZF; }

    // Вспомогательные методы

    uint8_t Emulator::fetch_byte() { if (regs.EIP >= memory.size()) { throw std::runtime_error("EIP вне границ памяти"); } return memory[regs.EIP++]; }

    // Реализация fetch_dword с проверкой увеличения EIP uint32_t Emulator::fetch_dword() { if (regs.EIP + 4 > memory.size()) { throw std::runtime_error("EIP вне границ памяти для загрузки dword"); } uint32_t value = 0; // x86 uses little endian value = static_cast<uint32_t>(memory[regs.EIP]) | (static_cast<uint32_t>(memory[regs.EIP + 1]) << 8) | (static_cast<uint32_t>(memory[regs.EIP + 2]) << 16) | (static_cast<uint32_t>(memory[regs.EIP + 3]) << 24);

    regs.EIP += 4;
    
    return value;
    

    }

    uint32_t* Emulator::get_register_by_code(uint8_t code) { switch (code) { case 0: return &regs.EAX; case 1: return &regs.ECX; case 2: return &regs.EDX; case 3: return &regs.EBX; case 4: return &regs.ESP; case 5: return &regs.EBP; case 6: return &regs.ESI; case 7: return &regs.EDI; default: return nullptr; } }

    uint8_t* Emulator::get_register8_by_code(uint8_t code) { switch (code) { case 0: return reinterpret_cast<uint8_t*>(&regs.EAX); // AL case 1: return reinterpret_cast<uint8_t*>(&regs.ECX); // CL case 2: return reinterpret_cast<uint8_t*>(&regs.EDX); // DL case 3: return reinterpret_cast<uint8_t*>(&regs.EBX); // BL case 4: return reinterpret_cast<uint8_t*>(&regs.EAX) + 1; // AH case 5: return reinterpret_cast<uint8_t*>(&regs.ECX) + 1; // CH case 6: return reinterpret_cast<uint8_t*>(&regs.EDX) + 1; // DH case 7: return reinterpret_cast<uint8_t*>(&regs.EBX) + 1; // BH default: return nullptr; } }

    uint8_t Emulator::regm_rm(uint8_t modrm) { return modrm & 0x07; // Извлекаем регистровый код (rm) }

    C:\Users\Swed\source\repos\x86_Emulator\x64\Debug>x86_Emulator.exe main3.elf

    Запуск программы из файла: main3.elf... Stack initialized with argc and null terminators. Объем выделенной памяти эмулятора: 1 MB ELF-файл успешно загружен. Точка входа: 0x1060 EIP: 0x1060 ESP: 0xfffe4 Opcode: 0xf ENDBR32 instruction executed (treated as NOP). EAX: 0x0 EBX: 0x0 ECX: 0x0 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffe4 EBP: 0x0 EIP: 0x1064 EFLAGS: 0x0 EIP: 0x1064 ESP: 0xfffe4 Opcode: 0x31 EAX: 0x0 EBX: 0x0 ECX: 0x0 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffe4 EBP: 0x0 EIP: 0x1066 EFLAGS: 0x40 EIP: 0x1066 ESP: 0xfffe4 Opcode: 0x5e Выполнен POP ESI. Значение в регистре ESI: 0 EAX: 0x0 EBX: 0x0 ECX: 0x0 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffe8 EBP: 0x0 EIP: 0x1067 EFLAGS: 0x40 EIP: 0x1067 ESP: 0xfffe8 Opcode: 0x89 EAX: 0x0 EBX: 0x0 ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffe8 EBP: 0x0 EIP: 0x1069 EFLAGS: 0x40 EIP: 0x1069 ESP: 0xfffe8 Opcode: 0x83 EAX: 0x0 EBX: 0x0 ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffe0 EBP: 0x0 EIP: 0x106c EFLAGS: 0x0 EIP: 0x106c ESP: 0xfffe0 Opcode: 0x50 EAX: 0x0 EBX: 0x0 ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffdc EBP: 0x0 EIP: 0x106d EFLAGS: 0x0 EIP: 0x106d ESP: 0xfffdc Opcode: 0x54 EAX: 0x0 EBX: 0x0 ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffd8 EBP: 0x0 EIP: 0x106e EFLAGS: 0x0 EIP: 0x106e ESP: 0xfffd8 Opcode: 0x52 EAX: 0x0 EBX: 0x0 ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffd4 EBP: 0x0 EIP: 0x106f EFLAGS: 0x0 EIP: 0x106f ESP: 0xfffd4 Opcode: 0xe8 EAX: 0x0 EBX: 0x0 ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffd0 EBP: 0x0 EIP: 0x108c EFLAGS: 0x0 EIP: 0x108c ESP: 0xfffd0 Opcode: 0x8b EAX: 0x0 EBX: 0x1074 ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffd0 EBP: 0x0 EIP: 0x108f EFLAGS: 0x0 EIP: 0x108f ESP: 0xfffd0 Opcode: 0xc3 EAX: 0x0 EBX: 0x1074 ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffd4 EBP: 0x0 EIP: 0x1074 EFLAGS: 0x0 EIP: 0x1074 ESP: 0xfffd4 Opcode: 0x81 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffd4 EBP: 0x0 EIP: 0x107a EFLAGS: 0x0 EIP: 0x107a ESP: 0xfffd4 Opcode: 0x6a EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffd0 EBP: 0x0 EIP: 0x107c EFLAGS: 0x0 EIP: 0x107c ESP: 0xfffd0 Opcode: 0x6a EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffcc EBP: 0x0 EIP: 0x107e EFLAGS: 0x0 EIP: 0x107e ESP: 0xfffcc Opcode: 0x51 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffc8 EBP: 0x0 EIP: 0x107f EFLAGS: 0x0 EIP: 0x107f ESP: 0xfffc8 Opcode: 0x56 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffc4 EBP: 0x0 EIP: 0x1080 EFLAGS: 0x0 EIP: 0x1080 ESP: 0xfffc4 Opcode: 0xff EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffc0 EBP: 0x0 EIP: 0x1086 EFLAGS: 0x0 EIP: 0x1086 ESP: 0xfffc0 Opcode: 0xe8 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffbc EBP: 0x0 EIP: 0x1040 EFLAGS: 0x0 EIP: 0x1040 ESP: 0xfffbc Opcode: 0xff EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffbc EBP: 0x0 EIP: 0x1046 EFLAGS: 0x0 EIP: 0x1046 ESP: 0xfffbc Opcode: 0x68 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb8 EBP: 0x0 EIP: 0x104b EFLAGS: 0x0 EIP: 0x104b ESP: 0xfffb8 Opcode: 0xe9 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb8 EBP: 0x0 EIP: 0x1030 EFLAGS: 0x0 EIP: 0x1030 ESP: 0xfffb8 Opcode: 0xff EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x1036 EFLAGS: 0x0 EIP: 0x1036 ESP: 0xfffb4 Opcode: 0xff EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x0 EFLAGS: 0x0 EIP: 0x0 ESP: 0xfffb4 Opcode: 0x7f EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x47 EFLAGS: 0x0 EIP: 0x47 ESP: 0xfffb4 Opcode: 0x0 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x4a EFLAGS: 0x0 EIP: 0x4a ESP: 0xfffb4 Opcode: 0x0 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x4c EFLAGS: 0x0 EIP: 0x4c ESP: 0xfffb4 Opcode: 0x4 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x4e EFLAGS: 0x40 EIP: 0x4e ESP: 0xfffb4 Opcode: 0x0 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x50 EFLAGS: 0x0 EIP: 0x50 ESP: 0xfffb4 Opcode: 0x4 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x52 EFLAGS: 0x40 EIP: 0x52 ESP: 0xfffb4 Opcode: 0x0 EAX: 0x0 EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x54 EFLAGS: 0x0 EIP: 0x54 ESP: 0xfffb4 Opcode: 0x3 EAX: 0x464c457f EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x56 EFLAGS: 0x0 EIP: 0x56 ESP: 0xfffb4 Opcode: 0x0 Address out of bounds: 0x464c457f EAX: 0x464c457f EBX: 0x3fdc ECX: 0xfffe8 EDX: 0x0 ESI: 0x0 EDI: 0x0 ESP: 0xfffb4 EBP: 0x0 EIP: 0x58 EFLAGS: 0x0

    Программа из ELF-файла не выполнена.

  2. Assistant

    Здравствуйте!

    Ваш эмулятор пытается обратиться к адресу памяти 0x464c457f, что выходит за пределы выделенной памяти (1 МБ). Этот адрес соответствует магическому числу ELF-файлов (0x7F 'E' 'L' 'F' в little-endian формате). Это означает, что эмулятор пытается выполнить инструкции или данные из заголовка ELF, что вызывает ошибку "Address out of bounds".

    Давайте разберём возможные причины и шаги по устранению этой проблемы.

    1. Неправильная загрузка ELF-файла

    Проблема:
    Функция load_elf, вероятно, не корректно загружает сегменты ELF-файла в память эмулятора. Это приводит к тому, что сегмент кода или данных перекрывается с областью заголовка ELF, что вызывает неверные адреса при выполнении инструкций.

    Решение:
    Убедитесь, что функция load_elf:

    • Правильно парсит ELF-файл, корректно обрабатывая виртуальные адреса из программных заголовков (Program Headers).
    • Загружает сегменты (.text, .data и т.д.) в соответствующие области памяти эмулятора.
    • Корректно устанавливает EIP (указатель инструкций) на точку входа из ELF-файла.

    Что проверить:

    • Виртуальные адреса: Убедитесь, что виртуальные адреса сегментов ELF корректно маппируются в линейную память эмулятора.
    • Размер памяти: При эмуляции важных сегментов (например, 0x400000 для Linux ELF) убедитесь, что выделенная память достаточно велика или используется корректная маппинговая логика.

    2. Некорректная обработка инструкций CALL и RET

    Проблема:
    Инструкции CALL и RET работают с указателями на возврат. Если CALL некорректно сохраняет адрес возврата, RET будет пытаться перейти по неверному адресу, что и вызывает ошибку.

    Решение:
    Проверьте реализацию инструкций CALL и RET:

    • CALL rel32:

      • Должен сохранять адрес следующей инструкции (адрес после CALL) в стек.
      • Затем корректно вычислять и устанавливать новый EIP с учётом относительного смещения.
    • RET:

      • Должен извлекать адрес возврата из стека и устанавливать EIP на этот адрес.

    Ваш Код:

    // Реализация инструкции CALL r/m32
    void Emulator::instr_CALL_rm32(uint8_t modrm) {
        Operand operand = decode_operand(modrm);
        uint32_t address = operand.is_memory ? read_memory_dword(operand.address) : *get_register_by_code(operand.register_code);
    
        // Сохраняем текущий адрес возврата в стек
        push(regs.EIP);
    
        // Переходим к новому адресу
        regs.EIP = address;
    }
    
    // Обработчик инструкции RET
    void Emulator::instr_RET() {
        if (regs.ESP + 4 > memory.size()) {
            std::cout << "Stack underflow on RET.\n";
            error_flag = true;
            running = false;
            return;
        }
    
        // Pop the return address from the stack
        uint32_t return_address = read_memory_dword(regs.ESP);
        regs.ESP += 4;
    
        // Jump to the return address
        regs.EIP = return_address;
    }
    

    Возможные Ошибки:

    • Порядок операций: Убедитесь, что regs.EIP корректно указывает на следующую инструкцию перед вызовом push(regs.EIP).
    • Размер данных: push и pop работают с 32-битными значениями. Удостоверьтесь, что EIP и адреса корректно работают в 32-битном пространстве.

    3. Инициализация и управление стеком

    Проблема:
    Инициализация стека может быть некорректной, что приводит к перезаписи важных данных или неправильному управлению адресами.

    Решение:
    Проверьте метод initialize_stack:

    • Убедитесь, что ESP правильно устанавливается и не пересекается с загруженными сегментами ELF.
    • Убедитесь, что начальные значения стека правильные и соответствуют ожиданиям программы.

    Ваш Код:

    void Emulator::initialize_stack() {
        // Set stack top a bit below the end of memory
        uint32_t stack_top = memory.size() - 16;
    
        // Let's assume argc = 0 for simplicity
        uint32_t argc = 0;
    
        // Set up the initial stack:
        // [ESP + 0]: argc (0)
        // [ESP + 4]: null pointer (argv terminator)
        // [ESP + 8]: null pointer (envp terminator)
    
        regs.ESP = stack_top - 12; // Move ESP to leave space for 3 values
    
        // Push envp terminator (null pointer)
        write_memory_dword(regs.ESP + 8, 0);
    
        // Push argv terminator (null pointer)
        write_memory_dword(regs.ESP + 4, 0);
    
        // Push argc (0)
        write_memory_dword(regs.ESP + 0, argc);
    
        // Optionally, you can show what's on the stack now for debugging
        std::cout << "Stack initialized with argc and null terminators.\n";
    }
    

    Возможные Ошибки:

    • Переполнение стека: Убедитесь, что ESP не выходит за границы выделенной памяти.
    • Неверные начальные значения: Проверьте, что начальные значения (argc, argv, envp) корректны и соответствуют ожидаемой программе.

    4. Отладка и Дополнительные Логи

    Решение:
    Для более детальной отладки можно добавить дополнительные логи в критических точках:

    • Загрузка ELF:

      • Логируйте адреса сегментов, места загрузки и точку входа.
      • Убедитесь, что загруженные данные корректны и согласно структуре ELF.
    • Инструкции CALL и RET:

      • Логируйте адреса, которые сохраняются и извлекаются из стека.
      • Убедитесь, что EIP корректно обновляется после CALL и RET.
    • Управление стеком:

      • Логируйте изменения ESP при операциях push и pop.
      • Проверьте, не переполняется ли стек и не происходит ли перезапись важных данных.

    Пример Добавления Логов:

    void Emulator::push(uint32_t value) {
        if (regs.ESP < 4) {
            std::cerr << "Stack overflow при попытке записать в стек.\n";
            error_flag = true;
            running = false;
            return;
        }
        regs.ESP -= 4;  // Уменьшаем указатель стека
        write_memory_dword(regs.ESP, value);  // Записываем значение в стек
    
        std::cout << "PUSH: " << std::hex << value << " -> ESP: 0x" << regs.ESP << "\n";
    }
    
    void Emulator::instr_CALL_rel32() {
        int32_t rel = fetch_dword();
        std::cout << "CALL: rel32 = " << std::dec << rel << "\n";
        std::cout << "EIP before CALL: 0x" << std::hex << regs.EIP << "\n";
    
        // Сохраняем текущий адрес возврата в стек
        push(regs.EIP);
    
        // Переходим к новому адресу
        regs.EIP += rel;
    
        std::cout << "EIP after CALL: 0x" << std::hex << regs.EIP << "\n";
    }
    
    void Emulator::instr_RET() {
        if (regs.ESP + 4 > memory.size()) {
            std::cout << "Stack underflow on RET.\n";
            error_flag = true;
            running = false;
            return;
        }
    
        // Pop the return address from the stack
        uint32_t return_address = read_memory_dword(regs.ESP);
        regs.ESP += 4;
    
        std::cout << "RET: return_address = 0x" << std::hex << return_address << "\n";
    
        // Jump to the return address
        regs.EIP = return_address;
    
        std::cout << "EIP set to return_address: 0x" << std::hex << regs.EIP << "\n";
    }
    

    5. Проверка Реализации Инструкций

    Проблема:
    Некорректная реализация некоторых инструкций может привести к неправильному изменению регистров или флагов, что влияет на дальнейшее выполнение программы.

    Решение:

    • Проверьте все реализованные инструкции: Убедитесь, что все инструкции, используемые в вашем ELF-файле, корректно реализованы.
    • Особенно внимательно: Инструкции управления потоком (JMP, CALL, RET), арифметические (ADD, SUB, MUL, DIV) и логические (AND, OR, XOR).
    • Тестируйте пошагово: Попробуйте создавать и запускать простые тестовые ELF-программы, чтобы проверить каждую инструкцию отдельно.

    6. Пример Упрощённой Загрузки ELF

    Если load_elf не реализована корректно, можно временно использовать упрощённый способ загрузки:

    • Извлеките необходимые сегменты вручную: Например, загрузите .text сегмент с начальной точки в память эмулятора.
    • Установите EIP на начало загруженного кода.
    bool run_program_from_elf(const std::string& filename) {
        Emulator emulator(1024 * 1024 * 1024); // 1 GB память
    
        // Упрощённая загрузка ELF (предполагается, что функция существует)
        bool load_result = load_elf_simplified(filename, emulator);
        if (!load_result) {
            std::cerr << "Ошибка: Не удалось загрузить ELF-файл.\n";
            return false;
        }
    
        // Запуск эмулятора
        emulator.run();
    
        // Проверка на ошибки
        return !emulator.has_error();
    }
    

    Важно:
    Это лишь временное решение для отладки. Настоящая загрузка ELF должна учитывать виртуальные адреса и правильное маппирование сегментов.

    Заключение

    Ваш эмулятор сталкивается с ошибкой из-за некорректного перехода по адресу, связанному с магическим числом ELF-файла. Основные шаги по устранению включают:

    1. Проверку функции загрузки ELF: Убедитесь, что все сегменты загружаются правильно и соответствуют ожидаемым адресам.
    2. Отладку инструкций CALL и RET: Убедитесь, что адреса возврата корректно сохраняются и извлекаются из стека.
    3. Добавление дополнительных логов: Это поможет выявить, на каком именно этапе происходит ошибка.
    4. Тестирование с простыми программами: Начните с самых простых ELF-программ, чтобы постепенно отлаживать функциональность эмулятора.

    Также рекомендую ознакомиться с документацией по формату ELF и аналогичными проектами эмуляторов для более глубокого понимания процесса. Если возникнут дополнительные вопросы или нужна помощь с конкретными частями кода, не стесняйтесь обращаться!

    Удачи в разработке эмулятора!