[Interpreter] Basic flow control.

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-generator.h"
 #include "src/interpreter/interpreter.h"
 #include "test/cctest/cctest.h"
@@ skipping 46 matching lines @@
 };
 
 
 // Structure for containing expected bytecode snippets.
 template<typename T>
 struct ExpectedSnippet {
   const char* code_snippet;
   int frame_size;
   int parameter_count;
   int bytecode_length;
-  const uint8_t bytecode[32];
+  const uint8_t bytecode[512];
   int constant_count;
   T constants[16];
 };
 
 
 // Helper macros for handcrafting bytecode sequences.
 #define B(x) static_cast<uint8_t>(Bytecode::k##x)
 #define U8(x) static_cast<uint8_t>((x) & 0xff)
 #define R(x) static_cast<uint8_t>(-(x) & 0xff)
 
@@ skipping 100 matching lines @@
     CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
     CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
     CHECK_EQ(ba->length(), snippets[i].bytecode_length);
     CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
                   ba->length()));
     CHECK_EQ(ba->constant_pool(), CcTest::heap()->empty_fixed_array());
   }
 }
 
 
-TEST(Constants) {
+TEST(IntegerConstants) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
-  // Check large SMIs.
-  {
-    ExpectedSnippet<int> snippets[] = {
-        {"return 12345678;", 0, 1, 3,
-         {
-            B(LdaConstant), U8(0),
-            B(Return)
-         }, 1, { 12345678 }
-        },
-        {"var a = 1234; return 5678;", 1 * kPointerSize, 1, 7,
-         {
-            B(LdaConstant), U8(0),
-            B(Star), R(0),
-            B(LdaConstant), U8(1),
-            B(Return)
-         }, 2, { 1234, 5678 }
-        },
-        {"var a = 1234; return 1234;",
-         1 * kPointerSize, 1, 7,
-         {
-            B(LdaConstant), U8(0),
-            B(Star), R(0),
-            B(LdaConstant), U8(0),
-            B(Return)
-         }, 1, { 1234 }
-        }
-    };
+  ExpectedSnippet<int> snippets[] = {{"return 12345678;",
+                                      0,
+                                      1,
+                                      3,
+                                      {
+                                          B(LdaConstant), U8(0),  //
+                                          B(Return)               //
+                                      },
+                                      1,
+                                      {12345678}},
+                                     {"var a = 1234; return 5678;",
+                                      1 * kPointerSize,
+                                      1,
+                                      7,
+                                      {
+                                          B(LdaConstant), U8(0),  //
+                                          B(Star), R(0),          //
+                                          B(LdaConstant), U8(1),  //
+                                          B(Return)               //
+                                      },
+                                      2,
+                                      {1234, 5678}},
+                                     {"var a = 1234; return 1234;",
+                                      1 * kPointerSize,
+                                      1,
+                                      7,
+                                      {
+                                          B(LdaConstant), U8(0),  //
+                                          B(Star), R(0),          //
+                                          B(LdaConstant), U8(0),  //
+                                          B(Return)               //
+                                      },
+                                      1,
+                                      {1234}}};

[rmcilroy, 2015/09/24 11:44:36]

was this reformat intended?

 
-    size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-    for (size_t i = 0; i < num_snippets; i++) {
-      Handle<BytecodeArray> ba =
-          helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
-      CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
-      CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
-      CHECK_EQ(ba->length(), snippets[i].bytecode_length);
-      CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
-                    ba->length()));
-      CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
-      for (int j = 0; j < snippets[i].constant_count; j++) {
-        CHECK_EQ(Smi::cast(ba->constant_pool()->get(j))->value(),
-                 snippets[i].constants[j]);
-      }
-    }
-  }
-
-  // Check heap number double constants
-  {
-    ExpectedSnippet<double> snippets[] = {
-        {"return 1.2;",
-         0, 1, 3,
-         {
-            B(LdaConstant), U8(0),
-            B(Return)
-         }, 1, { 1.2 }
-        },
-        {"var a = 1.2; return 2.6;", 1 * kPointerSize, 1, 7,
-         {
-            B(LdaConstant), U8(0),
-            B(Star), R(0),
-            B(LdaConstant), U8(1),
-            B(Return)
-         }, 2, { 1.2, 2.6 }
-        },
-        {"var a = 3.14; return 3.14;", 1 * kPointerSize, 1, 7,
-         {
-            B(LdaConstant), U8(0),
-            B(Star), R(0),
-            B(LdaConstant), U8(1),
-            B(Return)
-         }, 2,
-         // TODO(rmcilroy): Currently multiple identical double literals end up
-         // being allocated as new HeapNumbers and so require multiple constant
-         // pool entries. De-dup identical values.
-         { 3.14, 3.14 }
-        }
-    };
-
-    size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-    for (size_t i = 0; i < num_snippets; i++) {
-      Handle<BytecodeArray> ba =
-          helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
-      CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
-      CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
-      CHECK_EQ(ba->length(), snippets[i].bytecode_length);
-      CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
-                    ba->length()));
-      CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
-      for (int j = 0; j < snippets[i].constant_count; j++) {
-        CHECK_EQ(HeapNumber::cast(ba->constant_pool()->get(j))->value(),
-                 snippets[i].constants[j]);
-      }
-    }
-  }
-
-  // Check string literals
-  {
-    ExpectedSnippet<const char*> snippets[] = {
-        {"return \"This is a string\";", 0, 1, 3,
-         {
-            B(LdaConstant), U8(0),
-            B(Return)
-         }, 1,
-         { "This is a string" }
-        },
-        {"var a = \"First string\"; return \"Second string\";",
-         1 * kPointerSize, 1, 7,
-         {
-            B(LdaConstant), U8(0),
-            B(Star), R(0),
-            B(LdaConstant), U8(1),
-            B(Return)
-         }, 2, { "First string", "Second string"}
-        },
-        {"var a = \"Same string\"; return \"Same string\";",
-         1 * kPointerSize, 1, 7,
-         {
-            B(LdaConstant), U8(0),
-            B(Star), R(0),
-            B(LdaConstant), U8(0),
-            B(Return)
-         }, 1, { "Same string" }
-        }
-    };
-
-    size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
-    for (size_t i = 0; i < num_snippets; i++) {
-      Handle<BytecodeArray> ba =
-          helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
-      CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
-      CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
-      CHECK_EQ(ba->length(), snippets[i].bytecode_length);
-      CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
-                    ba->length()));
-      CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
-      for (int j = 0; j < snippets[i].constant_count; j++) {
-        Handle<String> expected = helper.factory()->NewStringFromAsciiChecked(
-            snippets[i].constants[j]);
-        CHECK(String::cast(ba->constant_pool()->get(j))->Equals(*expected));
-      }
+  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
+  for (size_t i = 0; i < num_snippets; i++) {
+    Handle<BytecodeArray> ba =
+        helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
+    CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
+    CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
+    CHECK_EQ(ba->length(), snippets[i].bytecode_length);
+    CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
+                  ba->length()));
+    CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
+    for (int j = 0; j < snippets[i].constant_count; j++) {
+      CHECK_EQ(Smi::cast(ba->constant_pool()->get(j))->value(),
+               snippets[i].constants[j]);
     }
   }
 }
