[#8 #10] feature: implemented nop, loading files to memory

src/basicComponents/Memory.h

@@ -2,6 +2,8 @@
 
 #include <cstdint>
 #include <vector>
+#include <fstream>
+#include <iostream>
 
 #include <utility/Widths.h>
 #include <Register.h>
@@ -21,6 +23,20 @@ class Memory {
         bytes.resize(size);
     }
 
+    Memory(const std::string& filename, std::size_t memsize){
+        std::ifstream input(filename, std::ios::binary);
+        if(!input.is_open()){
+            std::cerr << "can't read file " << filename << std::endl;
+            return;
+        }
+        bytes = std::vector<Byte>(
+            (std::istreambuf_iterator<char>(input)), 
+            std::istreambuf_iterator<char>());
+        if(bytes.size() < memsize){
+            bytes.resize(memsize);
+        }
+    }
+
     Memory(const std::vector<Byte> bytes) : bytes(bytes) {};
 
     template<typename WIDTH_T> 

src/instructions/nop.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <util/InstructionIfc.h>
+#include <basicComponents/Memory.h>
+#include <basicComponents/Cpu.h>
+#include <util/register_code.h>
+
+#include <iostream>
+
+
+class Nop : public InstructionIfc {
+    using InstructionIfc::InstructionIfc;
+
+    std::string mnemonic() const override {
+        return "NOP";
+    }
+    void fetch() override {
+
+    }
+    uint32_t size() const override {
+        return 1;
+    }
+    void callback() const override {
+        std::cout << mnemonic() << std::endl;
+    }
+};
+
+template<>
+inline bool InstructionBuilder<Nop>::isInstruction(Byte opcode){
+    return opcode == 0x90;
+}

src/instructions/util/InstructionsRegistry.cpp

@@ -3,6 +3,7 @@
 #include <sub.h>
 #include <push.h>
 #include <mov.h>
+#include <nop.h>
 
 InstructionRegistry::InstructionRegistry() {
     initializeInstructionModules();
@@ -13,6 +14,7 @@ void InstructionRegistry::initializeInstructionModules() {
     addInstruction<Sub>();
     addInstruction<Push>();
     addInstruction<Mov>();
+    addInstruction<Nop>();
 }
 
 const std::vector<std::unique_ptr<InstructionIfcBuilder>>& InstructionRegistry::getInstructionRegistryVector() const {

test/asm/noops.asm

@@ -0,0 +1,3 @@
+nop
+nop
+nop

test/binary_runner.cpp

@@ -12,3 +12,14 @@ TEST(BinaryRunnerTest, testBinaryRunner){
     runner.run(numTicks);
     ASSERT_EQ(runner.cpu.getTickCounter(), numTicks);
 }
+
+TEST(BinaryRunnerTest ,testBinaryRunnerNoops){
+    BinaryRunner runner("../../test/data/compiled/noops");
+    auto eaxBefore = runner.cpu.eax.get<Dword>();
+    runner.cpu.cs.set<Word>(0);
+    runner.run(3);
+    EXPECT_EQ(eaxBefore, runner.cpu.eax.get<Dword>());
+    EXPECT_EQ(runner.memory.read<Byte>(0x0), 0x90);
+    EXPECT_EQ(runner.memory.read<Byte>(0x0), 0x90);
+    EXPECT_EQ(runner.memory.read<Byte>(0x0), 0x90);
+}

test/data/compiled/example_hex_file

@@ -0,0 +1 @@
+abcdef

test/data/compiled/noops

@@ -0,0 +1 @@
+���

test/memory.cpp

@@ -1,9 +1,19 @@
 #include <gtest/gtest.h>
+#include <filesystem>
 
 #include <basicComponents/Memory.h>
 
 static constexpr auto testMemorySize = 1024;
 
+class TestableMemory : public Memory {
+public:
+    TestableMemory(const std::string& filename) : Memory(filename, testMemorySize){}
+
+    size_t size(){
+        return bytes.size();
+    }
+};
+
 TEST(MemoryTest, testWriteDword){
     Memory memory(testMemorySize);
     memory.write<Dword>(0x0, 0xB16B00B5);
@@ -33,3 +43,14 @@ TEST(MemoryTest, testRead){
     EXPECT_EQ(memory.read<Dword>(0x0), 0x00DEFEC8);
     EXPECT_EQ(memory.read<Dword>(testMemorySize), 0x00DEFEC8);
 }
+
+TEST(MemoryTest, testOpenFile){
+    TestableMemory memory("../../test/data/compiled/example_hex_file");
+    ASSERT_EQ(memory.size(), testMemorySize);
+    EXPECT_EQ(memory.read<Byte>(0x0), 'a');
+    EXPECT_EQ(memory.read<Byte>(0x1), 'b');
+    EXPECT_EQ(memory.read<Byte>(0x2), 'c');
+    EXPECT_EQ(memory.read<Byte>(0x3), 'd');
+    EXPECT_EQ(memory.read<Byte>(0x4), 'e');
+    EXPECT_EQ(memory.read<Byte>(0x5), 'f');
+}

test/util/BinaryRunner.h

@@ -19,6 +19,9 @@ class BinaryRunner {
             memory.write(addr++, bin);
         }
     }
+
+    BinaryRunner(const std::string& filename): memory(filename, memorySize), cpu(memory){}
+
     void run(const uint32_t& ticks){
         for(auto i = 0u; i < ticks; i++){
             cpu.tick();