[Interpreter] Adds an optimization to remove redundant Ldar/Star.

test/cctest/interpreter/test-bytecode-generator.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // TODO(rmcilroy): Remove this define after this flag is turned on globally
 #define V8_IMMINENT_DEPRECATION_WARNINGS
 
 #include "src/v8.h"
 
 #include "src/compiler.h"
@@ skipping 246 matching lines @@
 
 
 TEST(PrimitiveExpressions) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   ExpectedSnippet<int> snippets[] = {
       {"var x = 0; return x;",
        kPointerSize,
        1,
-       6,
+       4,
        {B(LdaZero),     //
         B(Star), R(0),  //
-        B(Ldar), R(0),  //
         B(Return)},
        0},
       {"var x = 0; return x + 3;",
        kPointerSize,
        1,
        8,
        {B(LdaZero),         //
         B(Star), R(0),      //
         B(LdaSmi8), U8(3),  //
         B(Add), R(0),       //
@@ skipping 119 matching lines @@
 
 TEST(LogicalExpressions) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
 
   ExpectedSnippet<int> snippets[] = {
       {"var x = 0; return x || 3;",
        1 * kPointerSize,
        1,
-       10,
+       8,
        {B(LdaZero),                     //
         B(Star), R(0),                  //
-        B(Ldar), R(0),                  //
         B(JumpIfToBooleanTrue), U8(4),  //
         B(LdaSmi8), U8(3),              //
         B(Return)},
        0},
       {"var x = 0; return (x == 1) || 3;",
        1 * kPointerSize,
        1,
        12,
        {B(LdaZero),            //
         B(Star), R(0),         //
         B(LdaSmi8), U8(1),     //
         B(TestEqual), R(0),    //
         B(JumpIfTrue), U8(4),  //
         B(LdaSmi8), U8(3),     //
         B(Return)},
        0},
       {"var x = 0; return x && 3;",
        1 * kPointerSize,
        1,
-       10,
+       8,
        {B(LdaZero),                      //
         B(Star), R(0),                   //
-        B(Ldar), R(0),                   //
         B(JumpIfToBooleanFalse), U8(4),  //
         B(LdaSmi8), U8(3),               //
         B(Return)},
        0},
       {"var x = 0; return (x == 0) && 3;",
        1 * kPointerSize,
        1,
        11,
        {B(LdaZero),             //
         B(Star), R(0),          //
         B(LdaZero),             //
         B(TestEqual), R(0),     //
         B(JumpIfFalse), U8(4),  //
         B(LdaSmi8), U8(3),      //
         B(Return)},
        0},
       {"var x = 0; return x || (1, 2, 3);",
        1 * kPointerSize,
        1,
-       10,
+       8,
        {B(LdaZero),                     //
         B(Star), R(0),                  //
-        B(Ldar), R(0),                  //
         B(JumpIfToBooleanTrue), U8(4),  //
         B(LdaSmi8), U8(3),              //
         B(Return)},
        0},
       {"var a = 2, b = 3, c = 4; return a || (a, b, a, b, c = 5, 3);",
        3 * kPointerSize,
        1,
        23,
        {B(LdaSmi8), U8(2),              //
         B(Star), R(0),                  //
@@ skipping 112 matching lines @@
       {"return 1 || 3;",
        0 * kPointerSize,
        1,
        3,
        {B(LdaSmi8), U8(1),  //
         B(Return)},
        0},
       {"var x = 1; return x && 3 || 0, 1;",
        1 * kPointerSize,
        1,
-       16,
+       14,
        {B(LdaSmi8), U8(1),               //
         B(Star), R(0),                   //
-        B(Ldar), R(0),                   //
         B(JumpIfToBooleanFalse), U8(4),  //
         B(LdaSmi8), U8(3),               //
         B(JumpIfToBooleanTrue), U8(3),   //
         B(LdaZero),                      //
         B(LdaSmi8), U8(1),               //
         B(Return)},
        0}};
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
@@ skipping 1050 matching lines @@
        2,
        {
            B(LdaUndefined),  //
            B(Return),        //
        },
        0,
        {unused, unused, unused, unused, unused, unused}},
       {"function f() { var a = 1; if (a) { a += 1; } else { return 2; } } f();",
        1 * kPointerSize,
        1,
-       21,
+       19,
        {
            B(LdaSmi8), U8(1),                //
            B(Star), R(0),                    //
-           B(Ldar), R(0),                    //
            B(JumpIfToBooleanFalse), U8(10),  //
            B(LdaSmi8), U8(1),                //
            B(Add), R(0),                     //
            B(Star), R(0),                    //
            B(Jump), U8(5),                   //
            B(LdaSmi8), U8(2),                //
            B(Return),                        //
            B(LdaUndefined),                  //
            B(Return),                        //
        },
@@ skipping 30 matching lines @@
            B(JumpIfFalse), U8(5),  //
            B(LdaConstant), U8(0),  //
            B(Return),              //
            B(LdaUndefined),        //
            B(Return),              //
        },
        1,
        {helper.factory()->NewNumberFromInt(200), unused, unused, unused, unused,
         unused}},
       {"function f(z) { var a = 0; var b = 0; if (a === 0.01) { "
-       REPEAT_32(SPACE, "b = a; a = b; ")
+       REPEAT_64(SPACE, "b = a; a = b; ")
        " return 200; } else { return -200; } } f(0.001)",
        2 * kPointerSize,
        2,
-       276,
+       278,
        {
            B(LdaZero),                     //
            B(Star), R(0),                  //
            B(LdaZero),                     //
            B(Star), R(1),                  //
            B(LdaConstant), U8(0),          //
            B(TestEqualStrict), R(0),       //
            B(JumpIfFalseConstant), U8(2),  //
-           REPEAT_32(COMMA,                //
-             B(Ldar), R(0),                //
+           B(Ldar), R(0),                  //
+           REPEAT_64(COMMA,                //
              B(Star), R(1),                //
-             B(Ldar), R(1),                //
              B(Star), R(0)),               //
            B(LdaConstant), U8(1),          //
            B(Return),                      //
            B(LdaConstant), U8(3),          //
            B(Return),                      //
            B(LdaUndefined),                //
            B(Return)},                     //
        4,
        {helper.factory()->NewHeapNumber(0.01),
         helper.factory()->NewNumberFromInt(200),
-        helper.factory()->NewNumberFromInt(261),
+        helper.factory()->NewNumberFromInt(263),
         helper.factory()->NewNumberFromInt(-200), unused, unused}},
       {"function f() { var a = 0; var b = 0; if (a) { "
-       REPEAT_32(SPACE, "b = a; a = b; ")
+       REPEAT_64(SPACE, "b = a; a = b; ")
        " return 200; } else { return -200; } } f()",
        2 * kPointerSize,
        1,
-       274,
+       276,
        {
            B(LdaZero),                              //
            B(Star), R(0),                           //
            B(LdaZero),                              //
            B(Star), R(1),                           //
            B(Ldar), R(0),                           //
            B(JumpIfToBooleanFalseConstant), U8(1),  //
-           REPEAT_32(COMMA,                         //
-             B(Ldar), R(0),                         //
+           B(Ldar), R(0),                           //
+           REPEAT_64(COMMA,                         //
              B(Star), R(1),                         //
-             B(Ldar), R(1),                         //
              B(Star), R(0)),                        //
            B(LdaConstant), U8(0),                   //
            B(Return),                               //
            B(LdaConstant), U8(2),                   //
            B(Return),                               //
            B(LdaUndefined),                         //
            B(Return)},                              //
        3,
        {helper.factory()->NewNumberFromInt(200),
-        helper.factory()->NewNumberFromInt(261),
+        helper.factory()->NewNumberFromInt(263),
         helper.factory()->NewNumberFromInt(-200), unused, unused, unused}},
 
       {"function f(a, b) {\n"
        "  if (a == b) { return 1; }\n"
        "  if (a === b) { return 1; }\n"
        "  if (a < b) { return 1; }\n"
        "  if (a > b) { return 1; }\n"
        "  if (a <= b) { return 1; }\n"
        "  if (a >= b) { return 1; }\n"
        "  if (a in b) { return 1; }\n"
@@ skipping 26 matching lines @@
       {"function f() {"
        " var a = 0;"
        " if (a) {"
        "  return 20;"
        "} else {"
        "  return -20;}"
        "};"
        "f();",
        1 * kPointerSize,
        1,
-       15,
+       13,
        {
            B(LdaZero),                      //
            B(Star), R(0),                   //
-           B(Ldar), R(0),                   //
            B(JumpIfToBooleanFalse), U8(5),  //
            B(LdaSmi8), U8(20),              //
            B(Return),                       //
            B(LdaSmi8), U8(-20),             //
            B(Return),                       //
            B(LdaUndefined),                 //
            B(Return)
        },
        0,
-       {unused, unused, unused, unused, unused, unused}}
-  };
+       {unused, unused, unused, unused, unused, unused}}};
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(snippets[i].code_snippet, helper.kFunctionName);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(DeclareGlobals) {
@@ skipping 51 matching lines @@
            B(Star), R(1),                                               //
            B(CallRuntime), U16(Runtime::kDeclareGlobals), R(0), U8(2),  //
            B(LdaUndefined),                                             //
            B(Return)                                                    //
        },
        1,
        {InstanceType::FIXED_ARRAY_TYPE}},
       {"var a = 1;\na=2;",
        4 * kPointerSize,
        1,
-       38,
+       36,
        {
            B(LdaConstant), U8(0),                                            //
            B(Star), R(1),                                                    //
            B(LdaZero),                                                       //
            B(Star), R(2),                                                    //
            B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),       //
            B(LdaConstant), U8(1),                                            //
            B(Star), R(1),                                                    //
            B(LdaZero),                                                       //
            B(Star), R(2),                                                    //
            B(LdaSmi8), U8(1),                                                //
            B(Star), R(3),                                                    //
            B(CallRuntime), U16(Runtime::kInitializeVarGlobal), R(1), U8(3),  //
            B(LdaSmi8), U8(2),                                                //
            B(StaGlobalSloppy), U8(1),                                        //
                                U8(store_vector->GetIndex(store_slot_2)),     //
            B(Star), R(0),                                                    //
-           B(Ldar), R(0),                                                    //
            B(Return)                                                         //
        },
        2,
        {InstanceType::FIXED_ARRAY_TYPE,
         InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
       {"function f() {}\nf();",
        3 * kPointerSize,
        1,
-       29,
+       27,
        {
            B(LdaConstant), U8(0),                                       //
            B(Star), R(1),                                               //
            B(LdaZero),                                                  //
            B(Star), R(2),                                               //
            B(CallRuntime), U16(Runtime::kDeclareGlobals), R(1), U8(2),  //
            B(LdaUndefined),                                             //
            B(Star), R(2),                                               //
            B(LdaGlobalSloppy), U8(1),                                   //
                                U8(load_vector->GetIndex(load_slot_1)),  //
            B(Star), R(1),                                               //
            B(Call), R(1), R(2), U8(0),                                  //
            B(Star), R(0),                                               //
-           B(Ldar), R(0),                                               //
            B(Return)                                                    //
        },
        2,
        {InstanceType::FIXED_ARRAY_TYPE,
         InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeTopLevelBytecode(snippets[i].code_snippet);
@@ skipping 226 matching lines @@
            B(LdaSmi8), U8(1),                //
            B(Sub), R(0),                     //
            B(Star), R(0),                    //
            B(Ldar), R(0),                    //
            B(JumpIfToBooleanTrue), U8(-14),  //
            B(Ldar), R(1),                    //
            B(Return),                        //
         },
        0},
       {"var x = 10;"
-        "var y = 1;"
-        "do {"
-        "  y = y * 12;"
-        "  x = x - 1;"
-        "} while(x);"
-        "return y;",
-        2 * kPointerSize,
-        1,
-        27,
-        {
+       "var y = 1;"
+       "do {"
+       "  y = y * 12;"
+       "  x = x - 1;"
+       "} while(x);"
+       "return y;",
+       2 * kPointerSize,
+       1,
+       27,
+       {
            B(LdaSmi8), U8(10),               //
            B(Star), R(0),                    //
            B(LdaSmi8), U8(1),                //
            B(Star), R(1),                    //
            B(LdaSmi8), U8(12),               //
            B(Mul), R(1),                     //
            B(Star), R(1),                    //
            B(LdaSmi8), U8(1),                //
            B(Sub), R(0),                     //
            B(Star), R(0),                    //
            B(Ldar), R(0),                    //
            B(JumpIfToBooleanTrue), U8(-14),  //
            B(Ldar), R(1),                    //
            B(Return),                        //
-        },
+       },
        0},
       {"var y = 1;"
        "for (var x = 10; x; --x) {"
        "  y = y * 12;"
        "}"
        "return y;",
        2 * kPointerSize,
        1,
        29,
        {
@@ skipping 84 matching lines @@
            B(Return),              //
        },
        0},
       {"var x = 0;"
        "while(false) {"
        "  x = x + 1;"
        "};"
        "return x;",
        1 * kPointerSize,
        1,
-       6,
+       4,
        {
            B(LdaZero),     //
            B(Star), R(0),  //
-           B(Ldar), R(0),  //
            B(Return),      //
        },
        0},
       {"var x = 0;"
        "for( var i = 0; false; i++) {"
        "  x = x + 1;"
        "};"
        "return x;",
        2 * kPointerSize,
        1,
@@ skipping 108 matching lines @@
            B(Mul), R(0),         //
            B(LdaUndefined),      //
            B(Return),            //
        },
        0},
       {"var x = 1234;"
        "var y = void (x * x - 1);"
        "return y;",
        3 * kPointerSize,
        1,
-       20,
+       16,
        {
            B(LdaConstant), U8(0),  //
            B(Star), R(0),          //
-           B(Ldar), R(0),          //
            B(Mul), R(0),           //
            B(Star), R(2),          //
            B(LdaSmi8), U8(1),      //
            B(Sub), R(2),           //
            B(LdaUndefined),        //
            B(Star), R(1),          //
-           B(Ldar), R(1),          //
            B(Return),              //
        },
        1,
        {1234}},
       {"var x = 13;"
        "return ~x;",
        1 * kPointerSize,
        1,
        9,
        {
@@ skipping 50 matching lines @@
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
 
   ExpectedSnippet<const char*> snippets[] = {
       {"function f() {\n"
        " var x = 13;\n"
        " return typeof(x);\n"
        "}; f();",
        kPointerSize,
        1,
-       8,
+       6,
        {
            B(LdaSmi8), U8(13),  //
-           B(Star), R(0),       // TODO(oth): Ldar R(X) following Star R(X)
-           B(Ldar), R(0),       // could be culled in bytecode array builder.
+           B(Star), R(0),       //
            B(TypeOf),           //
            B(Return),           //
        }},
       {"var x = 13;\n"
        "function f() {\n"
        " return typeof(x);\n"
        "}; f();",
        0,
        1,
        5,
@@ skipping 968 matching lines @@
        3,
        {
            B(LdaConstant), U8(0),  //
            B(Throw),               //
        },
        1,
        {"Error"}},
       {"var a = 1; if (a) { throw 'Error'; };",
        1 * kPointerSize,
        1,
-       13,
+       11,
        {
            B(LdaSmi8), U8(1),               //
            B(Star), R(0),                   //
-           B(Ldar), R(0),                   //
            B(JumpIfToBooleanFalse), U8(5),  //
            B(LdaConstant), U8(0),           //
            B(Throw),                        //
            B(LdaUndefined),                 //
            B(Return),                       //
        },
        1,
        {"Error"}},
   };
 
@@ skipping 367 matching lines @@
 
   int object_literal_flags =
       ObjectLiteral::kFastElements | ObjectLiteral::kDisableMementos;
   int array_literal_flags =
       ArrayLiteral::kDisableMementos | ArrayLiteral::kShallowElements;
 
   ExpectedSnippet<InstanceType> snippets[] = {
       {"var a = 1; return ++a;",
        1 * kPointerSize,
        1,
-       11,
+       9,
        {
            B(LdaSmi8), U8(1),  //
            B(Star), R(0),      //
-           B(Ldar), R(0),      //
            B(ToNumber),        //
            B(Inc),             //
            B(Star), R(0),      //
            B(Return),          //
        }},
       {"var a = 1; return a++;",
        2 * kPointerSize,
        1,
-       15,
+       13,
        {
            B(LdaSmi8), U8(1),  //
            B(Star), R(0),      //
-           B(Ldar), R(0),      //
            B(ToNumber),        //
            B(Star), R(1),      //
            B(Inc),             //
            B(Star), R(0),      //
            B(Ldar), R(1),      //
            B(Return),          //
        }},
       {"var a = 1; return --a;",
        1 * kPointerSize,
        1,
-       11,
+       9,
        {
            B(LdaSmi8), U8(1),  //
            B(Star), R(0),      //
-           B(Ldar), R(0),      //
            B(ToNumber),        //
            B(Dec),             //
            B(Star), R(0),      //
            B(Return),          //
        }},
       {"var a = 1; return a--;",
        2 * kPointerSize,
        1,
-       15,
+       13,
        {
            B(LdaSmi8), U8(1),  //
            B(Star), R(0),      //
-           B(Ldar), R(0),      //
            B(ToNumber),        //
            B(Star), R(1),      //
            B(Dec),             //
            B(Star), R(0),      //
            B(Ldar), R(1),      //
            B(Return),          //
        }},
       {"var a = { val: 1 }; return a.val++;",
        2 * kPointerSize,
        1,
@@ skipping 407 matching lines @@
   FeedbackVectorSpec feedback_spec(&zone);
   FeedbackVectorSlot slot = feedback_spec.AddKeyedLoadICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
 
   ExpectedSnippet<const char*> snippets[] = {
       {"function f() { return arguments; }",
        1 * kPointerSize,
        1,
-       6,
+       4,
        {
            B(CreateMappedArguments),  //
            B(Star), R(0),             //
-           B(Ldar), R(0),             //
            B(Return),                 //
        }},
       {"function f() { return arguments[0]; }",
        1 * kPointerSize,
        1,
        8,
        {
            B(CreateMappedArguments),                                //
            B(Star), R(0),                                           //
            B(LdaZero),                                              //
            B(KeyedLoadICSloppy), R(0), U8(vector->GetIndex(slot)),  //
            B(Return),                                               //
        }},
       {"function f() { 'use strict'; return arguments; }",
        1 * kPointerSize,
        1,
-       6,
+       4,
        {
            B(CreateUnmappedArguments),  //
            B(Star), R(0),               //
-           B(Ldar), R(0),               //
            B(Return),                   //
        }},
       {"function f(a) { return arguments[0]; }",
        2 * kPointerSize,
        2,
        20,
        {
            B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure),  //
                            U8(1),                                          //
            B(PushContext), R(1),                                           //
            B(Ldar), R(BytecodeGeneratorHelper::kLastParamIndex),           //
            B(StaContextSlot), R(1), U8(first_context_slot),                //
            B(CreateMappedArguments),                                       //
            B(Star), R(0),                                                  //
            B(LdaZero),                                                     //
            B(KeyedLoadICSloppy), R(0), U8(vector->GetIndex(slot)),         //
            B(Return),                                                      //
        }},
       {"function f(a, b, c) { return arguments; }",
        2 * kPointerSize,
        4,
-       28,
+       26,
        {
            B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure),  //
                            U8(1),                                          //
            B(PushContext), R(1),                                           //
            B(Ldar), R(BytecodeGeneratorHelper::kLastParamIndex - 2),       //
            B(StaContextSlot), R(1), U8(first_context_slot + 2),            //
            B(Ldar), R(BytecodeGeneratorHelper::kLastParamIndex - 1),       //
            B(StaContextSlot), R(1), U8(first_context_slot + 1),            //
            B(Ldar), R(BytecodeGeneratorHelper::kLastParamIndex),           //
            B(StaContextSlot), R(1), U8(first_context_slot),                //
            B(CreateMappedArguments),                                       //
            B(Star), R(0),                                                  //
-           B(Ldar), R(0),                                                  //
            B(Return),                                                      //
        }},
       {"function f(a, b, c) { 'use strict'; return arguments; }",
        1 * kPointerSize,
        4,
-       6,
+       4,
        {
            B(CreateUnmappedArguments),  //
            B(Star), R(0),               //
-           B(Ldar), R(0),               //
            B(Return),                   //
        }},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunction(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
@@ skipping 56 matching lines @@
       {"for (var p in undefined) {}",
        2 * kPointerSize,
        1,
        2,
        {B(LdaUndefined), B(Return)},
        0},
       {"var x = 'potatoes';\n"
        "for (var p in x) { return p; }",
        5 * kPointerSize,
        1,
-       52,
+       46,
        {
            B(LdaConstant), U8(0),                                             //
            B(Star), R(1),                                                     //
-           B(Ldar), R(1),                                                     //
-           B(JumpIfUndefined), U8(44),                                        //
-           B(JumpIfNull), U8(42),                                             //
+           B(JumpIfUndefined), U8(40),                                        //
+           B(JumpIfNull), U8(38),                                             //
            B(ToObject),                                                       //
            B(Star), R(3),                                                     //
            B(CallRuntime), U16(Runtime::kGetPropertyNamesFast), R(3), U8(1),  //
            B(ForInPrepare), R(3),                                             //
-           B(JumpIfUndefined), U8(30),                                        //
+           B(JumpIfUndefined), U8(26),                                        //
            B(Star), R(4),                                                     //
            B(LdaZero),                                                        //
            B(Star), R(3),                                                     //
            B(ForInDone), R(4),                                                //
-           B(JumpIfTrue), U8(21),                                             //
+           B(JumpIfTrue), U8(17),                                             //
            B(ForInNext), R(4), R(3),                                          //
-           B(JumpIfUndefined), U8(11),                                        //
+           B(JumpIfUndefined), U8(7),                                         //
            B(Star), R(0),                                                     //
-           B(Ldar), R(0),                                                     //
            B(Star), R(2),                                                     //
-           B(Ldar), R(2),                                                     //
            B(Return),                                                         //
            B(Ldar), R(3),                                                     //
            B(Inc),                                                            //
-           B(Jump), U8(-23),                                                  //
+           B(Jump), U8(-19),                                                  //
            B(LdaUndefined),                                                   //
            B(Return),                                                         //
        },
        1,
        {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
       {"var x = 0;\n"
        "for (var p in [1,2,3]) { x += p; }",
        5 * kPointerSize,
        1,
-       57,
+       53,
        {
            B(LdaZero),                                                        //
            B(Star), R(1),                                                     //
            B(LdaConstant), U8(0),                                             //
            B(CreateArrayLiteral), U8(0), U8(simple_flags),                    //
-           B(JumpIfUndefined), U8(47),                                        //
-           B(JumpIfNull), U8(45),                                             //
+           B(JumpIfUndefined), U8(43),                                        //
+           B(JumpIfNull), U8(41),                                             //
            B(ToObject),                                                       //
            B(Star), R(3),                                                     //
            B(CallRuntime), U16(Runtime::kGetPropertyNamesFast), R(3), U8(1),  //
            B(ForInPrepare), R(3),                                             //
-           B(JumpIfUndefined), U8(33),                                        //
+           B(JumpIfUndefined), U8(29),                                        //
            B(Star), R(4),                                                     //
            B(LdaZero),                                                        //
            B(Star), R(3),                                                     //
            B(ForInDone), R(4),                                                //
-           B(JumpIfTrue), U8(24),                                             //
+           B(JumpIfTrue), U8(20),                                             //
            B(ForInNext), R(4), R(3),                                          //
-           B(JumpIfUndefined), U8(14),                                        //
+           B(JumpIfUndefined), U8(10),                                        //
            B(Star), R(0),                                                     //
-           B(Ldar), R(0),                                                     //
            B(Star), R(2),                                                     //
-           B(Ldar), R(2),                                                     //
            B(Add), R(1),                                                      //
            B(Star), R(1),                                                     //
            B(Ldar), R(3),                                                     //
            B(Inc),                                                            //
-           B(Jump), U8(-26),                                                  //
+           B(Jump), U8(-22),                                                  //
            B(LdaUndefined),                                                   //
            B(Return),                                                         //
        },
        1,
        {InstanceType::FIXED_ARRAY_TYPE}},
       {"var x = { 'a': 1, 'b': 2 };\n"
        "for (x['a'] in [10, 20, 30]) {\n"
        "  if (x['a'] == 10) continue;\n"
        "  if (x['a'] == 20) break;\n"
        "}",
@@ skipping 142 matching lines @@
   BytecodeGeneratorHelper helper;
 
   ExpectedSnippet<int> snippets[] = {
       {"var a = 1;\n"
        "switch(a) {\n"
        " case 1: return 2;\n"
        " case 2: return 3;\n"
        "}\n",
        2 * kPointerSize,
        1,
-       30,
+       28,
        {
            B(LdaSmi8), U8(1),         //
            B(Star), R(1),             // The tag variable is allocated as a
-           B(Ldar), R(1),             // local by the parser, hence this
-           B(Star), R(0),             // strange shuffling.
-           B(LdaSmi8), U8(1),         //
+           B(Star), R(0),             // local by the parser, hence the store
+           B(LdaSmi8), U8(1),         // to another local register.
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(10),     //
            B(LdaSmi8), U8(2),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(7),      //
            B(Jump), U8(8),            //
            B(LdaSmi8), U8(2),         //
            B(Return),                 //
            B(LdaSmi8), U8(3),         //
            B(Return),                 //
            B(LdaUndefined),           //
            B(Return),                 //
        }},
       {"var a = 1;\n"
        "switch(a) {\n"
        " case 1: a = 2; break;\n"
        " case 2: a = 3; break;\n"
        "}\n",
        2 * kPointerSize,
        1,
-       36,
+       34,
        {
            B(LdaSmi8), U8(1),         //
            B(Star), R(1),             //
-           B(Ldar), R(1),             //
            B(Star), R(0),             //
            B(LdaSmi8), U8(1),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(10),     //
            B(LdaSmi8), U8(2),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(10),     //
            B(Jump), U8(14),           //
            B(LdaSmi8), U8(2),         //
            B(Star), R(1),             //
            B(Jump), U8(8),            //
            B(LdaSmi8), U8(3),         //
            B(Star), R(1),             //
            B(Jump), U8(2),            //
            B(LdaUndefined),           //
            B(Return),                 //
        }},
       {"var a = 1;\n"
        "switch(a) {\n"
        " case 1: a = 2; // fall-through\n"
        " case 2: a = 3; break;\n"
        "}\n",
        2 * kPointerSize,
        1,
-       34,
+       32,
        {
            B(LdaSmi8), U8(1),         //
            B(Star), R(1),             //
-           B(Ldar), R(1),             //
            B(Star), R(0),             //
            B(LdaSmi8), U8(1),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(10),     //
            B(LdaSmi8), U8(2),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(8),      //
            B(Jump), U8(12),           //
            B(LdaSmi8), U8(2),         //
            B(Star), R(1),             //
            B(LdaSmi8), U8(3),         //
            B(Star), R(1),             //
            B(Jump), U8(2),            //
            B(LdaUndefined),           //
            B(Return),                 //
        }},
       {"var a = 1;\n"
        "switch(a) {\n"
        " case 2: break;\n"
        " case 3: break;\n"
        " default: a = 1; break;\n"
        "}\n",
        2 * kPointerSize,
        1,
-       34,
+       32,
        {
            B(LdaSmi8), U8(1),         //
            B(Star), R(1),             //
-           B(Ldar), R(1),             //
            B(Star), R(0),             //
            B(LdaSmi8), U8(2),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(10),     //
            B(LdaSmi8), U8(3),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(6),      //
            B(Jump), U8(6),            //
            B(Jump), U8(10),           //
            B(Jump), U8(8),            //
            B(LdaSmi8), U8(1),         //
            B(Star), R(1),             //
            B(Jump), U8(2),            //
            B(LdaUndefined),           //
            B(Return),                 //
        }},
       {"var a = 1;\n"
        "switch(typeof(a)) {\n"
        " case 2: a = 1; break;\n"
        " case 3: a = 2; break;\n"
        " default: a = 3; break;\n"
        "}\n",
        2 * kPointerSize,
        1,
-       43,
+       41,
        {
            B(LdaSmi8), U8(1),         //
            B(Star), R(1),             //
-           B(Ldar), R(1),             //
            B(TypeOf),                 //
            B(Star), R(0),             //
            B(LdaSmi8), U8(2),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(10),     //
            B(LdaSmi8), U8(3),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(10),     //
            B(Jump), U8(14),           //
            B(LdaSmi8), U8(1),         //
            B(Star), R(1),             //
            B(Jump), U8(14),           //
            B(LdaSmi8), U8(2),         //
            B(Star), R(1),             //
            B(Jump), U8(8),            //
            B(LdaSmi8), U8(3),         //
            B(Star), R(1),             //
            B(Jump), U8(2),            //
            B(LdaUndefined),           //
            B(Return),                 //
        }},
       {"var a = 1;\n"
        "switch(a) {\n"
        " case typeof(a): a = 1; break;\n"
        " default: a = 2; break;\n"
        "}\n",
        2 * kPointerSize,
        1,
-       31,
+       29,
        {
            B(LdaSmi8), U8(1),         //
            B(Star), R(1),             //
-           B(Ldar), R(1),             //
            B(Star), R(0),             //
            B(Ldar), R(1),             //
            B(TypeOf),                 //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(4),      //
            B(Jump), U8(8),            //
            B(LdaSmi8), U8(1),         //
            B(Star), R(1),             //
            B(Jump), U8(8),            //
            B(LdaSmi8), U8(2),         //
            B(Star), R(1),             //
            B(Jump), U8(2),            //
            B(LdaUndefined),           //
            B(Return),                 //
        }},
       {"var a = 1;\n"
        "switch(a) {\n"
        " case 1:\n" REPEAT_64(SPACE, "  a = 2;")
        "break;\n"
        " case 2: a = 3; break;"
        "}\n",
        2 * kPointerSize,
        1,
-       288,
+       286,
        {
            B(LdaSmi8), U8(1),             //
            B(Star), R(1),                 //
-           B(Ldar), R(1),                 //
            B(Star), R(0),                 //
            B(LdaSmi8), U8(1),             //
            B(TestEqualStrict), R(0),      //
            B(JumpIfTrue), U8(10),         //
            B(LdaSmi8), U8(2),             //
            B(TestEqualStrict), R(0),      //
            B(JumpIfTrueConstant), U8(0),  //
            B(JumpConstant), U8(1),        //
            REPEAT_64(COMMA,               //
               B(LdaSmi8), U8(2),          //
@@ skipping 11 matching lines @@
        "switch(a) {\n"
        " case 1: \n"
        "   switch(a + 1) {\n"
        "      case 2 : a = 1; break;\n"
        "      default : a = 2; break;\n"
        "   }  // fall-through\n"
        " case 2: a = 3;\n"
        "}\n",
        3 * kPointerSize,
        1,
-       54,
+       52,
        {
            B(LdaSmi8), U8(1),         //
            B(Star), R(2),             //
-           B(Ldar), R(2),             //
            B(Star), R(0),             //
            B(LdaSmi8), U8(1),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(10),     //
            B(LdaSmi8), U8(2),         //
            B(TestEqualStrict), R(0),  //
            B(JumpIfTrue), U8(30),     //
            B(Jump), U8(32),           //
            B(LdaSmi8), U8(1),         //
            B(Add), R(2),              //
@@ skipping 26 matching lines @@
 TEST(BasicBlockToBoolean) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   // Check that we don't omit ToBoolean calls if they are at the start of basic
   // blocks.
   ExpectedSnippet<int> snippets[] = {
       {"var a = 1; if (a || a < 0) { return 1; }",
        1 * kPointerSize,
        1,
-       18,
+       16,
        {
            B(LdaSmi8), U8(1),               //
            B(Star), R(0),                   //
-           B(Ldar), R(0),                   //
            B(JumpIfToBooleanTrue), U8(5),   //
            B(LdaZero),                      //
            B(TestLessThan), R(0),           //
            B(JumpIfToBooleanFalse), U8(5),  //
            B(LdaSmi8), U8(1),               //
            B(Return),                       //
            B(LdaUndefined),                 //
            B(Return),                       //
        }},
       {"var a = 1; if (a && a < 0) { return 1; }",
        1 * kPointerSize,
        1,
-       18,
+       16,
        {
            B(LdaSmi8), U8(1),               //
            B(Star), R(0),                   //
-           B(Ldar), R(0),                   //
            B(JumpIfToBooleanFalse), U8(5),  //
            B(LdaZero),                      //
            B(TestLessThan), R(0),           //
            B(JumpIfToBooleanFalse), U8(5),  //
            B(LdaSmi8), U8(1),               //
            B(Return),                       //
            B(LdaUndefined),                 //
            B(Return),                       //
        }},
       {"var a = 1; a = (a || a < 0) ? 2 : 3;",
        1 * kPointerSize,
        1,
-       23,
+       21,
        {
            B(LdaSmi8), U8(1),               //
            B(Star), R(0),                   //
-           B(Ldar), R(0),                   //
            B(JumpIfToBooleanTrue), U8(5),   //
            B(LdaZero),                      //
            B(TestLessThan), R(0),           //
            B(JumpIfToBooleanFalse), U8(6),  //
            B(LdaSmi8), U8(2),               //
            B(Jump), U8(4),                  //
            B(LdaSmi8), U8(3),               //
            B(Star), R(0),                   //
            B(LdaUndefined),                 //
            B(Return),                       //
@@ skipping 35 matching lines @@
        0,
        1,
        3,
        {
            B(LdaSmi8), U8(1),  //
            B(Return),          //
        }},
       {"var a = 1; if (a) { return 1; }; return 2;",
        1 * kPointerSize,
        1,
-       14,
+       12,
        {
            B(LdaSmi8), U8(1),               //
            B(Star), R(0),                   //
-           B(Ldar), R(0),                   //
            B(JumpIfToBooleanFalse), U8(5),  //
            B(LdaSmi8), U8(1),               //
            B(Return),                       //
            B(LdaSmi8), U8(2),               //
            B(Return),                       //
        }},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
@@ skipping 18 matching lines @@
            B(LdaTheHole),        //
            B(Star), R(0),        //
            B(Ldar), R(closure),  //
            B(Star), R(0),        //
            B(LdaUndefined),      //
            B(Return),            //
        }},
       {"var f;\n f = function f() { return f; }",
        1 * kPointerSize,
        1,
-       10,
+       8,
        {
            B(LdaTheHole),        //
            B(Star), R(0),        //
            B(Ldar), R(closure),  //
            B(Star), R(0),        //
-           B(Ldar), R(0),        //
            B(Return),            //
        }},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunction(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(NewTarget) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   ExpectedSnippet<int> snippets[] = {
       {"return new.target;",
        1 * kPointerSize,
        1,
-       10,
+       8,
        {
            B(CallRuntime), U16(Runtime::kGetOriginalConstructor), R(0),  //
                            U8(0),                                        //
            B(Star), R(0),                                                //
-           B(Ldar), R(0),                                                //
            B(Return),                                                    //
        }},
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
+
+TEST(RemoveRedundantLdar) {
+  InitializedHandleScope handle_scope;
+  BytecodeGeneratorHelper helper;
+
+  ExpectedSnippet<int> snippets[] = {
+      {"var ld_a = 1;\n"             // This test is to check Ldar doesnot

[oth, 2015/11/13 10:51:32]

s/doesnot/does not/

[mythria, 2015/11/13 12:36:45]

Done.

+       "while(true) {\n"             // get removed if the preceding Star is
+       "  ld_a = ld_a + ld_a;\n"     // in a different basicblock.
+       "  if (ld_a > 10) break;\n"
+       "}\n"
+       "return ld_a;",
+       1 * kPointerSize,
+       1,
+       23,
+       {
+           B(LdaSmi8), U8(1),         //
+           B(Star), R(0),             //
+           B(Ldar), R(0),             //  This load should not be removed as it
+           B(Add), R(0),              //  is the target of the branch.
+           B(Star), R(0),             //
+           B(LdaSmi8), U8(10),        //
+           B(TestGreaterThan), R(0),  //
+           B(JumpIfFalse), U8(4),     //
+           B(Jump), U8(4),            //
+           B(Jump), U8(-14),          //
+           B(Ldar), R(0),             //
+           B(Return)
+       }},
+      {"var ld_a = 1;\n"
+       "do {\n"
+       "  ld_a = ld_a + ld_a;\n"
+       "  if (ld_a > 10) continue;\n"
+       "} while(false);\n"
+       "return ld_a;",
+       1 * kPointerSize,
+       1,
+       19,
+       {
+           B(LdaSmi8), U8(1),          //
+           B(Star), R(0),              //
+           B(Add), R(0),               //
+           B(Star), R(0),              //
+           B(LdaSmi8), U8(10),         //
+           B(TestGreaterThan), R(0),   //
+           B(JumpIfFalse), U8(4),      //
+           B(Jump), U8(2),             //
+           B(Ldar), R(0),              //
+           B(Return)
+       }},
+  };
+
+  for (size_t i = 0; i < arraysize(snippets); i++) {
+    Handle<BytecodeArray> bytecode_array =
+        helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
+    CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+  }
+}
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8