创建32位虚拟机的题解
原题链接：1.A+B problem
2026-03-23 15:21:04
发布于：江苏
3阅读
0回复
0点赞
#include <cstdint>
#include <vector>
#include <array>
#include <iostream>
#include <stdexcept>
class VM32 {
public:
using u32 = uint32_t;
using i32 = int32_t;
enum Registers {
EAX, EBX, ECX, EDX,
ESP, EIP,
REG_COUNT
};
enum OpCode : u32 {
HALT = 0x00000000,
MOV_REG = 0x01000000,
MOV_MEM = 0x02000000,
MOV_IMM = 0x03000000,
ADD_REG = 0x04000000,
SUB_REG = 0x05000000,
MUL_REG = 0x06000000,
DIV_REG = 0x07000000,
PUSH = 0x08000000,
POP = 0x09000000,
JMP = 0x0A000000,
IN = 0x0B000000,
OUT = 0x0C000000,
STR_MEM = 0x0D000000,
LDR_MEM = 0x0E000000
};
static constexpr size_t MEM_SIZE = 16 * 1024 * 1024;
VM32() {
registers.fill(0);
registers[ESP] = MEM_SIZE - 4;
memory.resize(MEM_SIZE, 0);
}
void load_program(const std::vector<u32>& program, size_t size) {
if (size > memory.size()) {
throw std::runtime_error("Program too large");
}
for (size_t i = 0; i < size; ++i) {
memory[i] = program[i];
}
}
void run() {
while (true) {
u32 eip = registers[EIP];
if (eip >= memory.size()) {
throw std::runtime_error("EIP out of bounds");
}
u32 instruction = memory[eip];
registers[EIP] += 1;
u32 op = instruction & 0xFF000000;
u32 args = instruction & 0x00FFFFFF;
switch (op) {
case HALT:
return;
case MOV_REG: {
u32 src_reg = (args >> 16) & 0xFF;
u32 dst_reg = args & 0xFF;
if (src_reg >= REG_COUNT || dst_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
registers[dst_reg] = registers[src_reg];
break;
}
case MOV_IMM: {
u32 dst_reg = args & 0xFF;
if (dst_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
u32 imm = memory[registers[EIP]];
registers[EIP] += 1;
registers[dst_reg] = imm;
break;
}
case ADD_REG: {
u32 src_reg = (args >> 16) & 0xFF;
u32 dst_reg = args & 0xFF;
if (src_reg >= REG_COUNT || dst_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
registers[dst_reg] += registers[src_reg];
break;
}
case SUB_REG: {
u32 src_reg = (args >> 16) & 0xFF;
u32 dst_reg = args & 0xFF;
if (src_reg >= REG_COUNT || dst_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
registers[dst_reg] -= registers[src_reg];
break;
}
case MUL_REG: {
u32 src_reg = (args >> 16) & 0xFF;
u32 dst_reg = args & 0xFF;
if (src_reg >= REG_COUNT || dst_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
registers[dst_reg] *= registers[src_reg];
break;
}
case DIV_REG: {
u32 src_reg = (args >> 16) & 0xFF;
u32 dst_reg = args & 0xFF;
if (src_reg >= REG_COUNT || dst_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
if (registers[src_reg] == 0) {
throw std::runtime_error("Divide by zero");
}
registers[dst_reg] /= registers[src_reg];
break;
}
case PUSH: {
u32 reg = args & 0xFF;
if (reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
registers[ESP] -= 4;
memory[registers[ESP]] = registers[reg];
break;
}
case POP: {
u32 reg = args & 0xFF;
if (reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
registers[reg] = memory[registers[ESP]];
registers[ESP] += 4;
break;
}
case JMP: {
u32 target_addr = memory[registers[EIP]];
registers[EIP] = target_addr;
break;
}
case IN: {
u32 dst_reg = args & 0xFF;
if (dst_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
u32 input_val;
std::cin >> input_val;
registers[dst_reg] = input_val;
break;
}
case OUT: {
u32 src_reg = args & 0xFF;
if (src_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
std::cout << registers[src_reg] << std::endl;
break;
}
case STR_MEM: {
u32 src_reg = (args >> 16) & 0xFF;
if (src_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
u32 mem_addr = memory[registers[EIP]];
registers[EIP] += 1;
if (mem_addr >= memory.size()) {
throw std::runtime_error("Mem out of bounds");
}
memory[mem_addr] = registers[src_reg];
break;
}
case LDR_MEM: {
u32 dst_reg = (args >> 16) & 0xFF;
if (dst_reg >= REG_COUNT) {
throw std::runtime_error("Invalid reg");
}
u32 mem_addr = memory[registers[EIP]];
registers[EIP] += 1;
if (mem_addr >= memory.size()) {
throw std::runtime_error("Mem out of bounds");
}
registers[dst_reg] = memory[mem_addr];
break;
}
default:
throw std::runtime_error("Invalid opcode: " + std::to_string(op));
}
}
}
private:
std::array<u32, REG_COUNT> registers;
std::vector<u32> memory;
};
int main() {
try {
VM32 vm;
std::vector<VM32::u32> program = {
0x0B000000 | VM32::EAX,
0x0B000000 | VM32::EBX,
0x04000000 | (VM32::EBX << 16) | VM32::EAX,
0x0C000000 | VM32::EAX,
0x00000000
};
vm.load_program(program, 5);
vm.run();
} catch (const std::exception& e) {
std::cerr << "虚拟机错误：" << e.what() << std::endl;
return 1;
}
return 0;
}
这里空空如也
有帮助，赞一个