[Tolk] Peephole optimization: PUSHINT+STU to STSLICECONST

Now, `b.storeInt(123, 32)` generates not `123 PUSHINT; SWAP; STI`,
but `x{...} STSLICECONST`.
Although, for certain conditions, still generate STUR/STUR targeting
smaller bytecode.

Author: tolk-vm

tolk-tester/tests/cells-slices.tolk

@@ -473,26 +473,23 @@ We test that consequtive storeInt/storeUint with constants are joined into a sin
 @fif_codegen
 """
   test6() PROC:<{
-    18446744082299486211 PUSHINT
     NEWC
-    96 STU      //  '2
+    x{000000010000000200000003} STSLICECONST
     ENDC        //  '11
 """
 
 @fif_codegen
 """
   test17() PROC:<{
-    4219 PUSHINT
     NEWC
-    16 STU
+    x{107b} STSLICECONST
 """
 
 @fif_codegen
 """
   test18() PROC:<{
-    421 PUSHINT
     NEWC
-    26 STU
+    b{00000000000000000110100101} STSLICECONST
 """
 
 @fif_codegen
@@ -501,8 +498,7 @@ We test that consequtive storeInt/storeUint with constants are joined into a sin
     123 PUSHINT
     NEWC
     4 STI
-    16 PUSHPOW2DEC
-    16 STUR
+    x{ffff} STSLICECONST
     -1 PUSHINT
     8 STIR
   }>
@@ -511,9 +507,8 @@ We test that consequtive storeInt/storeUint with constants are joined into a sin
 @fif_codegen
 """
   test20() PROC:<{
-    40976 PUSHINT
     NEWC
-    16 STU
+    x{a010} STSLICECONST
 """
 
 @fif_codegen
