Merge pull request #56 from 0xPolygonHermez/fix/non-maxmem-reg

remove MAXMEM register
0xPolygonHermez · Feb 20, 2023 · 3f8c63c · 3f8c63c
2 parents 9aaf66b + c82d3c4
commit 3f8c63c
Show file tree

Hide file tree

Showing 19 changed files with 206 additions and 214 deletions.
diff --git a/build/command_parser.js b/build/command_parser.js
diff --git a/build/zkasm_parser.js b/build/zkasm_parser.js
diff --git a/src/command_parser.jison b/src/command_parser.jison
@@ -16,7 +16,6 @@ GAS                     { return 'GAS'; }
 zkPC                    { return 'zkPC'; }
 RR                      { return 'RR'; }
 STEP                    { return 'STEP'; }
-MAXMEM                  { return 'MAXMEM'; }
 CNT_ARITH               { return 'CNT_ARITH' }
 CNT_BINARY              { return 'CNT_BINARY' }
 CNT_KECCAK_F            { return 'CNT_KECCAK_F' }
@@ -285,7 +284,6 @@ reg
     | zkPC
     | RR
     | STEP
-    | MAXMEM
     | HASHPOS
     | RCX
     ;

diff --git a/src/zkasm_parser.jison b/src/zkasm_parser.jison
@@ -24,7 +24,6 @@ zkPC                    { return 'zkPC'; }
 RR                      { return 'RR'; }
 STEP                    { return 'STEP'; }
 ROTL_C                  { return 'ROTL_C'; }
-MAXMEM                  { return 'MAXMEM'; }
 HASHPOS                 { return 'HASHPOS'; }
 MLOAD                   { return 'MLOAD' }
 MSTORE                  { return 'MSTORE' }
@@ -725,7 +724,6 @@ reg
     | RR
     | zkPC
     | STEP
-    | MAXMEM
     | HASHPOS
     | ROTL_C
     | RCX

diff --git a/test/arrays.zkasm b/test/arrays.zkasm
@@ -17,7 +17,7 @@ start:
         @d => A
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR
 
 finalWait:
         ${beforeLast()}  : JMPN(finalWait)

diff --git a/test/consts.zkasm b/test/consts.zkasm
@@ -181,7 +181,7 @@ CONSTL %BIT8 = 0x123456789ABCDEF0n ^ 0n
         ; -2147483648 :ASSERT
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/consts_command.zkasm b/test/consts_command.zkasm
@@ -10,7 +10,7 @@ CONSTL %MAXL = (1 << 256) - 1
         ${115792089237316195423570985008687907853269984665640564039457584007913129639935} :ASSERT
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR
 
 finalWait:
         ${beforeLast()}  : JMPN(finalWait)

diff --git a/test/errors/consts.max.zkasm b/test/errors/consts.max.zkasm
@@ -4,7 +4,7 @@ start:
         3*2+5 => A
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/errors/consts.maxl.zkasm b/test/errors/consts.maxl.zkasm
@@ -3,7 +3,7 @@ CONSTL %MAXL = ((1 << 256) - 1) + 1
 start:
         3*2+5 => A
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/errors/consts.min.zkasm b/test/errors/consts.min.zkasm
@@ -4,7 +4,7 @@ start:
         3*2+5 => A
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/errors/consts.minl.zkasm b/test/errors/consts.minl.zkasm
@@ -4,7 +4,7 @@ start:
         3*2+5 => A
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/errors/consts.mix.const.zkasm b/test/errors/consts.mix.const.zkasm
@@ -5,7 +5,7 @@ start:
         %A*%B+5 => A
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/errors/consts.mix.values.zkasm b/test/errors/consts.mix.values.zkasm
@@ -5,7 +5,7 @@ start:
         3*2+5n => A
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/errors/consts.notdefined.zkasm b/test/errors/consts.notdefined.zkasm
@@ -4,7 +4,7 @@ start:
         3*2+%C => A
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/errors/consts.redefinition.zkasm b/test/errors/consts.redefinition.zkasm
@@ -5,7 +5,7 @@ start:
         3*2+5n => A
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/opcodes.zkasm b/test/opcodes.zkasm
@@ -48,7 +48,7 @@ main:
 
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/operations.zkasm b/test/operations.zkasm
@@ -1,4 +1,4 @@
-start:        
+start:
 
         1 => B
         0 => C,D
@@ -10,88 +10,88 @@ start:
         ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 | 0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} => A
         ${0x01F34567FFFBCDEFFF1122334FFF667788FFAAFFCCDFFFFFFEDCBA9876FFFF10} :ARITH
 
