Fix bytecode immediates

Author: mkeeter

fidget-bytecode/src/lib.rs

@@ -197,6 +197,7 @@ impl Bytecode {
         let mut data = vec![u32::MAX, 0u32];
         let mut reg_count = 0u8;
         let mut mem_count = 0u32;
+        let mem_offset = u32::try_from(N).unwrap();
         for op in t.iter_asm() {
             let mut word = [0xFF; 4];
             let mut imm = None;
@@ -217,15 +218,15 @@ impl Bytecode {
 
                 RegOp::Load(reg, slot) => {
                     store_reg(1, reg)?;
-                    store_reg(2, u8::MAX)?;
-                    mem_count = mem_count.max(slot);
-                    imm = Some(slot);
+                    word[2] = u8::MAX;
+                    mem_count = mem_count.max(slot - mem_offset);
+                    imm = Some(slot - mem_offset);
                 }
                 RegOp::Store(reg, slot) => {
-                    store_reg(1, u8::MAX)?;
                     store_reg(2, reg)?;
-                    mem_count = mem_count.max(slot);
-                    imm = Some(slot);
+                    word[1] = u8::MAX;
+                    mem_count = mem_count.max(slot - mem_offset);
+                    imm = Some(slot - mem_offset);
                 }
 
                 RegOp::CopyImm(out, imm_f32) => {
@@ -361,6 +362,7 @@ mod test {
 
     #[test]
     fn load_store() {
+        // Build a bytecode tape with only 2 registers to test load and store
         let mut ctx = fidget_core::Context::new();
         let x = ctx.x();
         let y = ctx.y();
@@ -373,9 +375,59 @@ mod test {
         let mut next = || *iter.next().unwrap();
         assert_eq!(next(), 0xFFFFFFFF); // start marker
         assert_eq!(next(), 0);
+
+        // Input(1, Z)
+        assert_eq!(
+            next().to_le_bytes(),
+            [BytecodeOp::Input as u8, 1, 0xFF, 0xFF]
+        );
+        assert_eq!(next(), 2); // Z
+
+        // Copy from reg[1] -> mem[0]
+        assert_eq!(
+            next().to_le_bytes(),
+            [BytecodeOp::Mem as u8, 0xFF, 1, 0xFF]
+        );
+        assert_eq!(next(), 0);
+
+        // Input(1, Y)
         assert_eq!(
             next().to_le_bytes(),
-            [BytecodeOp::Copy as u8, 0, 0xFF, 0xFF]
+            [BytecodeOp::Input as u8, 1, 0xFF, 0xFF]
+        );
+        assert_eq!(next(), 1); // Y
+
+        // Input(0, X)
+        assert_eq!(
+            next().to_le_bytes(),
+            [BytecodeOp::Input as u8, 0, 0xFF, 0xFF]
         );
+        assert_eq!(next(), 0); // X
+
+        // r1 = max(1, 0)
+        assert_eq!(next().to_le_bytes(), [BytecodeOp::Max as u8, 1, 1, 0]);
+        assert_eq!(next(), 0xFF000000);
+
+        // Copy from mem[0] -> reg[0]
+        assert_eq!(
+            next().to_le_bytes(),
+            [BytecodeOp::Mem as u8, 0, 0xFF, 0xFF]
+        );
+        assert_eq!(next(), 0);
+
+        // r1 = max(1, 0)
+        assert_eq!(next().to_le_bytes(), [BytecodeOp::Max as u8, 0, 0, 1]);
+        assert_eq!(next(), 0xFF000000);
+
+        // output(0) = r0
+        assert_eq!(
+            next().to_le_bytes(),
+            [BytecodeOp::Output as u8, 0, 0xFF, 0xFF]
+        );
+        assert_eq!(next(), 0);
+
+        assert_eq!(next(), 0xFFFFFFFF); // end marker
+        assert_eq!(next(), 0xFFFFFFFF);
+        assert!(iter.next().is_none());
     }
 }

fidget-core/src/compiler/op.rs

@@ -275,6 +275,9 @@ opcodes!(
     ///
     /// We have a maximum of 256 registers, though some tapes (e.g. ones
     /// targeting physical hardware) may choose to use fewer.
+    ///
+    /// Note that memory slots are not zero-indexed; they start at `N` (where
+    /// `N` is the register count).
     #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
     pub enum RegOp<u8> {
         // default variants