update SHR/SHL arith

0xPolygonHermez · May 18, 2022 · 5fb4d14 · 5fb4d14
1 parent a0cfd1d
commit 5fb4d14
Show file tree

Hide file tree

Showing 8 changed files with 194 additions and 65 deletions.
diff --git a/main/loadtx_rlp.zkasm b/main/loadtx_rlp.zkasm
@@ -263,7 +263,7 @@ dataREAD:
 veryShortData:
         1                               :MSTORE(txCalldataLen)
         31 => D
-        ${A << (D*8)} => A
+                                        :CALL(SHLarith)
         A                               :MSTORE(SP++)
                                         :JMP(endData)
 
@@ -310,7 +310,7 @@ readDataFinal:
         C + D => C
 
         32-D => D
-        ${A << (D*8)} => A
+                                        :CALL(SHLarith)
         A                               :MSTORE(SP)
 
 endData:

diff --git a/main/opcodes.zkasm b/main/opcodes.zkasm
@@ -324,9 +324,8 @@ opBYTE:
     $ => B                  :MLOAD(SP--)
     $ => A                  :MLOAD(SP)
     31 - B => D
-    ${A >> (D*8)} => B
+                            :CALL(SHRarith)
     GAS-3 => GAS
-    B => A
     255 => B
     $                       :AND,MSTORE(SP++)
                             :JMP(readCode)
@@ -335,7 +334,14 @@ opSHR:
     SP - 1 => SP
     $ => D          :MLOAD(SP--)
     $ => A          :MLOAD(SP)
+    A => E
+    ${exp(2,D)} => B
+    ${B-1} => B
+    $ => C          :AND
+    ${exp(2,D)} => B
     ${A >> D} => A
+    0 => D
+    E               :ARITH
     A               :MSTORE(SP++)
     GAS-3 => GAS
                     :JMP(readCode)
@@ -344,8 +350,30 @@ opSHL:
     SP - 1 => SP
     $ => D          :MLOAD(SP--)
     $ => A          :MLOAD(SP)
-    ${A << D} => A
-    A               :MSTORE(SP++)
+    ${A << D} => E
+    256 - D => D    :JMPC(SHL0)
+    ${exp(2,D)} => B
+    ${B-1} => B
+    $ => C          :GT
+    256 - D => D
+    ${exp(2,D)} => B
+    0 - C           :JMPC(SHLbig)
+    0 => D,C
+    E               :ARITH
+                    :JMP(SHLfinal)
+SHL0:
+    0               :MSTORE(SP++)
+    GAS-3 => GAS
+                    :JMP(readCode)
+SHLbig:
+    256 - D => D
+    ${exp(2,D)} => D
+    ${A/D} => D
+    0 => C
+    E                       :ARITH
+
+SHLfinal:
+    E               :MSTORE(SP++)
     GAS-3 => GAS
                     :JMP(readCode)
 
@@ -368,7 +396,8 @@ opSAR:
     $ => A          :MLOAD(SP)
                     :CALL(abs)
                     ; if more than 32 set to 32
-    ${A >> (D*8)} => C
+                    :CALL(SHRarith)
+    A => C
     B => A
     1 => B
     $ => B          :XOR
@@ -434,7 +463,7 @@ opSHA3Loop:
 opSHA3Final:
                     :CALL(MLOADX)
     32 - C => D
-    ${A >> (D*8)} => A
+                    :CALL(SHRarith)
     $ => E          :MLOAD(lastHashIdUsed)
     C => D
     A               :HASHK(E)
@@ -516,10 +545,11 @@ opCALLDATALOAD2:
     A => D
     1024 + B => SP
     $ => A          :MLOAD(SP++)
-    ${A << (D*8)} => B
+                    :CALL(SHLarith)
+    A => B
     32 - D => D
     $ => A          :MLOAD(SP)
-    ${A >> (D*8)} => A
+                    :CALL(SHRarith)
     C => SP
     B + A           :MSTORE(SP++)
     GAS - 3 => GAS
@@ -553,12 +583,13 @@ opCALLDATACOPYinit:
     $ => A          :MLOAD(arithRes1)    
     1024 + A => SP
     $ => A          :MLOAD(SP)
-    ${A << (D*8)} => C
+                    :CALL(SHLarith)
+    A => C
     $ => A          :MLOAD(arithRes1) 
     1024 + A + 1 => SP
     32 - D => D
     $ => A          :MLOAD(SP)
-    ${A >> (D*8)} => A
+                    :CALL(SHRarith)
     A + C           :MSTORE(bytesToStore)
                     :CALL(MSTORE32)
     $ => SP         :MLOAD(SPw)
@@ -572,7 +603,7 @@ opCALLDATACOPYfinal:
     ${B%32} => D
     1024 + ${B/32} => SP
     $ => A          :MLOAD(SP)
-    ${A << (D*8)} => A
+                    :CALL(SHLarith)
     $ => SP         :MLOAD(SPw)
     $ => C          :MLOAD(SP)   ;length
     1024 + ${B/32} + 1 => SP
@@ -581,18 +612,18 @@ opCALLDATACOPYfinal:
     A => B
     $ => A          :MLOAD(SP)
     32 - D => D
-    ${A >> (D*8)} => A
+                    :CALL(SHRarith)
     32 - C => D
