[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 523 matching lines @@
                   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 (false) { return 1; } else { return -1; } }",
+       0,
+       1,
+       12,
+       {B(LdaFalse), B(CastToBoolean), B(JumpIfFalse), U8(7), B(LdaSmi8), U8(1),
+        B(Return), B(Jump),
+        U8(5),  // TODO(oth): Fix implicit return so dead-jump has
+                // a valid target.
+        B(LdaSmi8), U8(-1), B(Return)}},
+      {"function f(a) { if (a <= 0) { return 200; } else { return -200; } }",
+       kPointerSize,
+       2,
+       18,
+       {B(Ldar), R(-5), B(Star), R(0), B(LdaZero), B(TestLessThanEqual), R(0),
+        B(CastToBoolean), B(JumpIfFalse), U8(7), B(LdaConstant), U8(0),
+        B(Return), B(Jump),
+        U8(5),  // TODO(oth): Fix implicit return so dead-jump has
+                // a valid target.
+        B(LdaConstant), U8(1), B(Return)}},
+      {"function f(a, b) { if (a in b) { return 200; } }",
+       kPointerSize,
+       3,
+       18,
+       {B(Ldar), R(-6), B(Star), R(0), B(Ldar), R(-5), B(TestIn), R(0),
+        B(CastToBoolean), B(JumpIfFalse), U8(7), B(LdaConstant), U8(0),
+        B(Return), B(Jump),
+        U8(2),  // TODO(oth): Fix implicit return so dead-jump has
+                // a valid target.
+        B(LdaUndefined), B(Return)}},
+      {"function f(a, b) { if (a instanceof b) { return 200; } }",
+       kPointerSize,
+       3,
+       18,
+       {B(Ldar), R(-6), B(Star), R(0), B(Ldar), R(-5), B(TestInstanceOf), R(0),
+        B(CastToBoolean), B(JumpIfFalse), U8(7), B(LdaConstant), U8(0),
+        B(Return), B(Jump),
+        U8(2),  // TODO(oth): Fix implicit return so dead-jump has
+                // a valid target.
+        B(LdaUndefined), B(Return)}},
+      {"function f(z) { var a = 0; var b = 0; if (a === 0.01) { "
+// Force a jump using a constant pool entry.
+#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,
+       217,
+       {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(CastToBoolean), 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): Fix implicit return so dead-jump has
+                // a valid target.
+        B(LdaConstant), U8(3), B(Return)}},
+  };
+
+  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()));
+  }
+}
+
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespance v8