[interpreter] Bytecode register optimizer.

test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden

 #
 # Autogenerated by generate-bytecode-expectations.
 #
 
 ---
 pool type: string
 execute: yes
 wrap: yes
 
 ---
@@ skipping 26 matching lines @@
 ]
 
 ---
 snippet: "
   var x = 55;
   var y = (x = 100);
   return y;
 "
 frame size: 2
 parameter count: 1
-bytecode array length: 12
+bytecode array length: 14
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), U8(55),
   /*   42 E> */ B(Star), R(0),
   /*   57 S> */ B(LdaSmi), U8(100),
   /*   57 E> */ B(Star), R(0),
   /*   57 E> */ B(Star), R(1),
+  /*   65 S> */ B(Ldar), R(1),

[Yang, 2016/05/20 08:00:55]

How come we now have an additional position? It used to be that for something
like

function f() {
  var a = 1;
  return a;
}

In FCG we have a break at the start of the return-statement, and one at the end
of the function. In bytecode, since the return value is already in the
accumulator, we don't have the break at the start of the return-statement
anymore.

I had to fix a bunch of test cases that expected the FCG behavior.

Did this change?

[oth, 2016/05/20 09:01:04]

Yes, it matches FCG behavior. With the register optimizer and the new peephole
optimizer we are trying much harder to preserve source positions. The code on
the LHS here has been through the peephole optimizer and has dropped some source
positions. We no longer do this.

For this specific test the output is exactly the same as having no bytecode
optimizations (no peephole and no register equivalence optimization). 

   /*   75 S> */ B(Return),
 ]
 constant pool: [
 ]
 handlers: [
 ]
 
 ---
 snippet: "
   var x = 55;
   x = x + (x = 100) + (x = 101);
   return x;
 "
 frame size: 3
 parameter count: 1
-bytecode array length: 24
+bytecode array length: 27
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), U8(55),
   /*   42 E> */ B(Star), R(0),
-  /*   46 S> */ B(Star), R(1),
-                B(LdaSmi), U8(100),
-  /*   57 E> */ B(Star), R(0),
+  /*   46 S> */ B(LdaSmi), U8(100),
+  /*   57 E> */ B(Mov), R(0), R(1),
+                B(Star), R(0),
                 B(Add), R(1),
                 B(Star), R(2),
                 B(LdaSmi), U8(101),
   /*   69 E> */ B(Star), R(0),
                 B(Add), R(2),
   /*   48 E> */ B(Star), R(0),
+  /*   77 S> */ B(Ldar), R(0),

[Yang, 2016/05/20 08:00:55]

Ditto. This even seems unnecessary, since Ldar R0 should be a no-op?

[oth, 2016/05/20 09:01:04]

The question is whether it's better to match FCG or to be microscopically
faster. There is a CL that peephole optimizes the Mov R0, R1; Star R0 here to
Ldar R0; Star R1.

Overall, the savings from the register optimization are pretty good:

https://docs.google.com/spreadsheets/d/1lKozV5gf9zUmsz8FrJgOzscDDoReZJxaZqfRS...

   /*   87 S> */ B(Return),
 ]
 constant pool: [
 ]
 handlers: [
 ]
 
 ---
 snippet: "
   var x = 55;
   x = (x = 56) - x + (x = 57);
   x++;
   return x;
 "
 frame size: 3
 parameter count: 1
-bytecode array length: 32
+bytecode array length: 30
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), U8(55),
   /*   42 E> */ B(Star), R(0),
   /*   46 S> */ B(LdaSmi), U8(56),
   /*   53 E> */ B(Star), R(0),
-                B(Star), R(1),
-  /*   61 E> */ B(Ldar), R(0),
-                B(Sub), R(1),
+  /*   61 E> */ B(Sub), R(0),
                 B(Star), R(2),
                 B(LdaSmi), U8(57),
   /*   68 E> */ B(Star), R(0),
                 B(Add), R(2),
   /*   48 E> */ B(Star), R(0),
   /*   75 S> */ B(ToNumber),
                 B(Star), R(1),
                 B(Inc),
   /*   76 E> */ B(Star), R(0),
