Remove all the signed versions of memory read accessors and just do this as needed in memaccess.

This avoids a lot of duplication and opportunities for bugs (e.g. failing to override correctly)

TODO.md

@@ -2,7 +2,6 @@
 
 ## General
 * Persist disassembly labels across sessions?
-* Get rid of the readU32() stubs which just do readS32()>>>0.
 
 ## CPU
 

src/devices/ai.js

@@ -73,10 +73,6 @@ export class AIRegDevice extends Device {
   }
 
   readU32(address) {
-    return this.readS32(address) >>> 0;
-  }
-
-  readS32(address) {
     const ea = this.calcWriteEA(address);
     if (ea + 4 > this.u8.length) {
       throw 'Write is out of range';
@@ -93,7 +89,7 @@ export class AIRegDevice extends Device {
     }
 
     // All other reads return the current length.
-    return this.dmaLengthRemaining();
+    return this.dmaLengthRemaining() >>> 0;
   }
 
   write32(address, value) {

src/devices/device.js

@@ -160,45 +160,6 @@ export class Device {
     return this.mem.getU8(ea);
   }
 
-  /**
-   * Reads signed 32 bit data at the specified address.
-   * @param {number} address
-   * @return {number}
-   */
-  readS32(address) {
-    const ea = this.calcReadEA(address);
-    if (ea + 4 > this.u8.length) {
-      return 0;
-    }
-    return this.mem.getS32(ea);
-  }
-
-  /**
-   * Reads signed 16 bit data at the specified address.
-   * @param {number} address
-   * @return {number}
-   */
-  readS16(address) {
-    const ea = this.calcReadEA(address);
-    if (ea + 2 > this.u8.length) {
-      return 0;
-    }
-    return this.mem.getS16(ea);
-  }
-
-  /**
-   * Reads signed 8 bit data at the specified address.
-   * @param {number} address
-   * @return {number}
-   */
-  readS8(address) {
-    const ea = this.calcReadEA(address);
-    if (ea + 1 > this.u8.length) {
-      return 0;
-    }
-    return this.mem.getS8(ea);
-  }
-
   /**
    * Writes 64 bit data using a mask to the specified address.
    * @param {number} address Address to write to - will be 64 bit aligned.
@@ -333,21 +294,6 @@ export class LoggingDevice extends Device {
     return super.readU8(address);
   }
 
-  readS32(address) {
-    this.logRead(address);
-    return super.readS32(address);
-  }
-
-  readS16(address) {
-    this.logRead(address);
-    return super.readS16(address);
-  }
-
-  readS8(address) {
-    this.logRead(address);
-    return super.readS8(address);
-  }
-
   write64masked(address, value, mask) {
     this.logWrite(address, value, 64);
     super.write64masked(address, value, mask);

src/devices/dpc.js

@@ -128,10 +128,6 @@ export class DPCDevice extends Device {
     this.logRead(address);
     return this.readRegU32(this.calcReadEA(address));
   }
-  readS32(address) {
-    this.logRead(address);
-    return this.readRegU32(this.calcReadEA(address)) >> 0;
-  }
 
   readRegU32(ea) {
     if (ea + 4 > this.u8.length) {

src/devices/dps.js

@@ -27,7 +27,7 @@ export class DPSDevice extends Device {
     //this.mem.set32(ea, value);
   }
 
-  readS32(address) {
+  readU32(address) {
     this.logRead(address);
     const ea = this.calcReadEA(address);
 
@@ -35,10 +35,6 @@ export class DPSDevice extends Device {
       throw 'Read is out of range';
     }
     throw 'DPS reads are unhandled';
-    //return this.mem.getS32(ea);
-  }
-
-  readU32(address) {
-    return this.readS32(address) >>> 0;
+    //return this.mem.getU32(ea);
   }
 }

src/devices/pi.js

@@ -69,7 +69,7 @@ export class PIRegDevice extends Device {
     }
   }
 
-  readS32(address) {
+  readU32(address) {
     const ea = this.calcReadEA(address);
     if (ea + 4 > this.u8.length) {
       throw 'Read is out of range';
@@ -91,11 +91,7 @@ export class PIRegDevice extends Device {
 
     if (!this.quiet) { logger.log(`Reading from PIReg: [${toString32(address)}] -> ${toString32(v)}`); }
 
-    return v;
-  }
-
-  readU32(address) {
-    return this.readS32(address) >>> 0;
+    return v >>> 0;
   }
 
   write32(address, value) {

src/devices/pif.js

@@ -11,12 +11,12 @@ export class PIFMemDevice extends Device {
     super("PIFMEM", hardware, hardware.pif_mem, rangeStart, rangeEnd);
   }
 
-  readS32(address) {
+  readU32(address) {
     const ea = this.calcReadEA(address);
     if (ea + 4 > this.u8.length) {
       throw 'Read is out of range';
     }
-    const v = this.mem.getS32(ea);
+    const v = this.mem.getU32(ea);
     if (ea < 0x7c0) {
       logger.log(`Reading from PIF rom (${toString32(address)}). Got ${toString32(v)}`);
     } else {
@@ -31,11 +31,7 @@ export class PIFMemDevice extends Device {
     return v;
   }
 
-  readU32(address) {
-    return this.readS32(address) >>> 0;
-  }
-
-  readS8(address) {
+  readU8(address) {
     const ea = this.calcReadEA(address);
     const v = this.mem.getU8(ea);
     if (ea < 0x7c0) {
@@ -52,10 +48,6 @@ export class PIFMemDevice extends Device {
     return v;
   }
 
-  readU8(address) {
-    return this.readS8(address) >>> 0;
-  }
-
   write32(address, value) {
     const ea = this.calcWriteEA(address);
     if (ea < 0x7c0) {

src/devices/ram.js

@@ -44,11 +44,6 @@ export class CachedMemDevice extends Device {
     return this.dataView.getUint32(off, false); 
   }
 
-  readS32(address) {
-    const off = address - 0x80000000;
-    return this.dataView.getInt32(off, false); 
-  }
-
   write32(address, value) {
     const off = address - 0x80000000;
     this.dataView.setUint32(off, value, false); 
@@ -79,10 +74,6 @@ export class InvalidMemDevice extends Device {
   readU16(address) { return this.read(address) & 0xffff; }
   readU8(address) { return this.read(address) & 0xff; }
 
-  readS32(address) { return this.read(address) >> 0; }
-  readS16(address) { return this.read(address) & 0xffff; }
-  readS8(address) { return this.read(address) & 0xff; }
-
   write32(address, value) { this.write(address, value); }
   write16(address, value) { this.write(address, value); }
   write8(address, value) { this.write(address, value); }

src/devices/rom.js

@@ -103,13 +103,6 @@ export class ROMD1A2Device extends Device {
         return super.readU32(address);
     }
 
-    readS32(address) {
-        if (this.hasLastWrite) {
-            return this.consumeLastWrite() >> 0;
-        }
-        return super.readS32(address);
-    }
-
     readU16(address) {
         if (this.hasLastWrite) {
             return this.consumeLastWrite() >>> 16;
@@ -117,13 +110,6 @@ export class ROMD1A2Device extends Device {
         return super.readU16(address);
     }
 
-    readS16(address) {
-        if (this.hasLastWrite) {
-            return this.consumeLastWrite() >> 16;
-        }
-        return super.readS16(address);
-    }
-
     readU8(address) {
         if (this.hasLastWrite) {
             return this.consumeLastWrite() >>> 24;
@@ -131,13 +117,6 @@ export class ROMD1A2Device extends Device {
         return super.readU8(address);
     }
 
-    readS8(address) {
-        if (this.hasLastWrite) {
-            return this.consumeLastWrite() >> 24;
-        }
-        return super.readS8(address);
-    }
-
     cacheLastWrite(value) {
         if (!this.hasLastWrite) {
             this.lastWrite = value;
@@ -205,10 +184,6 @@ export class ROMD2A1Device extends Device {
     readU16(address) { return this.read(address) & 0xffff; }
     readU8(address) { return this.read(address) & 0xff; }
 
-    readS32(address) { return this.read(address) >> 0; }
-    readS16(address) { return this.read(address) & 0xffff; }
-    readS8(address) { return this.read(address) & 0xff; }
-
     write32(address, value) { throw `Writing to rom ${toString32(value)} -> [${toString32(address)}]`; }
     write16(address, value) { throw `Writing to rom ${toString16(value)} -> [${toString32(address)}]`; }
     write8(address, value) { throw `Writing to rom ${toString8(value)} -> [${toString32(address)}]`; }
@@ -226,24 +201,20 @@ export class ROMD2A2Device extends Device {
 
     hasFlashRam() { return this.hardware.saveType == 'FlashRam'; }
 
-    readU32(address) { return this.readS32(address) >>> 0; }
-    readU16(address) { return this.readS16(address) >>> 0; }
-    readU8(address) { return this.readS8(address) >>> 0; }
-
-    readS32(address) {
+    readU32(address) {
         const ea = this.calcWriteEA(address);
         if (ea >= 0x88000) {
             return unmappedAddressValue(address);
         }
         if (this.hasFlashRam()) {
             const wrapped = ea & 4; // Load from either low or high word.
-            return this.flashStatus.getS32(wrapped);
+            return this.flashStatus.getU32(wrapped);
         }
         throw `Reading s32 from rom d2a2 [${toString32(address)}]`;
     }
     // TODO: short reads should probably behave like 32 bit read and byte selection done on CPU.
-    readS16(address) { throw `Reading s16 from rom d2a2 [${toString32(address)}]`; }
-    readS8(address) { throw `Reading s8 from rom d2a2 [${toString32(address)}]`; }
+    readU16(address) { throw `Reading 16 bits from rom d2a2 [${toString32(address)}]`; }
+    readU8(address) { throw `Reading 8 bits from rom d2a2 [${toString32(address)}]`; }
 
     write32(address, value) {
         const ea = this.calcWriteEA(address);

src/devices/si.js

@@ -21,7 +21,7 @@ export class SIRegDevice extends Device {
     super("SIReg", hardware, hardware.si_reg, rangeStart, rangeEnd);
   }
 
-  readS32(address) {
+  readU32(address) {
     this.logRead(address);
     const ea = this.calcReadEA(address);
 
@@ -31,11 +31,7 @@ export class SIRegDevice extends Device {
     if (ea === SI_STATUS_REG) {
       this.checkStatusConsistent();
     }
-    return this.mem.getS32(ea);
-  }
-
-  readU32(address) {
-    return this.readS32(address) >>> 0;
+    return this.mem.getU32(ea);
   }
 
   write32(address, value) {

src/devices/sp.js

@@ -209,10 +209,6 @@ export class SPRegDevice extends Device {
     this.logRead(address);
     return this.readRegU32(this.calcReadEA(address));
   }
-  readS32(address) {
-    this.logRead(address);
-    return this.readRegU32(this.calcReadEA(address)) >> 0;
-  }
 
   readRegU32(ea) {
     if (ea + 4 > this.u8.length) {

src/devices/vi.js

@@ -224,7 +224,7 @@ export class VIRegDevice extends Device {
     }
   }
 
-  readS32(address) {
+  readU32(address) {
     this.logRead(address);
     const ea = this.calcReadEA(address);
     if (ea + 4 > this.u8.length) {
@@ -249,11 +249,7 @@ export class VIRegDevice extends Device {
 
       this.mem.set32(ea, value);
     }
-    return this.mem.getS32(ea);
-  }
-
-  readU32(address) {
-    return this.readS32(address) >>> 0;
+    return this.mem.getU32(ea);
   }
 
   computeDimensions() {

src/memaccess.js

@@ -153,17 +153,17 @@ function loadInstructionSlow(addr) {
 
 // Signed loads.
 function loadS8slow(addr) {
-  return getMemoryHandler(addr).readS8(addr);
+  return (getMemoryHandler(addr).readU8(addr) << 24) >> 24;
 }
 
 function loadS16slow(addr) {
   if (addr & 1) { cpu0.unalignedLoad(addr); }
-  return getMemoryHandler(addr).readS16(addr);
+  return (getMemoryHandler(addr).readU16(addr) << 16) >> 16;
 }
 
 export function loadS32slow(addr) {
   if (addr & 3) { cpu0.unalignedLoad(addr); }
-  return getMemoryHandler(addr).readS32(addr);
+  return getMemoryHandler(addr).readU32(addr) >> 0;
 }
 
 // Stores.