Вопросы, касающиеся реализации простого эмулятора ЦП

Разберите исходный код в массив целых чисел. Этот массив является памятью вашего компьютера.

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

unsigned int x = 0xfeed;
unsigned int opcode = (x >> 12) & 0xf;

извлечет верхние четыре бита (здесь 0xf) из 16-битного значения, хранящегося в unsigned int. Затем вы можете использовать, например. switch(), чтобы проверить код операции и предпринять соответствующие действия:

enum { ADD = 0 };

unsigned int execute(int *memory, unsigned int pc)
{
  const unsigned int opcode = (memory[pc++] >> 12) & 0xf;

  switch(opcode)
  {
  case OP_ADD:
    /* Do whatever the ADD instruction's definition mandates. */
    return pc;
  default:
    fprintf(stderr, "** Non-implemented opcode %x found in location %x\n", opcode, pc - 1);
  }
  return pc;
}

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

Я думаю, что лучший подход - прочитать инструкции, преобразовать их в целые числа без знака и сохранить их в памяти, а затем выполнить их из памяти.

1. После того, как вы проанализировали инструкции и сохранили их в памяти, самостоятельная модификация намного проще, чем сохранение списка изменений для каждой инструкции. Вы можете просто изменить память в этом месте (при условии, что вам никогда не нужно знать, какой была старая инструкция).

2. Поскольку вы конвертируете инструкции в целые числа, эта проблема неактуальна.

3. Чтобы разобрать разделы кода операции и операнда, вам нужно будет использовать сдвиг битов и маскирование. Например, чтобы получить код операции, вы маскируете верхние 4 бита и выполняете сдвиг вниз на 12 бит (instruction >> 12). Вы также можете использовать маску для получения операнда.

4. Вы имеете в виду, что в вашей машине есть инструкции, которые сдвигают биты? Это не должно влиять на то, как вы храните операнды. Когда вы приступите к выполнению одной из этих инструкций, вы можете просто использовать операторы битового сдвига C++ << и >>.

На всякий случай, вот последний эмулятор процессора, который я написал на C++. На самом деле, это единственный эмулятор, который я написал на C++.

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

http://www.boundvariable.org/um-spec.txt

Вот мой (несколько переработанный) код, который должен дать вам некоторые идеи. Например, он показывает, как реализовать математические операторы в выражении Giant Switch в um.cpp:

http://www.eschatonic.org/misc/um.zip

Возможно, вы сможете найти другие реализации для сравнения с веб-поиском, так как в конкурсе участвовало много людей (я не был одним из них: я сделал это намного позже). Хотя, я думаю, не так много на С++.

На вашем месте я бы для начала сохранил инструкции только в виде строк, если так спецификация вашей виртуальной машины определяет операции с ними. Затем преобразуйте их в целые числа по мере необходимости каждый раз, когда вы хотите их выполнить. Это будет медленно, ну и что? У вас не настоящая виртуальная машина, которую вы собираетесь использовать для запуска критичных ко времени программ, и очень медленный интерпретатор по-прежнему иллюстрирует важные моменты, которые вам необходимо знать на данном этапе.

Однако возможно, что виртуальная машина на самом деле определяет все в терминах целых чисел, а строки нужны только для описания программы, когда она загружается в машину. В этом случае сначала преобразуйте программу в целые числа. Если виртуальная машина хранит программы и данные вместе, и на них воздействуют одни и те же операции, то это правильный путь.

Чтобы выбрать между ними, нужно посмотреть код операции, который используется для изменения программы. Подается ли ему новая инструкция как целое число или как строка? Что бы это ни было, проще всего начать с сохранения программы в этом формате. Вы всегда можете изменить позже, как только он заработает.

В случае описанной выше единой системы обмена сообщениями машина определяется в терминах «пластин» с пространством для 32 бит. Ясно, что они могут быть представлены в C++ как 32-битные целые числа, что и делает моя реализация.

Я создал эмулятор для собственного криптографического процессора. Я использовал полиморфизм C++, создав дерево базовых классов:

struct Instruction  // Contains common methods & data to all instructions.
{
    virtual void execute(void) = 0;
    virtual size_t get_instruction_size(void) const = 0;
    virtual unsigned int get_opcode(void) const = 0;
    virtual const std::string& get_instruction_name(void) = 0;
};

class Math_Instruction
:  public Instruction
{
  // Operations common to all math instructions;
};

class Branch_Instruction
:  public Instruction
{
  // Operations common to all branch instructions;
};

class Add_Instruction
:  public Math_Instruction
{
};

У меня также было несколько заводов. Было бы полезно как минимум два:

1. Фабрика для создания инструкции из текста.
2. Фабрика для создания инструкции из кода операции

Классы инструкций должны иметь методы для загрузки своих данных из источника ввода (например, std::istream) или текста (std::string). Также должны поддерживаться сопутствующие методы вывода (например, имя инструкции и код операции).

Я заставил приложение создавать объекты из входного файла и помещать их в вектор Instruction. Метод executor будет запускать метод 'execute()` каждой инструкции в массиве. Это действие просочилось к объекту-листу инструкции, который выполнил детальное выполнение.

Существуют и другие глобальные объекты, которые также могут нуждаться в эмуляции. В моем случае некоторые включали шину данных, регистры, АЛУ и ячейки памяти.

Пожалуйста, потратьте больше времени на проектирование и обдумывание проекта, прежде чем писать код. Я нашел это довольно сложной задачей, особенно реализовать отладчик с поддержкой single-step и графический интерфейс.

Удачи!