+  /*   80 S> */ B(Ldar), R(0),
   /*   90 S> */ B(Return),
 ]
 constant pool: [
 ]
 handlers: [
 ]
 
 ---
 snippet: "
   var x = 55;
   var y = x + (x = 1) + (x = 2) + (x = 3);
   return y;
 "
 frame size: 4
 parameter count: 1
-bytecode array length: 32
+bytecode array length: 35
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), U8(55),
   /*   42 E> */ B(Star), R(0),
-  /*   76 S> */ B(Star), R(2),
-                B(LdaSmi), U8(1),
-  /*   61 E> */ B(Star), R(0),
+  /*   76 S> */ B(LdaSmi), U8(1),
+  /*   61 E> */ B(Mov), R(0), R(2),
+                B(Star), R(0),
                 B(Add), R(2),
                 B(Star), R(3),
                 B(LdaSmi), U8(2),
   /*   71 E> */ B(Star), R(0),
                 B(Add), R(3),
                 B(Star), R(2),
                 B(LdaSmi), U8(3),
   /*   81 E> */ B(Star), R(0),
                 B(Add), R(2),
   /*   76 E> */ B(Star), R(1),
+  /*   87 S> */ B(Ldar), R(1),
   /*   97 S> */ B(Return),
 ]
 constant pool: [
 ]
 handlers: [
 ]
 
 ---
 snippet: "
   var x = 55;
   var x = x + (x = 1) + (x = 2) + (x = 3);
   return x;
 "
 frame size: 3
 parameter count: 1
-bytecode array length: 32
+bytecode array length: 35
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), U8(55),
   /*   42 E> */ B(Star), R(0),
-  /*   76 S> */ B(Star), R(1),
-                B(LdaSmi), U8(1),
-  /*   61 E> */ B(Star), R(0),
+  /*   76 S> */ B(LdaSmi), U8(1),
+  /*   61 E> */ B(Mov), R(0), R(1),
+                B(Star), R(0),
                 B(Add), R(1),
                 B(Star), R(2),
                 B(LdaSmi), U8(2),
   /*   71 E> */ B(Star), R(0),
                 B(Add), R(2),
                 B(Star), R(1),
                 B(LdaSmi), U8(3),
   /*   81 E> */ B(Star), R(0),
                 B(Add), R(1),
   /*   76 E> */ B(Star), R(0),
+  /*   87 S> */ B(Ldar), R(0),
   /*   97 S> */ B(Return),
 ]
 constant pool: [
 ]
 handlers: [
 ]
 
 ---
 snippet: "
   var x = 10, y = 20;
   return x + (x = 1) + (x + 1) * (y = 2) + (y = 3) + (x = 4) + (y = 5) + y;
 "
 frame size: 5
 parameter count: 1
-bytecode array length: 70
+bytecode array length: 65
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), U8(10),
   /*   42 E> */ B(Star), R(0),
   /*   50 S> */ B(LdaSmi), U8(20),
   /*   50 E> */ B(Star), R(1),
-  /*   54 S> */ B(Ldar), R(0),
-                B(Star), R(2),
-                B(LdaSmi), U8(1),
-  /*   68 E> */ B(Star), R(0),
+  /*   54 S> */ B(LdaSmi), U8(1),
+  /*   68 E> */ B(Mov), R(0), R(2),
+                B(Star), R(0),
                 B(Add), R(2),
                 B(Star), R(3),
-  /*   76 E> */ B(Ldar), R(0),
-                B(Star), R(2),
-                B(LdaSmi), U8(1),
-                B(Add), R(2),
+  /*   76 E> */ B(LdaSmi), U8(1),
+                B(Add), R(0),
                 B(Star), R(4),
                 B(LdaSmi), U8(2),
   /*   88 E> */ B(Star), R(1),
                 B(Mul), R(4),
                 B(Add), R(3),
                 B(Star), R(2),
                 B(LdaSmi), U8(3),
   /*   98 E> */ B(Star), R(1),
                 B(Add), R(2),
                 B(Star), R(3),
@@ skipping 43 matching lines @@
                 B(Inc),
   /*   72 E> */ B(Star), R(0),
                 B(Add), R(3),
   /*   76 S> */ B(Return),
 ]
 constant pool: [
 ]
 handlers: [
 ]