@@ -529,12 +524,10 @@ We test that consequtive storeInt/storeUint with constants are joined into a sin
   test22() PROC:<{
     NEWC                    	//  '2
     NEWC                    	//  b1 b2
-    2056 PUSHINT
-    ROT
-    24 STU                  	//  b2 b1
+    SWAP                        //  b2 b1
+    x{000808} STSLICECONST      //  b2 b1
     SWAP                    	//  b1 b2
-    10141514286835656557042350424064 PUSHINTX
-    132 STUR                	//  b1 b2
+    x{000000080010000000000000000000000} STSLICECONST  //  b1 b2
 """
 
 @fif_codegen
@@ -543,13 +536,11 @@ We test that consequtive storeInt/storeUint with constants are joined into a sin
     NEWC
     SWAP
     IF:<{
-      91343852333181432387730302044911803916571639814 PUSHINT
-      256 STUR
+      x{0000000000000000000000001000000000000000000000000200000000000006} STSLICECONST
       8 PUSHINT
       256 STUR
     }>ELSE<{
-      56539106072908298546665520023773392506479484700019806659963456035401760775 PUSHINT
-      255 STIR
+      b{000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000111} STSLICECONST
     }>
     BBITS
   }>
@@ -597,9 +588,8 @@ We test that consequtive storeInt/storeUint with constants are joined into a sin
     s3 POP
     42 EQINT
     IF:<{
-      0 PUSHINT
-      ROT
-      3 STU
+      SWAP
+      b{000} STSLICECONST
       8 STU                 	//  b
     }>ELSE<{
       DROP                  	//  b

tolk-tester/tests/constants-tests.tolk

@@ -126,5 +126,5 @@ fun main() {
 @testcase | 105 |   | -1 0 7 48
 @testcase | 106 |   | -1 0 0 -1
 
-@code_hash 39394999917297360167950120811797040756088634052063904555277102239104815314650
+@code_hash 32362412747322136329528616455651783746542516198110452861733590440068294458753
 */

tolk-tester/tests/inline-tests.tolk

@@ -467,13 +467,11 @@ fun usedIn10ButDeclaredBelow(x: int) {
 @fif_codegen
 """
   test8() PROC:<{               //
-    5 PUSHINT
     NEWC
-    32 STU                      //  '3
+    x{00000005} STSLICECONST    //  '3
     25 PUSHINT                  //  '3 '9
-    107374182425 PUSHINT
-    ROT
-    64 STU                      //  x '3
+    SWAP                        //  x self
+    x{0000001900000019} STSLICECONST  //  x '3
     SWAP                        //  '3 x
   }>
 """
@@ -509,9 +507,8 @@ fun usedIn10ButDeclaredBelow(x: int) {
   test10() PROC:<{
     5 PUSHINT                   //  '3=5
     DUP                         //  '3=5 y=5
-    5 PUSHINT
     NEWC
-    32 STU                      //  a=5 b=5 c
+    x{00000005} STSLICECONST    //  a=5 b=5 c
     BBITS                       //  a=5 b=5 '18
   }>
 """

tolk-tester/tests/lazy-load-tests.tolk

@@ -1900,9 +1900,8 @@ fun main() {
     x{0102} PUSHSLICE
     8 LDI
     NIP
-    15 PUSHINT
     NEWC
-    8 STI
+    x{0f} STSLICECONST
     STSLICE
 """
 
@@ -1917,9 +1916,8 @@ fun main() {
     320 PUSHINT                 //  lazyS '14=320
     PLDSLICEX                   //  '15
     PUSHNULL                    //  '15 st.extensions
-    0 PUSHINT
     NEWC
-    1 STU                       //  '15 st.extensions b
+    b{0} STSLICECONST           //  '15 st.extensions b
     s1 s2 XCHG                  //  st.extensions '15 b
     STSLICE                     //  st.extensions b
     STOPTREF                    //  b

tolk-tester/tests/pack-unpack-1.tolk

@@ -107,9 +107,8 @@ fun main(c: cell) {
 @fif_codegen
 """
   test3() PROC:<{
-    42949672980 PUSHINT
     NEWC
-    64 STI                      //  b
+    x{0000000a00000014} STSLICECONST  //  b
     ENDC                        //  c
     CTOS                        //  s
     64 LDU

tolk-tester/tests/strings-tests.tolk

@@ -78,5 +78,5 @@ fun test1() {
 @testcase | 0   | | 0
 @testcase | 101 | | [ 65 66 67 68 ]
 
-@code_hash 33596158548631231081906594921712427436857221384530839008514203474433205250299
+@code_hash 52991558142486159683575375539594116045551936710713942466413832119934760926753
 */

tolk/optimize.cpp

@@ -164,8 +164,8 @@ bool Optimizer::detect_rewrite_big_THROW() {
   return true;
 }
 
-// purpose 1: for one constant b.storeInt(123, 32) generate not "123 PUSHINT; SWAP; STI", but "123 PUSHINT; STIR"
-// purpose 2: consecutive b.storeUint(ff, 16).storeUint(ff, 16) generate one "00ff00ff" STU
+// purpose 1: for b.storeInt(123, 32) generate not "123 PUSHINT; SWAP; STI", but "x{...} STSLICECONST"
+// purpose 2: consecutive b.storeUint(ff, 16).storeUint(ff, 16) generate one "x{00ff00ff} STSLICECONST"
 // (since it works at IR level, it also works for const variables and auto-serialization)
 bool Optimizer::detect_rewrite_MY_store_int() {
   bool first_my_store = op_[0]->is_custom() && op_[0]->op.starts_with("MY_store_int");
@@ -198,14 +198,38 @@ bool Optimizer::detect_rewrite_MY_store_int() {
     n_merged++;
   }
 
-  p_ = n_merged;
-  q_ = 2;
-  oq_[0] = std::make_unique<AsmOp>(AsmOp::IntConst(op_[0]->loc, total_number));
-  if (total_number == 0 && total_len == 4 && first_unsigned) {    // "STGRAMS" stores four 0-bits cheaper than "4 STUR"
-    oq_[1] = std::make_unique<AsmOp>(AsmOp::Custom(op_[0]->loc, "STGRAMS", 1, 1));
-  } else {
+  // we do not want to always use STSLICECONST; for example, storing "0" 64-bit via x{00...} is more effective
+  // for a single operation, but in practice, total bytecode becomes larger, which has a cumulative negative effect;
+  // here is a heuristic "when to use STSLICECONST, when leave PUSHINT + STUR", based on real contracts measurements
+  bool use_stsliceconst = total_len <= 32 || (total_len <= 48 && total_number >= 256) || (total_len <= 64 && total_number >= 65536)
+                      || (total_len <= 96 && total_number >= (1ULL<<32)) || (total_number > (1ULL<<62));
+  if (!use_stsliceconst) {
+    p_ = n_merged;
+    q_ = 2;
+    oq_[0] = std::make_unique<AsmOp>(AsmOp::IntConst(op_[0]->loc, total_number));
     oq_[1] = std::make_unique<AsmOp>(AsmOp::Custom(op_[0]->loc, std::to_string(total_len) + (first_unsigned ? " STUR" : " STIR"), 1, 1));
+    return true;
   }
+
+  p_ = n_merged;
+  q_ = 1;
+
+  // output "x{...}" or "b{...}" (if length not divisible by 4)
+  const td::RefInt256 base = td::make_refint(total_len % 4 == 0 ? 16 : 2);
+  const int s_len = base == 16 ? total_len / 4 : total_len;
+  const char* digits = "0123456789abcdef";
+
+  std::string result(s_len + 3, '0');
+  result[0] = base == 16 ? 'x' : 'b';
+  result[1] = '{';
+  result[s_len + 3 - 1] = '}';
+  for (int i = s_len - 1; i >= 0 && total_number != 0; --i) {
+    result[2 + i] = digits[(total_number % base)->to_long()];
+    total_number /= base;
+  }
+
+  result += " STSLICECONST";
+  oq_[0] = std::make_unique<AsmOp>(AsmOp::Custom(op_[0]->loc, result, 0, 1));
   return true;
 }