[Interpreter] Add interpreter support for compare ops and ToBoolean.

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.
 
 #include "src/v8.h"
 
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/interpreter.h"
 #include "test/cctest/cctest.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 class BytecodeGeneratorHelper {
  public:
   const char* kFunctionName = "f";
 
-  const int kLastParamIndex =
+  static const int kLastParamIndex =
       -InterpreterFrameConstants::kLastParamFromRegisterPointer / kPointerSize;
 
   BytecodeGeneratorHelper() {
     i::FLAG_vector_stores = true;
     i::FLAG_ignition = true;
     i::FLAG_ignition_filter = StrDup(kFunctionName);
     i::FLAG_always_opt = false;
     CcTest::i_isolate()->interpreter()->Initialize();
   }
 
@@ skipping 430 matching lines @@
            B(Ldar), R(helper.kLastParamIndex),                           //
            B(Star), R(1),                                                //
            B(LdaSmi8), U8(-124),                                         //
            B(KeyedLoadIC), R(1), U8(vector->first_ic_slot_index() + 2),  //
            B(Return)                                                     //
        },
        1,
        {"name"}}};
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
-        helper.MakeBytecode(snippets[i].code_snippet, "f");
+        helper.MakeBytecode(snippets[i].code_snippet, helper.kFunctionName);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(PropertyStores) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   Code::Kind ic_kinds[] = { i::Code::STORE_IC, i::Code::STORE_IC };
@@ skipping 81 matching lines @@
            B(LdaSmi8), U8(-124),                                           //
            B(KeyedLoadIC), R(2), U8(vector->first_ic_slot_index()),        //
            B(StoreIC), R(0), R(1), U8(vector->first_ic_slot_index() + 2),  //
            B(LdaUndefined),                                                //
            B(Return)                                                       //
        },
        1,
        {"name"}}};
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
-        helper.MakeBytecode(snippets[i].code_snippet, "f");
+        helper.MakeBytecode(snippets[i].code_snippet, helper.kFunctionName);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 #define FUNC_ARG "new (function Obj() { this.func = function() { return; }})()"
 
 
 TEST(PropertyCall) {
   InitializedHandleScope handle_scope;
@@ skipping 56 matching lines @@
            B(Star), R(2),                                           //
            B(Ldar), R(helper.kLastParamIndex),                      //
            B(Star), R(3),                                           //
            B(Call), R(0), R(1), U8(2),                              //
            B(Return)                                                //
        },
        1,
        {"func"}}};
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
-        helper.MakeBytecode(snippets[i].code_snippet, "f");
+        helper.MakeBytecode(snippets[i].code_snippet, helper.kFunctionName);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 TEST(LoadGlobal) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   ExpectedSnippet<const char*> snippets[] = {
       {"var a = 1;\nfunction f() { return a; }\nf()",
        0, 1, 3,
        {
           B(LdaGlobal), _,
           B(Return)
        },
       },
       {"function t() { }\nfunction f() { return t; }\nf()",
        0, 1, 3,
        {
           B(LdaGlobal), _,
           B(Return)
        },
       },
   };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
         helper.MakeBytecode(snippets[i].code_snippet, "f");
-    bytecode_array->Print();
     CheckBytecodeArrayEqual(snippets[i], bytecode_array, true);
   }
 }
 
 
 TEST(CallGlobal) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   ExpectedSnippet<const char*> snippets[] = {
@@ skipping 35 matching lines @@
 }
 
 
 TEST(IfConditions) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   Handle<Object> unused = helper.factory()->undefined_value();
 
   ExpectedSnippet<Handle<Object>> snippets[] = {
-      {"function f() { if (0) { return 1; } else { return -1; } }",
+      {"function f() { if (0) { return 1; } else { return -1; } } f()",
        0,
        1,
        14,
        {B(LdaZero),             //
         B(ToBoolean),           //
         B(JumpIfFalse), U8(7),  //
         B(LdaSmi8), U8(1),      //
         B(Return),              //
         B(Jump), U8(5),         // TODO(oth): Unreachable jump after return
         B(LdaSmi8), U8(-1),     //
         B(Return),              //
         B(LdaUndefined),        //
         B(Return)},             //
        0,
        {unused, unused, unused, unused}},
-      {"function f() { if ('lucky') { return 1; } else { return -1; } }",
+      {"function f() { if ('lucky') { return 1; } else { return -1; } } f();",
        0,
        1,
        15,
        {B(LdaConstant), U8(0),  //
         B(ToBoolean),           //
         B(JumpIfFalse), U8(7),  //
         B(LdaSmi8), U8(1),      //
         B(Return),              //
         B(Jump), U8(5),         // TODO(oth): Unreachable jump after return
         B(LdaSmi8), U8(-1),     //
         B(Return),              //
         B(LdaUndefined),        //
         B(Return)},             //
        1,
-       {helper.factory()->NewStringFromStaticChars("lucky"), unused,
-        unused, unused}},
-      {"function f() { if (false) { return 1; } else { return -1; } }",
+       {helper.factory()->NewStringFromStaticChars("lucky"), unused, unused,
+        unused}},
+      {"function f() { if (false) { return 1; } else { return -1; } } f();",
        0,
        1,
        13,
        {B(LdaFalse),            //
         B(JumpIfFalse), U8(7),  //
         B(LdaSmi8), U8(1),      //
         B(Return),              //
         B(Jump), U8(5),         // TODO(oth): Unreachable jump after return
         B(LdaSmi8), U8(-1),     //
         B(Return),              //
         B(LdaUndefined),        //
         B(Return)},             //
        0,
        {unused, unused, unused, unused}},
-      {"function f(a) { if (a <= 0) { return 200; } else { return -200; } }",
+      {"function f(a) { if (a <= 0) { return 200; } else { return -200; } }"
+       "f(99);",
        kPointerSize,
        2,
        19,
-       {B(Ldar), R(-5),              //
-        B(Star), R(0),               //
-        B(LdaZero),                  //
-        B(TestLessThanEqual), R(0),  //
-        B(JumpIfFalse), U8(7),       //
-        B(LdaConstant), U8(0),       //
-        B(Return),                   //
-        B(Jump), U8(5),              // TODO(oth): Unreachable jump after return
-        B(LdaConstant), U8(1),       //
-        B(Return),                   //
-        B(LdaUndefined),             //
-        B(Return)},                  //
+       {B(Ldar), R(-5),                //
+        B(Star), R(0),                 //
+        B(LdaZero),                    //
+        B(TestLessThanOrEqual), R(0),  //
+        B(JumpIfFalse), U8(7),         //
+        B(LdaConstant), U8(0),         //
+        B(Return),                     //
+        B(Jump), U8(5),         // TODO(oth): Unreachable jump after return
+        B(LdaConstant), U8(1),  //
+        B(Return),              //
+        B(LdaUndefined),        //
+        B(Return)},             //
        2,
        {helper.factory()->NewNumberFromInt(200),
         helper.factory()->NewNumberFromInt(-200), unused, unused}},
-      {"function f(a, b) { if (a in b) { return 200; } }",
+      {"function f(a, b) { if (a in b) { return 200; } }"
+       "f('prop', { prop: 'yes'});",
        kPointerSize,
        3,
        17,
        {B(Ldar), R(-6),         //
         B(Star), R(0),          //
         B(Ldar), R(-5),         //
         B(TestIn), R(0),        //
         B(JumpIfFalse), U8(7),  //
         B(LdaConstant), U8(0),  //
         B(Return),              //
         B(Jump), U8(2),         // TODO(oth): Unreachable jump after return
         B(LdaUndefined),        //
         B(Return)},             //
        1,
        {helper.factory()->NewNumberFromInt(200), unused, unused, unused}},
-      {"function f(a, b) { if (a instanceof b) { return 200; } }",
-       kPointerSize,
-       3,
-       17,
-       {B(Ldar), R(-6),           //
-        B(Star), R(0),            //
-        B(Ldar), R(-5),           //
-        B(TestInstanceOf), R(0),  //
-        B(JumpIfFalse), U8(7),    //
-        B(LdaConstant), U8(0),    //
-        B(Return),                //
-        B(Jump), U8(2),           // TODO(oth): Unreachable jump after return
-        B(LdaUndefined),          //
-        B(Return)},               //
-       1,
-       {helper.factory()->NewNumberFromInt(200), unused, unused, unused}},
       {"function f(z) { var a = 0; var b = 0; if (a === 0.01) { "
 #define X "b = a; a = b; "
        X X X X X X X X X X X X X X X X X X X X X X X X
 #undef X
-       " return 200; } else { return -200; } }",
+       " return 200; } else { return -200; } } f(0.001)",
        3 * kPointerSize,
        2,
        218,
        {B(LdaZero),                     //
         B(Star), R(0),                  //
         B(LdaZero),                     //
         B(Star), R(1),                  //
         B(Ldar), R(0),                  //
         B(Star), R(2),                  //
         B(LdaConstant), U8(0),          //
         B(TestEqualStrict), R(2),       //
         B(JumpIfFalseConstant), U8(2),  //
 #define X B(Ldar), R(0), B(Star), R(1), B(Ldar), R(1), B(Star), R(0),
         X X X X X X X X X X X X X X X X X X X X X X X X
 #undef X
             B(LdaConstant),
         U8(1),                  //
         B(Return),              //
         B(Jump), U8(5),         // TODO(oth): Unreachable jump after return
         B(LdaConstant), U8(3),  //
         B(Return),              //
         B(LdaUndefined),        //
         B(Return)},             //
        4,
        {helper.factory()->NewHeapNumber(0.01),
         helper.factory()->NewNumberFromInt(200),
         helper.factory()->NewNumberFromInt(199),
-        helper.factory()->NewNumberFromInt(-200)}}};
+        helper.factory()->NewNumberFromInt(-200)}},
+      {"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"
+       "if (a instanceof b) { return 1; }\n"
+       "/* if (a != b) { return 1; } */"   // TODO(oth) Ast visitor yields unary
+       "/* if (a !== b) { return 1; } */"  // NOT, rather than not-equals ops.
+       "return 0;\n"
+       "} f(1,1);",
+       kPointerSize,
+       3,
+       122,
+       {
+#define IF_CONDITION_RETURN(condition) \
+  B(Ldar), R(-6),                      \
+  B(Star), R(0),                       \
+  B(Ldar), R(-5),                      \
+  B(condition), R(0),                  \
+  B(JumpIfFalse), U8(7),               \
+  B(LdaSmi8), U8(1),                   \
+  B(Return),                           \
+  B(Jump), U8(2),
+           IF_CONDITION_RETURN(TestEqual)               //
+           IF_CONDITION_RETURN(TestEqualStrict)         //
+           IF_CONDITION_RETURN(TestLessThan)            //
+           IF_CONDITION_RETURN(TestGreaterThan)         //
+           IF_CONDITION_RETURN(TestLessThanOrEqual)     //
+           IF_CONDITION_RETURN(TestGreaterThanOrEqual)  //
+           IF_CONDITION_RETURN(TestIn)                  //
+           IF_CONDITION_RETURN(TestInstanceOf)          //
+#undef IF_CONDITION_RETURN
+           B(LdaZero),  //
+           B(Return)},  //
+       0,
+       {unused, unused, unused, unused}},
+  };
 
   for (size_t i = 0; i < arraysize(snippets); i++) {
     Handle<BytecodeArray> bytecode_array =
-        helper.MakeBytecodeForFunction(snippets[i].code_snippet);
+        helper.MakeBytecode(snippets[i].code_snippet, helper.kFunctionName);
     CheckBytecodeArrayEqual(snippets[i], bytecode_array);
   }
 }
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespance v8