+
+
+TEST(HeapNumberConstants) {
+  InitializedHandleScope handle_scope;
+  BytecodeGeneratorHelper helper;
+
+  ExpectedSnippet<double> snippets[] = {
+      {"return 1.2;",
+       0,
+       1,
+       3,
+       {
+           B(LdaConstant), U8(0),  //
+           B(Return)               //
+       },
+       1,
+       {1.2}},
+      {"var a = 1.2; return 2.6;",
+       1 * kPointerSize,
+       1,
+       7,
+       {
+           B(LdaConstant), U8(0),  //
+           B(Star), R(0),          //
+           B(LdaConstant), U8(1),  //
+           B(Return)               //
+       },
+       2,
+       {1.2, 2.6}},
+      {"var a = 3.14; return 3.14;",
+       1 * kPointerSize,
+       1,
+       7,
+       {
+           B(LdaConstant), U8(0),  //
+           B(Star), R(0),          //
+           B(LdaConstant), U8(1),  //
+           B(Return)               //
+       },
+       2,
+       // TODO(rmcilroy): Currently multiple identical double literals end up
+       // being allocated as new HeapNumbers and so require multiple constant
+       // pool entries. De-dup identical values.
+       {3.14, 3.14}}};
+
+  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
+  for (size_t i = 0; i < num_snippets; i++) {
+    Handle<BytecodeArray> ba =
+        helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
+    CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
+    CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
+    CHECK_EQ(ba->length(), snippets[i].bytecode_length);
+    CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
+                  ba->length()));
+    CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
+    for (int j = 0; j < snippets[i].constant_count; j++) {
+      CHECK_EQ(HeapNumber::cast(ba->constant_pool()->get(j))->value(),
+               snippets[i].constants[j]);
+    }
+  }
+}
+
+
+TEST(StringConstants) {
+  InitializedHandleScope handle_scope;
+  BytecodeGeneratorHelper helper;
+
+  ExpectedSnippet<const char*> snippets[] = {
+      {"return \"This is a string\";",
+       0,
+       1,
+       3,
+       {
+           B(LdaConstant), U8(0),  //
+           B(Return)               //
+       },
+       1,
+       {"This is a string"}},
+      {"var a = \"First string\"; return \"Second string\";",
+       1 * kPointerSize,
+       1,
+       7,
+       {
+           B(LdaConstant), U8(0),  //
+           B(Star), R(0),          //
+           B(LdaConstant), U8(1),  //
+           B(Return)               //
+       },
+       2,
+       {"First string", "Second string"}},
+      {"var a = \"Same string\"; return \"Same string\";",
+       1 * kPointerSize,
+       1,
+       7,
+       {
+           B(LdaConstant), U8(0),  //
+           B(Star), R(0),          //
+           B(LdaConstant), U8(0),  //
+           B(Return)               //
+       },
+       1,
+       {"Same string"}}};
+
+  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
+  for (size_t i = 0; i < num_snippets; i++) {
+    Handle<BytecodeArray> ba =
+        helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
+    CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
+    CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
+    CHECK_EQ(ba->length(), snippets[i].bytecode_length);
+    CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
+                  ba->length()));
+    CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
+    for (int j = 0; j < snippets[i].constant_count; j++) {
+      Handle<String> expected =
+          helper.factory()->NewStringFromAsciiChecked(snippets[i].constants[j]);
+      CHECK(String::cast(ba->constant_pool()->get(j))->Equals(*expected));
+    }
+  }
+}
 
 
 TEST(PropertyLoads) {
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   Code::Kind ic_kinds[] = { i::Code::LOAD_IC, i::Code::LOAD_IC };
   FeedbackVectorSpec feedback_spec(0, 2, ic_kinds);
   Handle<i::TypeFeedbackVector> vector =
       helper.factory()->NewTypeFeedbackVector(&feedback_spec);
 
   ExpectedSnippet<const char*> snippets[] = {
       {"function f(a) { return a.name; }\nf({name : \"test\"})",
-       1 * kPointerSize, 2, 10,
+       1 * kPointerSize,
+       2,
+       10,
        {
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(0),
-          B(LdaConstant), U8(0),
-          B(LoadIC), R(0), U8(vector->first_ic_slot_index()),
-          B(Return)
+           B(Ldar), R(helper.kLastParamIndex),                  //
+           B(Star), R(0),                                       //
+           B(LdaConstant), U8(0),                               //
+           B(LoadIC), R(0), U8(vector->first_ic_slot_index()),  //
+           B(Return)                                            //
        },
-       1, { "name" }
-      },
+       1,
+       {"name"}},
       {"function f(a) { return a[\"key\"]; }\nf({key : \"test\"})",
-       1 * kPointerSize, 2, 10,
+       1 * kPointerSize,
+       2,
+       10,
        {
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(0),
-          B(LdaConstant), U8(0),
-          B(LoadIC), R(0), U8(vector->first_ic_slot_index()),
-          B(Return)
+           B(Ldar), R(helper.kLastParamIndex),                  //
+           B(Star), R(0),                                       //
+           B(LdaConstant), U8(0),                               //
+           B(LoadIC), R(0), U8(vector->first_ic_slot_index()),  //
+           B(Return)                                            //
        },
-       1, { "key" }
-      },
+       1,
+       {"key"}},
       {"function f(a) { return a[100]; }\nf({100 : \"test\"})",
-       1 * kPointerSize, 2, 10,
+       1 * kPointerSize,
+       2,
+       10,
        {
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(0),
-          B(LdaSmi8), U8(100),
-          B(KeyedLoadIC), R(0), U8(vector->first_ic_slot_index()),
-          B(Return)
-       }, 0
-      },
+           B(Ldar), R(helper.kLastParamIndex),                       //
+           B(Star), R(0),                                            //
+           B(LdaSmi8), U8(100),                                      //
+           B(KeyedLoadIC), R(0), U8(vector->first_ic_slot_index()),  //
+           B(Return)                                                 //
+       },
+       0},
       {"function f(a, b) { return a[b]; }\nf({arg : \"test\"}, \"arg\")",
-       1 * kPointerSize, 3, 10,
+       1 * kPointerSize,
+       3,
+       10,
        {
-          B(Ldar), R(helper.kLastParamIndex - 1),
-          B(Star), R(0),
-          B(Ldar), R(helper.kLastParamIndex),
-          B(KeyedLoadIC), R(0), U8(vector->first_ic_slot_index()),
-          B(Return)
-       }, 0
-      },
+           B(Ldar), R(helper.kLastParamIndex - 1),                   //
+           B(Star), R(0),                                            //
+           B(Ldar), R(helper.kLastParamIndex),                       //
+           B(KeyedLoadIC), R(0), U8(vector->first_ic_slot_index()),  //
+           B(Return)                                                 //
+       },
+       0},
       {"function f(a) { var b = a.name; return a[-124]; }\n"
        "f({\"-124\" : \"test\", name : 123 })",
-       2 * kPointerSize, 2, 21,
+       2 * kPointerSize,
+       2,
+       21,
        {
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(1),
-          B(LdaConstant), U8(0),
-          B(LoadIC), R(1), U8(vector->first_ic_slot_index()),
-          B(Star), R(0),
-          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)
+           B(Ldar), R(helper.kLastParamIndex),                           //
+           B(Star), R(1),                                                //
+           B(LdaConstant), U8(0),                                        //
+           B(LoadIC), R(1), U8(vector->first_ic_slot_index()),           //
+           B(Star), R(0),                                                //
+           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" }
-      }
-  };
+       1,
+       {"name"}}};
   size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
   for (size_t i = 0; i < num_snippets; i++) {
     Handle<BytecodeArray> ba =
         helper.MakeBytecode(snippets[i].code_snippet, "f");
     CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
     CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
     CHECK_EQ(ba->length(), snippets[i].bytecode_length);
     CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
                   ba->length()));
     CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
@@ skipping 10 matching lines @@
   InitializedHandleScope handle_scope;
   BytecodeGeneratorHelper helper;
 
   Code::Kind ic_kinds[] = { i::Code::STORE_IC, i::Code::STORE_IC };
   FeedbackVectorSpec feedback_spec(0, 2, ic_kinds);
   Handle<i::TypeFeedbackVector> vector =
       helper.factory()->NewTypeFeedbackVector(&feedback_spec);
 
   ExpectedSnippet<const char*> snippets[] = {
       {"function f(a) { a.name = \"val\"; }\nf({name : \"test\"})",
-       2 * kPointerSize, 2, 16,
+       2 * kPointerSize,
+       2,
+       16,
        {
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(0),
-          B(LdaConstant), U8(0),
-          B(Star), R(1),
-          B(LdaConstant), U8(1),
-          B(StoreIC), R(0), R(1), U8(vector->first_ic_slot_index()),
-          B(LdaUndefined),
-          B(Return)
+           B(Ldar), R(helper.kLastParamIndex),                         //
+           B(Star), R(0),                                              //
+           B(LdaConstant), U8(0),                                      //
+           B(Star), R(1),                                              //
+           B(LdaConstant), U8(1),                                      //
+           B(StoreIC), R(0), R(1), U8(vector->first_ic_slot_index()),  //
+           B(LdaUndefined),                                            //
+           B(Return)                                                   //
        },
-       2, { "name", "val" }
-      },
+       2,
+       {"name", "val"}},
       {"function f(a) { a[\"key\"] = \"val\"; }\nf({key : \"test\"})",
-       2 * kPointerSize, 2, 16,
+       2 * kPointerSize,
+       2,
+       16,
        {
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(0),
-          B(LdaConstant), U8(0),
-          B(Star), R(1),
-          B(LdaConstant), U8(1),
-          B(StoreIC), R(0), R(1), U8(vector->first_ic_slot_index()),
-          B(LdaUndefined),
-          B(Return)
+           B(Ldar), R(helper.kLastParamIndex),                         //
+           B(Star), R(0),                                              //
+           B(LdaConstant), U8(0),                                      //
+           B(Star), R(1),                                              //
+           B(LdaConstant), U8(1),                                      //
+           B(StoreIC), R(0), R(1), U8(vector->first_ic_slot_index()),  //
+           B(LdaUndefined),                                            //
+           B(Return)                                                   //
        },
-       2, { "key", "val" }
-      },
+       2,
+       {"key", "val"}},
       {"function f(a) { a[100] = \"val\"; }\nf({100 : \"test\"})",
-       2 * kPointerSize, 2, 16,
+       2 * kPointerSize,
+       2,
+       16,
        {
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(0),
-          B(LdaSmi8), U8(100),
-          B(Star), R(1),
-          B(LdaConstant), U8(0),
-          B(KeyedStoreIC), R(0), R(1), U8(vector->first_ic_slot_index()),
-          B(LdaUndefined),
-          B(Return)
+           B(Ldar), R(helper.kLastParamIndex),                              //
+           B(Star), R(0),                                                   //
+           B(LdaSmi8), U8(100),                                             //
+           B(Star), R(1),                                                   //
+           B(LdaConstant), U8(0),                                           //
+           B(KeyedStoreIC), R(0), R(1), U8(vector->first_ic_slot_index()),  //
+           B(LdaUndefined),                                                 //
+           B(Return)                                                        //
        },
-       1, { "val" }
-      },
+       1,
+       {"val"}},
       {"function f(a, b) { a[b] = \"val\"; }\nf({arg : \"test\"}, \"arg\")",
-       2 * kPointerSize, 3, 16,
+       2 * kPointerSize,
+       3,
+       16,
        {
-          B(Ldar), R(helper.kLastParamIndex - 1),
-          B(Star), R(0),
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(1),
-          B(LdaConstant), U8(0),
-          B(KeyedStoreIC), R(0), R(1), U8(vector->first_ic_slot_index()),
-          B(LdaUndefined),
-          B(Return)
+           B(Ldar), R(helper.kLastParamIndex - 1),                          //
+           B(Star), R(0),                                                   //
+           B(Ldar), R(helper.kLastParamIndex),                              //
+           B(Star), R(1),                                                   //
+           B(LdaConstant), U8(0),                                           //
+           B(KeyedStoreIC), R(0), R(1), U8(vector->first_ic_slot_index()),  //
+           B(LdaUndefined),                                                 //
+           B(Return)                                                        //
        },
-       1, { "val" }
-      },
+       1,
+       {"val"}},
       {"function f(a) { a.name = a[-124]; }\n"
        "f({\"-124\" : \"test\", name : 123 })",
-       3 * kPointerSize, 2, 23,
+       3 * kPointerSize,
+       2,
+       23,
        {
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(0),
-          B(LdaConstant), U8(0),
-          B(Star), R(1),
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(2),
-          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)
+           B(Ldar), R(helper.kLastParamIndex),                             //
+           B(Star), R(0),                                                  //
+           B(LdaConstant), U8(0),                                          //
+           B(Star), R(1),                                                  //
+           B(Ldar), R(helper.kLastParamIndex),                             //
+           B(Star), R(2),                                                  //
+           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" }
-      }
-  };
+       1,
+       {"name"}}};
   size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
   for (size_t i = 0; i < num_snippets; i++) {
     Handle<BytecodeArray> ba =
         helper.MakeBytecode(snippets[i].code_snippet, "f");
     CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
     CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
     CHECK_EQ(ba->length(), snippets[i].bytecode_length);
     CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
                   ba->length()));
     CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
     for (int j = 0; j < snippets[i].constant_count; j++) {
       Handle<String> expected =
           helper.factory()->NewStringFromAsciiChecked(snippets[i].constants[j]);
       CHECK(String::cast(ba->constant_pool()->get(j))->Equals(*expected));
     }
   }
 }
 
 
 #define FUNC_ARG "new (function Obj() { this.func = function() { return; }})()"
 
 
 TEST(PropertyCall) {
   InitializedHandleScope handle_scope;
-  BytecodeGeneratorHelper helper;
+  BytecodeGeneratorHelper helper;  //
 
   Code::Kind ic_kinds[] = { i::Code::LOAD_IC, i::Code::LOAD_IC  };
   FeedbackVectorSpec feedback_spec(0, 2, ic_kinds);
   Handle<i::TypeFeedbackVector> vector =
       helper.factory()->NewTypeFeedbackVector(&feedback_spec);
 
   ExpectedSnippet<const char*> snippets[] = {
       {"function f(a) { return a.func(); }\nf(" FUNC_ARG ")",
-       2 * kPointerSize, 2, 16,
+       2 * kPointerSize,
+       2,
+       16,
        {
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(1),
-          B(LdaConstant), U8(0),
-          B(LoadIC), R(1), U8(vector->first_ic_slot_index() + 2),
-          B(Star), R(0),
-          B(Call), R(0), R(1), U8(0),
-          B(Return)
+           B(Ldar), R(helper.kLastParamIndex),                      //
+           B(Star), R(1),                                           //
+           B(LdaConstant), U8(0),                                   //
+           B(LoadIC), R(1), U8(vector->first_ic_slot_index() + 2),  //
+           B(Star), R(0),                                           //
+           B(Call), R(0), R(1), U8(0),                              //
+           B(Return)                                                //
        },
-       1, { "func" }
-      },
+       1,
+       {"func"}},
       {"function f(a, b, c) { return a.func(b, c); }\nf(" FUNC_ARG ", 1, 2)",
-       4 * kPointerSize, 4, 24,
+       4 * kPointerSize,
+       4,
+       24,
        {
-          B(Ldar), R(helper.kLastParamIndex - 2),
-          B(Star), R(1),
-          B(LdaConstant), U8(0),
-          B(LoadIC), R(1), U8(vector->first_ic_slot_index() + 2),
-          B(Star), R(0),
-          B(Ldar), R(helper.kLastParamIndex - 1),
-          B(Star), R(2),
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(3),
-          B(Call), R(0), R(1), U8(2),
-          B(Return)
+           B(Ldar), R(helper.kLastParamIndex - 2),                  //
+           B(Star), R(1),                                           //
+           B(LdaConstant), U8(0),                                   //
+           B(LoadIC), R(1), U8(vector->first_ic_slot_index() + 2),  //
+           B(Star), R(0),                                           //
+           B(Ldar), R(helper.kLastParamIndex - 1),                  //
+           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" }
-     },
-     {"function f(a, b) { return a.func(b + b, b); }\nf(" FUNC_ARG ", 1)",
-      4 * kPointerSize, 3, 30,
-      {
-          B(Ldar), R(helper.kLastParamIndex - 1),
-          B(Star), R(1),
-          B(LdaConstant), U8(0),
-          B(LoadIC), R(1), U8(vector->first_ic_slot_index() + 2),
-          B(Star), R(0),
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Star), R(2),
-          B(Ldar), R(helper.kLastParamIndex),
-          B(Add), R(2),
-          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"}},
+      {"function f(a, b) { return a.func(b + b, b); }\nf(" FUNC_ARG ", 1)",
+       4 * kPointerSize,
+       3,
+       30,
+       {
+           B(Ldar), R(helper.kLastParamIndex - 1),                  //
+           B(Star), R(1),                                           //
+           B(LdaConstant), U8(0),                                   //
+           B(LoadIC), R(1), U8(vector->first_ic_slot_index() + 2),  //
+           B(Star), R(0),                                           //
+           B(Ldar), R(helper.kLastParamIndex),                      //
+           B(Star), R(2),                                           //
+           B(Ldar), R(helper.kLastParamIndex),                      //
+           B(Add), R(2),                                            //
+           B(Star), R(2),                                           //
+           B(Ldar), R(helper.kLastParamIndex),                      //
+           B(Star), R(3),                                           //
+           B(Call), R(0), R(1), U8(2),                              //
+           B(Return)                                                //

[rmcilroy, 2015/09/24 11:44:36]

Thanks for fixing all these other tests!

        },
-       1, { "func" }
-    }
-  };
+       1,
+       {"func"}}};
   size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
   for (size_t i = 0; i < num_snippets; i++) {
     Handle<BytecodeArray> ba =
         helper.MakeBytecode(snippets[i].code_snippet, "f");
     CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
     CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
     CHECK_EQ(ba->length(), snippets[i].bytecode_length);
     CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
                   ba->length()));
     CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
     for (int j = 0; j < snippets[i].constant_count; j++) {
       Handle<String> expected =
           helper.factory()->NewStringFromAsciiChecked(snippets[i].constants[j]);
       CHECK(String::cast(ba->constant_pool()->get(j))->Equals(*expected));
     }
   }
 }
 
+
+TEST(IfConditions) {
+  InitializedHandleScope handle_scope;
+  BytecodeGeneratorHelper helper;
+
+  ExpectedSnippet<void*> snippets[] = {
+      {"function f() { if (0) { return 1; } else { return -1; } }",
+       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},
+      {"function f() { if ('lucky') { return 1; } else { return -1; } }",
+       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},
+      {"function f() { if (false) { return 1; } else { return -1; } }",
+       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},
+      {"function f(a) { if (a <= 0) { return 200; } else { return -200; } }",
+       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)},                  //
+       2},
+      {"function f(a, b) { if (a in b) { return 200; } }",
+       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},
+      {"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},
+      {"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; } }",
+       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},                      //
+  };
+
+  size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
+  for (size_t i = 0; i < num_snippets; i++) {
+    Handle<BytecodeArray> ba =
+        helper.MakeBytecodeForFunction(snippets[i].code_snippet);
+    CHECK_EQ(ba->frame_size(), snippets[i].frame_size);
+    CHECK_EQ(ba->parameter_count(), snippets[i].parameter_count);
+    CHECK_EQ(ba->length(), snippets[i].bytecode_length);
+    CHECK(!memcmp(ba->GetFirstBytecodeAddress(), snippets[i].bytecode,
+                  ba->length()));
+    CHECK_EQ(ba->constant_pool()->length(), snippets[i].constant_count);
+  }
+}
+
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespance v8