-    ${A << (D*8)} => A
+                    :CALL(SHLarith)
     B + A => A
     A               :MSTORE(bytesToStore)
                     :CALL(MSTOREX)
                     :JMP(opCALLDATACOPYend)
 
 opCALLDATACOPYxor:
     32 - C => D
-    ${A >> (D*8)} => A
-    ${A << (D*8)} => A
+                    :CALL(SHRarith)
+                    :CALL(SHLarith)
     A               :MSTORE(bytesToStore)
                     :CALL(MSTOREX)
 
@@ -650,7 +681,7 @@ opCODECOPYinit:
 opCODECOPYfinal:
     ${getBytecode(A,B,C)} => A
     32 - C  => D
-    ${A << (D*8)} => A
+                    :CALL(SHLarith)
     A               :MSTORE(bytesToStore)
                     :CALL(MSTOREX)
 
@@ -705,7 +736,7 @@ opEXTCODECOPYinit:
 opEXTCODECOPYfinal:
     ${getBytecode(A,B,C)} => A
     32 - C  => D
-    ${A << (D*8)} => A
+                    :CALL(SHLarith)
     A               :MSTORE(bytesToStore)
                     :CALL(MSTOREX)
 
@@ -929,7 +960,7 @@ opMSTORE8:
     $ => A          :MLOAD(SP)                  ;value
     1 => C
     32 - C => D
-    ${A << (D*8)} => A
+                    :CALL(SHLarith)
     A               :MSTORE(bytesToStore)
                     :CALL(MSTOREX)
     GAS - 3 => GAS
@@ -1151,7 +1182,7 @@ opAuxPUSHC:
     D - E => D
     $ => B                      :MLOAD(SP)
     ${getByte(B,C,D)} => B
-    ${A >> (D*8)} => A
+                                :CALL(SHRarith)
     $ => SP                     :MLOAD(SPw)
     A + B                       :MSTORE(SP++)
     GAS-3 => GAS

diff --git a/main/precompiled/blake2f.zkasm b/main/precompiled/blake2f.zkasm
@@ -17,7 +17,7 @@ BLAKE2FLoopData:
 BLAKE2FEndLoopData:
     $ => A                              :MLOAD(SP)
     32 - B => D
-    ${A >> (D*8)} => A
+                                        :CALL(SHRarith)
     ${precompiled_blake2f_add(A, B)}
 
 BLAKE2FDigestReturn:

diff --git a/main/precompiled/modexp.zkasm b/main/precompiled/modexp.zkasm
@@ -32,7 +32,7 @@ MODEXP:
     ;ASSERT C == D
     ;Result of the computation, with the same number of bytes as M
     32 - D => D
-    ${A << (D*8)} => A
+                    :CALL(SHLarith)
     A               :MSTORE(bytesToStore)
     C - 32          :JMPC(MODEXPstoreX)
                     :CALL(MSTORE32)

diff --git a/main/precompiled/ripemd160.zkasm b/main/precompiled/ripemd160.zkasm
@@ -15,7 +15,7 @@ RIPEMD160LoopData: ; set array of bytes in RIPEMD160
 RIPEMD160EndLoopData:
     $ => A                              :MLOAD(SP)
     32 - B => D
-    ${A >> (D*8)} => A
+                                        :CALL(SHRarith)
     ${precompiled_ripemd160_add(A, B)}
 
 RIPEMD160DigestReturn: ; digest hash and prepare return

diff --git a/main/precompiled/sha256.zkasm b/main/precompiled/sha256.zkasm
@@ -15,7 +15,7 @@ SHA256LoopData: ; set array of bytes in sha256
 SHA256EndLoopData:
     $ => A                              :MLOAD(SP)
     32 - B => D
-    ${A >> (D*8)} => A
+                                        :CALL(SHRarith)
     ${precompiled_sha256_add(A, B)}
 
 SHA256DigestReturn: ; digest hash and prepare return

diff --git a/main/process_tx.zkasm b/main/process_tx.zkasm
@@ -222,8 +222,8 @@ endContractAddress:
         HASHPOS                         :HASHKLEN(E)
         $ => A                          :HASHKDIGEST(E)
         12 => D
-        ${A << (D*8)} => A
-        ${A >> (D*8)} => A
+                                        :CALL(SHLarith)
+                                        :CALL(SHRarith)
         A                               :MSTORE(createContractAddress)
         ; TODO: Check nonce != 0 OR already_bytecode ==> same behaviour as fail constructor
         ; TODO: check CREATE or deployment with constructor reverted
@@ -255,7 +255,7 @@ loopCreate2:
 endloopCreate2:
         $ => A                          :MLOAD(SP)
         32 - C => D
-        ${A >> (D*8)} => A
+                                        :CALL(SHRarith)
         C => D
         A                               :HASHK(E)
 
@@ -280,8 +280,8 @@ create2end:
         HASHPOS                         :HASHKLEN(E)
         $ => A                          :HASHKDIGEST(E)
         12 => D
-        ${A << (D*8)} => A ; // TODO: Could be replaced by a bitwise and: ${bitwise_and(A, 2**160 - 1)
-        ${A >> (D*8)} => A
+                                        :CALL(SHLarith) ; // TODO: Could be replaced by a bitwise and: ${bitwise_and(A, 2**160 - 1)
+                                        :CALL(SHRarith)
         A                               :MSTORE(createContractAddress)
 
 deploy: