[Tolk] Optimize arg_order in advance when it's safe

This partially "reverts" the behavior of pragma
'compute-asm-ltr' from FunC, which was always on in Tolk.
Now, if it's safe, for asm functions with arg_order,
arguments are evaluated and placed onto the stack
in a desired order. When it's unsafe (the purpose
of this pragma, actually), arguments are evaluated
left-to-right.

Author: tolk-vm

tolk-tester/tests/asm-arg-order.tolk

@@ -120,6 +120,67 @@ fun test_new_dot(): (tuple, tuple) {
   return (t, t2);
 }
 
+@pure
+fun asmAPlus1TimesB(a: int, b: int): int
+    asm(b a) "1 ADDCONST MUL";
+
+@pure
+fun int.plus1TimesB(self, b: int): int
+    asm(b self) "1 ADDCONST MUL";
+
+@pure
+fun get2Pure() { return 2; }
+@pure
+fun get10Pure() { return 10; }
+
+fun get2Impure() { return 2; }
+fun get10Impure() { return 10; }
+
+global g2: int;
+global g10: int;
+
+fun setG2(v: int) { g2 = v; return v; }
+
+@method_id(27)
+fun test27() {
+    return asmAPlus1TimesB(2, 10);
+}
+
+@method_id(28)
+fun test28() {
+    return asmAPlus1TimesB(get2Pure(), get10Pure());
+}
+
+@method_id(29)
+fun test29() {
+    return asmAPlus1TimesB(get2Impure(), get10Impure());
+}
+
+@method_id(30)
+fun test30() {
+    g2 = 2;
+    g10 = 10;
+    return asmAPlus1TimesB(g2, g10);
+}
+
+@method_id(31)
+fun test31() {
+    g2 = 2;
+    g10 = 10;
+    return asmAPlus1TimesB(g2 += 2, g10 += g2);
+}
+
+@method_id(32)
+fun test32() {
+    return 2.plus1TimesB(10);
+}
+
+@method_id(33)
+fun test33(x: int) {
+    return ((x += 10).plus1TimesB(2), (x += 20).plus1TimesB(x), ((x /= (g2=2)).plus1TimesB(x*g2)), setG2(7).plus1TimesB(g2));
+}
+
+
 fun main() {
 }
 
@@ -137,6 +198,60 @@ fun main() {
 @testcase | 24 |    | [ 11 22 33 44 55 ] [ 220 330 440 110 550 ]
 @testcase | 25 |    | [ 22 33 ] [ 220 330 ]
 @testcase | 26 |    | [ 11 22 33 ] [ 220 330 110 ]
+@testcase | 27 |    | 30
+@testcase | 28 |    | 30
+@testcase | 29 |    | 30
+@testcase | 30 |    | 30
+@testcase | 31 |    | 70
+@testcase | 32 |    | 30
+@testcase | 33 | 0  | 22 930 480 56
+
+@fif_codegen
+"""
+  test27 PROC:<{
+    10 PUSHINT
+    2 PUSHINT
+    1 ADDCONST MUL
+  }>
+"""
+
+@fif_codegen
+"""
+  test28 PROC:<{
+    get10Pure CALLDICT
+    get2Pure CALLDICT
+    1 ADDCONST MUL
+  }>
+"""
+
+@fif_codegen
+"""
+  test29 PROC:<{
+    get2Impure CALLDICT
+    get10Impure CALLDICT
+    SWAP
+    1 ADDCONST MUL
+  }>
+"""
+
+@fif_codegen
+"""
+  test30 PROC:<{
+    ...
+    g10 GETGLOB
+    g2 GETGLOB
+    1 ADDCONST MUL
+  }>
+"""
+
+@fif_codegen
+"""
+  test32 PROC:<{
+    10 PUSHINT
+    2 PUSHINT
+    1 ADDCONST MUL
+  }>
+"""
 
-@code_hash 93068291567112337250118419287631047120002003622184251973082208096953112184588
+@code_hash 78671986831403867804966279036762472603849672357801214378328975900111280733054
 */

tolk-tester/tests/cells-slices.tolk

@@ -198,6 +198,37 @@ fun test111() {
     return (op1, q1, op2, q2);
 }
 
+global g8: int;
+global g10: int;
+global g16: int;
+global g32: int;
+
+@inline_ref
+fun initGlobals() {
+    g8 = 8;
+    g10 = 10;
+    g16 = 16;
+    g32 = 32;
+}
+
+@method_id(116)
+fun test16() {
+    initGlobals();
+    var b1 = beginCell().storeUint(g8, g16).storeUint(0xFF, g32).storeUint(g8, g16 * 2);
+    var b2 = beginCell().storeUint(8, 16).storeUint(0xFF, 32).storeUint(8, 16 * 2);
+    assert(b1.bitsCount() == b2.bitsCount(), 400);
+    var c1 = b1.endCell().beginParse();
+    var c2 = b2.endCell().beginParse();
+    assert(c1.bitsEqual(c2), 400);
+    assert(c1.loadUint(g16) == g8, 400);
+    assert(c1.loadUint(g32) == 0xFF, 400);
+    assert(c1.loadUint(2 * g16) == 8, 400);
+    return b1;
+    // 00140008000000ff00000008
+    // 00140008000000ff00000008
+}
+
+
 fun main(): int {
     return 0;
 }
@@ -217,21 +248,19 @@ fun main(): int {
 @testcase | 114 | -1  | -1 0 -1
 @testcase | 114 | 0   | 0 0 0
 @testcase | 115 |     | 123 456 123 456
+@testcase | 116 |     | BC{00140008000000ff00000008}
 
 Note, that since 'compute-asm-ltr' became on be default, chaining methods codegen is not quite optimal.
 @fif_codegen
 """
   test6 PROC:<{
-    NEWC	//  '0
-    1 PUSHINT	//  '0 '1=1
-    SWAP	//  '1=1 '0
-    32 STU	//  '0
-    2 PUSHINT	//  '0 '4=2
-    SWAP	//  '4=2 '0
-    32 STU	//  '0
-    3 PUSHINT	//  '0 '7=3
-    SWAP	//  '7=3 '0
-    32 STU	//  '0
+    3 PUSHINT                   //  '0=3
+    2 PUSHINT                   //  '0=3 '1=2
+    1 PUSHINT                   //  '0=3 '1=2 '2=1
+    NEWC                        //  '0=3 '1=2 '2=1 '3
+    32 STU                      //  '0=3 '1=2 '3
+    32 STU                      //  '0=3 '3
+    32 STU                      //  '3
   }>
 """
  */

tolk-tester/tests/constants-tests.tolk

@@ -118,5 +118,5 @@ fun main() {
 @testcase | 104 |   | 1 1 2
 @testcase | 105 |   | -1 0 7 48
 
-@code_hash 80040709432962217077682091261201772251141677197885524779745956896218368868623
+@code_hash 49556957179018386976033482229516007597784982050169632168468608374010225644988
 */

tolk-tester/tests/strings-tests.tolk

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

tolk/analyzer.cpp

@@ -851,6 +851,10 @@ void Op::set_impure_flag() {
   flags |= _Impure;
 }
 
+void Op::set_arg_order_already_equals_asm_flag() {
+  flags |= _ArgOrderAlreadyEqualsAsm;
+}
+
 bool Op::mark_noreturn() {
   switch (cl) {
     case _Nop:

tolk/codegen.cpp

@@ -453,8 +453,10 @@ bool Op::generate_code_step(Stack& stack) {
       if (disabled()) {
         return true;
       }
-      // f_sym can be nullptr for Op::_CallInd (invoke a variable, not a function)
-      const std::vector<int>* arg_order = f_sym ? f_sym->get_arg_order() : nullptr;
+      // f_sym can be nullptr for Op::_CallInd (invoke a variable, not a function);
+      // if f has arg_order, when it's safe, the compiler evaluates arguments in that order in advance (for fewer stack manipulations);
+      // when it's unsafe, arguments are evaluated left-to-right, and we need to match asm arg_order here
+      const std::vector<int>* arg_order = f_sym && !arg_order_already_equals_asm() ? f_sym->get_arg_order() : nullptr;
       const std::vector<int>* ret_order = f_sym ? f_sym->get_ret_order() : nullptr;
       tolk_assert(!arg_order || arg_order->size() == right.size());
       tolk_assert(!ret_order || ret_order->size() == left.size());

tolk/pipe-ast-to-legacy.cpp

@@ -278,6 +278,53 @@ class LValContext {
   }
 };
 
+// the purpose of this class is having a call `f(a1,a2,...)` when f has asm arg_order, to check
+// whether it's safe to rearrange arguments (to evaluate them in arg_order right here for fewer stack manipulations)
+// or it's unsafe, and we should evaluate them left-to-right;
+// example: `f(1,2,3)` / `b.storeUint(2,32)` is safe
+// example: `f(x,x+=5,x)` / `f(impureF1(), global_var)` is unsafe
+class CheckReorderingForAsmArgOrderIsSafeVisitor final : public ASTVisitorFunctionBody {
+  bool has_side_effects = false;
+
+protected:
+  void visit(V<ast_function_call> v) override {
+    has_side_effects |= v->fun_maybe == nullptr || !v->fun_maybe->is_marked_as_pure();
+    parent::visit(v);
+  }
+
+  void visit(V<ast_assign> v) override {
+    has_side_effects = true;
+    parent::visit(v);
+  }
+
+  void visit(V<ast_set_assign> v) override {
+    has_side_effects = true;
+    parent::visit(v);
+  }
+
+public:
+  bool should_visit_function(FunctionPtr fun_ref) override {
+    tolk_assert(false);
+  }
+
+  static bool is_safe_to_reorder(V<ast_function_call> v) {
+    for (const LocalVarData& param : v->fun_maybe->parameters) {
+      if (param.declared_type->get_width_on_stack() != 1) {
+        return false;
+      }
+    }
+
+    CheckReorderingForAsmArgOrderIsSafeVisitor visitor;
+    for (int i = 0; i < v->get_num_args(); ++i) {
+      visitor.ASTVisitorFunctionBody::visit(v->get_arg(i)->get_expr());
+    }
+    if (v->dot_obj_is_self) {
+      visitor.ASTVisitorFunctionBody::visit(v->get_self_obj());
+    }
+    return !visitor.has_side_effects;
+  }
+};
+
 // given `{some_expr}!`, return some_expr
 static AnyExprV unwrap_not_null_operator(AnyExprV v) {
   while (auto v_notnull = v->try_as<ast_not_null_operator>()) {
@@ -469,12 +516,16 @@ static std::vector<var_idx_t> pre_compile_is_type(CodeBlob& code, TypePtr expr_t
 }
 
 static std::vector<var_idx_t> gen_op_call(CodeBlob& code, TypePtr ret_type, SrcLocation loc,
-                                          std::vector<var_idx_t>&& args_vars, FunctionPtr fun_ref, const char* debug_desc) {
+                                          std::vector<var_idx_t>&& args_vars, FunctionPtr fun_ref, const char* debug_desc,
+                                          bool arg_order_already_equals_asm = false) {
   std::vector<var_idx_t> rvect = code.create_tmp_var(ret_type, loc, debug_desc);
   Op& op = code.emplace_back(loc, Op::_Call, rvect, std::move(args_vars), fun_ref);
   if (!fun_ref->is_marked_as_pure()) {
     op.set_impure_flag();
   }
+  if (arg_order_already_equals_asm) {
+    op.set_arg_order_already_equals_asm_flag();
+  }
   return rvect;
 }
 
@@ -1234,9 +1285,31 @@ static std::vector<var_idx_t> process_function_call(V<ast_function_call> v, Code
   for (int i = 0; i < v->get_num_args(); ++i) {
     args.push_back(v->get_arg(i)->get_expr());
   }
+
   // the purpose of tensor_tt ("tensor target type") is to transition `null` to `(int, int)?` and so on
   // the purpose of calling `pre_compile_tensor_inner` is to have 0-th IR vars to handle return self
   std::vector<TypePtr> params_types = fun_ref->inferred_full_type->try_as<TypeDataFunCallable>()->params_types;
+
+  // if fun_ref has asm arg_order, maybe it's safe to swap arguments here (to put them onto a stack in the right way);
+  // (if it's not safe, arguments are evaluated left-to-right, involving stack transformations later)
+  bool arg_order_already_equals_asm = false;
+  int asm_self_idx = 0;
+  if (!fun_ref->arg_order.empty() && CheckReorderingForAsmArgOrderIsSafeVisitor::is_safe_to_reorder(v)) {
+    std::vector<AnyExprV> new_args(args.size());
+    std::vector<TypePtr> new_params_types(params_types.size());
+    for (int i = 0; i < static_cast<int>(fun_ref->arg_order.size()); ++i) {
+      int real_i = fun_ref->arg_order[i];
+      new_args[i] = args[real_i];
+      new_params_types[i] = params_types[real_i];
+      if (real_i == 0) {
+        asm_self_idx = i;
+      }
+    }
+    args = std::move(new_args);
+    params_types = std::move(new_params_types);
+    arg_order_already_equals_asm = true;
+  }
+
   const TypeDataTensor* tensor_tt = TypeDataTensor::create(std::move(params_types))->try_as<TypeDataTensor>();
   std::vector<std::vector<var_idx_t>> vars_per_arg = pre_compile_tensor_inner(code, args, tensor_tt, nullptr);
 
@@ -1263,20 +1336,21 @@ static std::vector<var_idx_t> process_function_call(V<ast_function_call> v, Code
   for (const std::vector<var_idx_t>& list : vars_per_arg) {
     args_vars.insert(args_vars.end(), list.cbegin(), list.cend());
   }
-  std::vector<var_idx_t> rvect_apply = gen_op_call(code, op_call_type, v->loc, std::move(args_vars), fun_ref, "(fun-call)");
+  std::vector<var_idx_t> rvect_apply = gen_op_call(code, op_call_type, v->loc, std::move(args_vars), fun_ref, "(fun-call)", arg_order_already_equals_asm);
 
   if (fun_ref->has_mutate_params()) {
     LValContext local_lval;
     std::vector<var_idx_t> left;
     for (int i = 0; i < delta_self + v->get_num_args(); ++i) {
+      int real_i = arg_order_already_equals_asm ? i == 0 && delta_self ? asm_self_idx : fun_ref->arg_order[i - delta_self] : i;
       if (fun_ref->parameters[i].is_mutate_parameter()) {
-        AnyExprV arg_i = obj_leftmost && i == 0 ? obj_leftmost : args[i];
+        AnyExprV arg_i = obj_leftmost && i == 0 ? obj_leftmost : args[real_i];
         tolk_assert(arg_i->is_lvalue || i == 0);
         if (arg_i->is_lvalue) {
           std::vector<var_idx_t> ith_var_idx = pre_compile_expr(arg_i, code, nullptr, &local_lval);
           left.insert(left.end(), ith_var_idx.begin(), ith_var_idx.end());
         } else {
-          left.insert(left.end(), vars_per_arg[0].begin(), vars_per_arg[0].end());
+          left.insert(left.end(), vars_per_arg[asm_self_idx].begin(), vars_per_arg[asm_self_idx].end());
         }
       }
     }
@@ -1292,7 +1366,7 @@ static std::vector<var_idx_t> process_function_call(V<ast_function_call> v, Code
     if (obj_leftmost->is_lvalue) {    // to handle if obj is global var, potentially re-assigned inside a chain
       rvect_apply = pre_compile_expr(obj_leftmost, code, nullptr);
     } else {                          // temporary object, not lvalue, pre_compile_expr
-      rvect_apply = vars_per_arg[0];
+      rvect_apply = vars_per_arg[asm_self_idx];
     }
   }
 

tolk/tolk.h

@@ -287,7 +287,7 @@ struct Op {
     _SliceConst,
   };
   OpKind cl;
-  enum { _Disabled = 1, _NoReturn = 4, _Impure = 24 };
+  enum { _Disabled = 1, _NoReturn = 2, _Impure = 4, _ArgOrderAlreadyEqualsAsm = 8 };
   int flags;
   std::unique_ptr<Op> next;
   FunctionPtr f_sym = nullptr;
@@ -347,6 +347,9 @@ struct Op {
   bool impure() const { return flags & _Impure; }
   void set_impure_flag();
 
+  bool arg_order_already_equals_asm() const { return flags & _ArgOrderAlreadyEqualsAsm; }
+  void set_arg_order_already_equals_asm_flag();
+
   void show(std::ostream& os, const std::vector<TmpVar>& vars, std::string pfx = "", int mode = 0) const;
   void show_var_list(std::ostream& os, const std::vector<var_idx_t>& idx_list, const std::vector<TmpVar>& vars) const;
   void show_var_list(std::ostream& os, const std::vector<VarDescr>& list, const std::vector<TmpVar>& vars) const;