chore: stage bunch of size_t to uint32_t

Signed-off-by: Amneesh Singh <natto@weirdnatto.in>

include/bus.hh

@@ -8,14 +8,14 @@ class Bus {
   public:
     Bus(const Memory& memory);
 
-    uint8_t read_byte(size_t address);
+    uint8_t read_byte(uint32_t address);
-    void write_byte(size_t address, uint8_t byte);
+    void write_byte(uint32_t address, uint8_t byte);
 
-    uint16_t read_halfword(size_t address);
+    uint16_t read_halfword(uint32_t address);
-    void write_halfword(size_t address, uint16_t halfword);
+    void write_halfword(uint32_t address, uint16_t halfword);
 
-    uint32_t read_word(size_t address);
+    uint32_t read_word(uint32_t address);
-    void write_word(size_t address, uint32_t word);
+    void write_word(uint32_t address, uint32_t word);
 
   private:
     std::shared_ptr<Memory> memory;

include/memory.hh

@@ -10,15 +10,16 @@
 namespace matar {
 class Memory {
   public:
-    static constexpr size_t BIOS_SIZE = 1024 * 16;
+    static constexpr uint32_t BIOS_SIZE = 1024 * 16;
 
     Memory(std::array<uint8_t, BIOS_SIZE>&& bios, std::vector<uint8_t>&& rom);
 
-    uint8_t read(size_t address) const;
+    uint8_t read(uint32_t address) const;
-    void write(size_t address, uint8_t byte);
+    void write(uint32_t address, uint8_t byte);
 
   private:
-#define MEMORY_REGION(name, start) static constexpr size_t name##_START = start;
+#define MEMORY_REGION(name, start)                                             \
+    static constexpr uint32_t name##_START = start;
 
 #define DECL_MEMORY(name, ident, start, end)                                   \
     MEMORY_REGION(name, start)                                                 \
@@ -50,7 +51,7 @@ class Memory {
 
 #undef MEMORY_REGION
 
-    std::unordered_map<size_t, uint8_t> invalid_mem;
+    std::unordered_map<uint32_t, uint8_t> invalid_mem;
     std::vector<uint8_t> rom;
     Header header;
     void parse_header();

src/bus.cc

@@ -7,17 +7,17 @@ Bus::Bus(const Memory& memory)
   : memory(std::make_shared<Memory>(memory)) {}
 
 uint8_t
-Bus::read_byte(size_t address) {
+Bus::read_byte(uint32_t address) {
     return memory->read(address);
 }
 
 void
-Bus::write_byte(size_t address, uint8_t byte) {
+Bus::write_byte(uint32_t address, uint8_t byte) {
     memory->write(address, byte);
 }
 
 uint16_t
-Bus::read_halfword(size_t address) {
+Bus::read_halfword(uint32_t address) {
     if (address & 0b01)
         glogger.warn("Reading a non aligned halfword address");
 
@@ -25,7 +25,7 @@ Bus::read_halfword(size_t address) {
 }
 
 void
-Bus::write_halfword(size_t address, uint16_t halfword) {
+Bus::write_halfword(uint32_t address, uint16_t halfword) {
     if (address & 0b01)
         glogger.warn("Writing to a non aligned halfword address");
 
@@ -34,7 +34,7 @@ Bus::write_halfword(size_t address, uint16_t halfword) {
 }
 
 uint32_t
-Bus::read_word(size_t address) {
+Bus::read_word(uint32_t address) {
     if (address & 0b11)
         glogger.warn("Reading a non aligned word address");
 
@@ -43,7 +43,7 @@ Bus::read_word(size_t address) {
 }
 
 void
-Bus::write_word(size_t address, uint32_t word) {
+Bus::write_word(uint32_t address, uint32_t word) {
     if (address & 0b11)
         glogger.warn("Writing to a non aligned word address");
 

src/cpu/alu.cc

@@ -57,7 +57,7 @@ sub(uint32_t a, uint32_t b, bool& carry, bool& overflow) {
 
     uint32_t result = a - b;
 
-    carry    = b <= a;
+    carry    = a >= b;
     overflow = s1 != s2 && s2 == get_bit(result, 31);
 
     return result;

src/memory.cc

@@ -1,9 +1,7 @@
 #include "memory.hh"
 #include "header.hh"
-#include "util/bits.hh"
 #include "util/crypto.hh"
 #include "util/log.hh"
-#include <bitset>
 #include <stdexcept>
 
 namespace matar {
@@ -35,7 +33,7 @@ Memory::Memory(std::array<uint8_t, BIOS_SIZE>&& bios,
 };
 
 uint8_t
-Memory::read(size_t address) const {
+Memory::read(uint32_t address) const {
 #define MATCHES(AREA, area)                                                    \
     if (address >= AREA##_START && address < AREA##_START + area.size())       \
         return area[address - AREA##_START];
@@ -57,7 +55,7 @@ Memory::read(size_t address) const {
 }
 
 void
-Memory::write(size_t address, uint8_t byte) {
+Memory::write(uint32_t address, uint8_t byte) {
 #define MATCHES(AREA, area)                                                    \
     if (address >= AREA##_START && address < AREA##_START + area.size()) {     \
         area[address - AREA##_START] = byte;                                   \
@@ -159,7 +157,7 @@ Memory::parse_header() {
     if (rom[0xB2] != 0x96)
         glogger.error("HEADER: invalid fixed byte at 0xB2");
 
-    for (size_t i = 0xB5; i < 0xBC; i++) {
+    for (uint32_t i = 0xB5; i < 0xBC; i++) {
         if (rom[i] != 0x00)
             glogger.error("HEADER: invalid fixed bytes at 0xB5");
     }
@@ -168,7 +166,7 @@ Memory::parse_header() {
 
     // checksum
     {
-        size_t i = 0xA0, chk = 0;
+        uint32_t i = 0xA0, chk = 0;
         while (i <= 0xBC)
             chk -= rom[i++];
         chk -= 0x19;