-        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 | 0} => A          
+        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 | 0} => A
         ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210} :ARITH
 
-        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 | 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} => A          
+        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 | 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} => A
         ${0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} :ARITH
 
         ;;;;;;;;;;;;;;;
         ;; bitwise AND
         ;;;;;;;;;;;;;;;
-        
-        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 & 0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} => A          
+
+        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 & 0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} => A
         ${0x0020000089A000000000000004550000009900BB000DEEFFF000000000543200} :ARITH
 
-        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 & 0} => A          
+        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 & 0} => A
         ${0} :ARITH
 
-        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} => A          
+        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} => A
         ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210} :ARITH
-        
+
         ;;;;;;;;;;;;;;;
         ;; bitwise XOR
         ;;;;;;;;;;;;;;;
-        
-        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 ^ 0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} => A          
+
+        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 ^ 0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} => A
         ${0x01D34567765BCDEFFF1122334BAA66778866AA44CCD211000EDCBA9876ABCD10} :ARITH
 
-        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 ^ 0} => A          
+        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 ^ 0} => A
         ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210} :ARITH
 
-        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} => A          
+        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} => A
         ${0xFEDCBA9876543210FFEEDDCCBBAA998877665544332211000123456789ABCDEF} :ARITH
-        
+
         ;;;;;;;;;;;;;;;
         ;; bitwise NOT
         ;;;;;;;;;;;;;;;
-        
-        ${~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} => A          
+
+        ${~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} => A
         ${0} :ARITH
 
-        ${~0} => A          
+        ${~0} => A
         ${0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF} :ARITH
 
-        ${~0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210} => A          
+        ${~0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210} => A
         ${0xFEDCBA9876543210FFEEDDCCBBAA998877665544332211000123456789ABCDEF} :ARITH
 
         ;;;;;;;;;;;;;;;
         ;; SHL
         ;;;;;;;;;;;;;;;
-        
-        ${0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF << 1} => A          
+
+        ${0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF << 1} => A
         ${0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE} :ARITH
 
-        ${0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF << 255} => A          
+        ${0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF << 255} => A
         ${0x8000000000000000000000000000000000000000000000000000000000000000} :ARITH
 
-        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 << 36} => A          
+        ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 << 36} => A
         ${0x9ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210000000000} :ARITH
 
         ;;;;;;;;;;;;;;;
         ;; IF with ?
         ;;;;;;;;;;;;;;;
 
         1 => E
-        ${E ? 0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 : 0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} => A 
+        ${E ? 0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 : 0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} => A
         ${0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210} :ARITH
 
         0 => E
-        ${E ? 0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 : 0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} => A 
+        ${E ? 0x0123456789ABCDEF00112233445566778899AABBCCDDEEFFFEDCBA9876543210 : 0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} => A
         ${0x00F00000FFF00000FF0000000FFF000000FF00FF000FFFFFF000000000FFFF00} :ARITH
 
         1 => E
-        ${E ? (E + 3) : (E + 2)} => A 
+        ${E ? (E + 3) : (E + 2)} => A
         4 :ARITH
 
         0 => E
-        ${E ? (E + 2 + 1) : ((E + 6 * 2) * 2 + 3)} => A 
+        ${E ? (E + 2 + 1) : ((E + 6 * 2) * 2 + 3)} => A
         27 :ARITH
 
         :JMP(end)
-       
+
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)

diff --git a/test/rotlc.zkasm b/test/rotlc.zkasm
@@ -7,7 +7,7 @@ start:
         0x1415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F10111213n: ASSERT
 
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR
 
 finalWait:
         ${beforeLast()}  : JMPN(finalWait)

diff --git a/test/subroutine.zkasm b/test/subroutine.zkasm
@@ -4,26 +4,26 @@ start:
         2 => B
 
         :CALL(subroutine)             ; same as :JMP(RR)
-        
-        0 => A,B,D 
+
+        0 => A,B,D
         5 => E     :ARITH
 
         4 => A
         8 => B
 
         zkPC+1 => RR :JMP(subroutine) ; same as CALL(subroutime)
 
-        0 => A,B,D 
+        0 => A,B,D
         12 => E     :ARITH
 
         :JMP(end)
 
 subroutine:
         A+B => C
         :RETURN                       ; same as :JMP(RR)
-       
+
 end:
-       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR                 ; Set all registers to 0
+       0 => A,B,C,D,E,CTX, SP, PC, GAS, SR                 ; Set all registers to 0
 
 longLoop:
         STEP-0x10000+40  : JMPC(longLoop2)