Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/test/cctest/interpreter/test-bytecode-generator.cc b/test/cctest/interpreter/test-bytecode-generator.cc
new file mode 100644
index 0000000..2c06da2
--- /dev/null
+++ b/test/cctest/interpreter/test-bytecode-generator.cc
@@ -0,0 +1,6727 @@
+// 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"
+#include "test/cctest/test-feedback-vector.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+class BytecodeGeneratorHelper {
+ public:
+ const char* kFunctionName = "f";
+
+ static const int kLastParamIndex =
+ -InterpreterFrameConstants::kLastParamFromRegisterPointer / kPointerSize;
+
+ BytecodeGeneratorHelper() {
+ i::FLAG_ignition = true;
+ i::FLAG_ignition_fake_try_catch = true;
+ i::FLAG_ignition_fallback_on_eval_and_catch = false;
+ i::FLAG_ignition_filter = StrDup(kFunctionName);
+ i::FLAG_always_opt = false;
+ i::FLAG_allow_natives_syntax = true;
+ i::FLAG_legacy_const = true;
+ CcTest::i_isolate()->interpreter()->Initialize();
+ }
+
+ Isolate* isolate() { return CcTest::i_isolate(); }
+ Factory* factory() { return CcTest::i_isolate()->factory(); }
+
+ Handle<BytecodeArray> MakeTopLevelBytecode(const char* source) {
+ const char* old_ignition_filter = i::FLAG_ignition_filter;
+ i::FLAG_ignition_filter = "*";
+ Local<v8::Script> script = v8_compile(source);
+ i::FLAG_ignition_filter = old_ignition_filter;
+ i::Handle<i::JSFunction> js_function = v8::Utils::OpenHandle(*script);
+ return handle(js_function->shared()->bytecode_array(), CcTest::i_isolate());
+ }
+
+ Handle<BytecodeArray> MakeBytecode(const char* script,
+ const char* function_name) {
+ CompileRun(script);
+ v8::Local<v8::Context> context =
+ v8::Isolate::GetCurrent()->GetCurrentContext();
+ Local<Function> function = Local<Function>::Cast(
+ CcTest::global()->Get(context, v8_str(function_name)).ToLocalChecked());
+ i::Handle<i::JSFunction> js_function =
+ i::Handle<i::JSFunction>::cast(v8::Utils::OpenHandle(*function));
+ return handle(js_function->shared()->bytecode_array(), CcTest::i_isolate());
+ }
+
+ Handle<BytecodeArray> MakeBytecode(const char* script, const char* filter,
+ const char* function_name) {
+ const char* old_ignition_filter = i::FLAG_ignition_filter;
+ i::FLAG_ignition_filter = filter;
+ Handle<BytecodeArray> return_val = MakeBytecode(script, function_name);
+ i::FLAG_ignition_filter = old_ignition_filter;
+ return return_val;
+ }
+
+ Handle<BytecodeArray> MakeBytecodeForFunctionBody(const char* body) {
+ static const char kFormat[] = "function %s() { %s }\n%s();";
+ static const int kFormatLength = arraysize(kFormat);
+ int length = kFormatLength + 2 * StrLength(kFunctionName) + StrLength(body);
+ ScopedVector<char> program(length);
+ length = SNPrintF(program, kFormat, kFunctionName, body, kFunctionName);
+ CHECK_GT(length, 0);
+ return MakeBytecode(program.start(), kFunctionName);
+ }
+
+ Handle<BytecodeArray> MakeBytecodeForFunction(const char* function) {
+ ScopedVector<char> program(3072);
+ SNPrintF(program, "%s\n%s();", function, kFunctionName);
+ return MakeBytecode(program.start(), kFunctionName);
+ }
+
+ Handle<BytecodeArray> MakeBytecodeForFunctionNoFilter(const char* function) {
+ ScopedVector<char> program(3072);
+ SNPrintF(program, "%s\n%s();", function, kFunctionName);
+ return MakeBytecode(program.start(), "*", kFunctionName);
+ }
+};
+
+
+// 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)
+#define A(x, n) R(helper.kLastParamIndex - (n) + 1 + (x))
+#define THIS(n) A(0, n)
+#if defined(V8_TARGET_LITTLE_ENDIAN)
+#define U16(x) static_cast<uint8_t>((x) & 0xff), \
+ static_cast<uint8_t>(((x) >> kBitsPerByte) & 0xff)
+#define U16I(x) static_cast<uint8_t>((x) & 0xff), \
+ static_cast<uint8_t>(((x++) >> kBitsPerByte) & 0xff)
+#elif defined(V8_TARGET_BIG_ENDIAN)
+#define U16(x) static_cast<uint8_t>(((x) >> kBitsPerByte) & 0xff), \
+ static_cast<uint8_t>((x) & 0xff)
+#define U16I(x) static_cast<uint8_t>(((x) >> kBitsPerByte) & 0xff), \
+ static_cast<uint8_t>((x++) & 0xff)
+#else
+#error Unknown byte ordering
+#endif
+
+#define XSTR(A) #A
+#define STR(A) XSTR(A)
+
+#define COMMA() ,
+#define SPACE()
+#define UNIQUE_VAR() "var a" STR(__COUNTER__) " = 0;\n"
+
+#define REPEAT_2(SEP, ...) \
+ __VA_ARGS__ SEP() __VA_ARGS__
+#define REPEAT_4(SEP, ...) \
+ REPEAT_2(SEP, __VA_ARGS__) SEP() REPEAT_2(SEP, __VA_ARGS__)
+#define REPEAT_8(SEP, ...) \
+ REPEAT_4(SEP, __VA_ARGS__) SEP() REPEAT_4(SEP, __VA_ARGS__)
+#define REPEAT_16(SEP, ...) \
+ REPEAT_8(SEP, __VA_ARGS__) SEP() REPEAT_8(SEP, __VA_ARGS__)
+#define REPEAT_32(SEP, ...) \
+ REPEAT_16(SEP, __VA_ARGS__) SEP() REPEAT_16(SEP, __VA_ARGS__)
+#define REPEAT_64(SEP, ...) \
+ REPEAT_32(SEP, __VA_ARGS__) SEP() REPEAT_32(SEP, __VA_ARGS__)
+#define REPEAT_128(SEP, ...) \
+ REPEAT_64(SEP, __VA_ARGS__) SEP() REPEAT_64(SEP, __VA_ARGS__)
+#define REPEAT_256(SEP, ...) \
+ REPEAT_128(SEP, __VA_ARGS__) SEP() REPEAT_128(SEP, __VA_ARGS__)
+
+#define REPEAT_127(SEP, ...) \
+ REPEAT_64(SEP, __VA_ARGS__) SEP() REPEAT_32(SEP, __VA_ARGS__) SEP() \
+ REPEAT_16(SEP, __VA_ARGS__) SEP() REPEAT_8(SEP, __VA_ARGS__) SEP() \
+ REPEAT_4(SEP, __VA_ARGS__) SEP() REPEAT_2(SEP, __VA_ARGS__) SEP() \
+ __VA_ARGS__
+
+#define REPEAT_249(SEP, ...) \
+ REPEAT_127(SEP, __VA_ARGS__) SEP() REPEAT_64(SEP, __VA_ARGS__) SEP() \
+ REPEAT_32(SEP, __VA_ARGS__) SEP() REPEAT_16(SEP, __VA_ARGS__) SEP() \
+ REPEAT_8(SEP, __VA_ARGS__) SEP() REPEAT_2(SEP, __VA_ARGS__)
+
+#define REPEAT_249_UNIQUE_VARS() \
+UNIQUE_VAR() REPEAT_127(UNIQUE_VAR) UNIQUE_VAR() REPEAT_64(UNIQUE_VAR) \
+UNIQUE_VAR() REPEAT_32(UNIQUE_VAR) UNIQUE_VAR() REPEAT_16(UNIQUE_VAR) \
+UNIQUE_VAR() REPEAT_8(UNIQUE_VAR) UNIQUE_VAR() REPEAT_2(UNIQUE_VAR)
+
+// Structure for containing expected bytecode snippets.
+template<typename T, int C = 6>
+struct ExpectedSnippet {
+ const char* code_snippet;
+ int frame_size;
+ int parameter_count;
+ int bytecode_length;
+ const uint8_t bytecode[2048];
+ int constant_count;
+ T constants[C];
+};
+
+
+static void CheckConstant(int expected, Object* actual) {
+ CHECK_EQ(expected, Smi::cast(actual)->value());
+}
+
+
+static void CheckConstant(double expected, Object* actual) {
+ CHECK_EQ(expected, HeapNumber::cast(actual)->value());
+}
+
+
+static void CheckConstant(const char* expected, Object* actual) {
+ Handle<String> expected_string =
+ CcTest::i_isolate()->factory()->NewStringFromAsciiChecked(expected);
+ CHECK(String::cast(actual)->Equals(*expected_string));
+}
+
+
+static void CheckConstant(Handle<Object> expected, Object* actual) {
+ CHECK(actual == *expected || expected->StrictEquals(actual));
+}
+
+
+static void CheckConstant(InstanceType expected, Object* actual) {
+ CHECK_EQ(expected, HeapObject::cast(actual)->map()->instance_type());
+}
+
+
+template <typename T, int C>
+static void CheckBytecodeArrayEqual(const ExpectedSnippet<T, C>& expected,
+ Handle<BytecodeArray> actual) {
+ CHECK_EQ(expected.frame_size, actual->frame_size());
+ CHECK_EQ(expected.parameter_count, actual->parameter_count());
+ CHECK_EQ(expected.bytecode_length, actual->length());
+ if (expected.constant_count == 0) {
+ CHECK_EQ(CcTest::heap()->empty_fixed_array(), actual->constant_pool());
+ } else {
+ CHECK_EQ(expected.constant_count, actual->constant_pool()->length());
+ for (int i = 0; i < expected.constant_count; i++) {
+ CheckConstant(expected.constants[i], actual->constant_pool()->get(i));
+ }
+ }
+
+ BytecodeArrayIterator iterator(actual);
+ int i = 0;
+ while (!iterator.done()) {
+ int bytecode_index = i++;
+ Bytecode bytecode = iterator.current_bytecode();
+ if (Bytecodes::ToByte(bytecode) != expected.bytecode[bytecode_index]) {
+ std::ostringstream stream;
+ stream << "Check failed: expected bytecode [" << bytecode_index
+ << "] to be " << Bytecodes::ToString(static_cast<Bytecode>(
+ expected.bytecode[bytecode_index]))
+ << " but got " << Bytecodes::ToString(bytecode);
+ FATAL(stream.str().c_str());
+ }
+ for (int j = 0; j < Bytecodes::NumberOfOperands(bytecode); ++j) {
+ OperandType operand_type = Bytecodes::GetOperandType(bytecode, j);
+ int operand_index = i;
+ i += static_cast<int>(Bytecodes::SizeOfOperand(operand_type));
+ uint32_t raw_operand = iterator.GetRawOperand(j, operand_type);
+ uint32_t expected_operand;
+ switch (Bytecodes::SizeOfOperand(operand_type)) {
+ case OperandSize::kNone:
+ UNREACHABLE();
+ return;
+ case OperandSize::kByte:
+ expected_operand =
+ static_cast<uint32_t>(expected.bytecode[operand_index]);
+ break;
+ case OperandSize::kShort:
+ expected_operand =
+ ReadUnalignedUInt16(&expected.bytecode[operand_index]);
+ break;
+ default:
+ UNREACHABLE();
+ return;
+ }
+ if (raw_operand != expected_operand) {
+ std::ostringstream stream;
+ stream << "Check failed: expected operand [" << j << "] for bytecode ["
+ << bytecode_index << "] to be "
+ << static_cast<unsigned int>(expected_operand) << " but got "
+ << static_cast<unsigned int>(raw_operand);
+ FATAL(stream.str().c_str());
+ }
+ }
+ iterator.Advance();
+ }
+}
+
+
+TEST(PrimitiveReturnStatements) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"", 0, 1, 2, {B(LdaUndefined), B(Return)}, 0},
+ {"return;", 0, 1, 2, {B(LdaUndefined), B(Return)}, 0},
+ {"return null;", 0, 1, 2, {B(LdaNull), B(Return)}, 0},
+ {"return true;", 0, 1, 2, {B(LdaTrue), B(Return)}, 0},
+ {"return false;", 0, 1, 2, {B(LdaFalse), B(Return)}, 0},
+ {"return 0;", 0, 1, 2, {B(LdaZero), B(Return)}, 0},
+ {"return +1;", 0, 1, 3, {B(LdaSmi8), U8(1), B(Return)}, 0},
+ {"return -1;", 0, 1, 3, {B(LdaSmi8), U8(-1), B(Return)}, 0},
+ {"return +127;", 0, 1, 3, {B(LdaSmi8), U8(127), B(Return)}, 0},
+ {"return -128;", 0, 1, 3, {B(LdaSmi8), U8(-128), B(Return)}, 0},
+ };
+
+ 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(PrimitiveExpressions) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"var x = 0; return x;",
+ kPointerSize,
+ 1,
+ 4,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(Return)},
+ 0},
+ {"var x = 0; return x + 3;",
+ 2 * kPointerSize,
+ 1,
+ 10,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Add), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 0; return x - 3;",
+ 2 * kPointerSize,
+ 1,
+ 10,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Sub), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 4; return x * 3;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {B(LdaSmi8), U8(4), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Mul), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 4; return x / 3;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {B(LdaSmi8), U8(4), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Div), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 4; return x % 3;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {B(LdaSmi8), U8(4), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Mod), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 1; return x | 2;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(BitwiseOr), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 1; return x ^ 2;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(BitwiseXor), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 1; return x & 2;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(BitwiseAnd), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 10; return x << 3;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {B(LdaSmi8), U8(10), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(ShiftLeft), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 10; return x >> 3;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {B(LdaSmi8), U8(10), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(ShiftRight), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 10; return x >>> 3;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {B(LdaSmi8), U8(10), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(ShiftRightLogical), R(1), //
+ B(Return)},
+ 0},
+ {"var x = 0; return (x, 3);",
+ 1 * kPointerSize,
+ 1,
+ 6,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(3), //
+ B(Return)},
+ 0}};
+
+ 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(LogicalExpressions) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"var x = 0; return x || 3;",
+ 1 * kPointerSize,
+ 1,
+ 8,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(JumpIfToBooleanTrue), U8(4), //
+ B(LdaSmi8), U8(3), //
+ B(Return)},
+ 0},
+ {"var x = 0; return (x == 1) || 3;",
+ 2 * kPointerSize,
+ 1,
+ 14,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqual), R(1), //
+ B(JumpIfTrue), U8(4), //
+ B(LdaSmi8), U8(3), //
+ B(Return)},
+ 0},
+ {"var x = 0; return x && 3;",
+ 1 * kPointerSize,
+ 1,
+ 8,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(JumpIfToBooleanFalse), U8(4), //
+ B(LdaSmi8), U8(3), //
+ B(Return)},
+ 0},
+ {"var x = 0; return (x == 0) && 3;",
+ 2 * kPointerSize,
+ 1,
+ 13,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaZero), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(LdaSmi8), U8(3), //
+ B(Return)},
+ 0},
+ {"var x = 0; return x || (1, 2, 3);",
+ 1 * kPointerSize,
+ 1,
+ 8,
+ {B(LdaZero), //
+ B(Star), 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,
+ 31,
+ {B(LdaSmi8), U8(2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(4), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(JumpIfToBooleanTrue), U8(16), //
+ B(Ldar), R(0), //
+ B(Ldar), R(1), //
+ B(Ldar), R(0), //
+ B(Ldar), R(1), //
+ B(LdaSmi8), U8(5), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(3), //
+ B(Return)},
+ 0},
+ {"var x = 1; var a = 2, b = 3; return x || ("
+ REPEAT_32(SPACE, "a = 1, b = 2, ")
+ "3);",
+ 3 * kPointerSize,
+ 1,
+ 275,
+ {B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(JumpIfToBooleanTrueConstant), U8(0), //
+ REPEAT_32(COMMA, //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(2)), //
+ B(LdaSmi8), U8(3), //
+ B(Return)},
+ 1,
+ {260, 0, 0, 0}},
+ {"var x = 0; var a = 2, b = 3; return x && ("
+ REPEAT_32(SPACE, "a = 1, b = 2, ")
+ "3);",
+ 3 * kPointerSize,
+ 1,
+ 274,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(JumpIfToBooleanFalseConstant), U8(0), //
+ REPEAT_32(COMMA, //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(2)), //
+ B(LdaSmi8), U8(3), //
+ B(Return)}, //
+ 1,
+ {260, 0, 0, 0}},
+ {"var x = 1; var a = 2, b = 3; return (x > 3) || ("
+ REPEAT_32(SPACE, "a = 1, b = 2, ")
+ "3);",
+ 4 * kPointerSize,
+ 1,
+ 281,
+ {B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(3), //
+ B(TestGreaterThan), R(3), //
+ B(JumpIfTrueConstant), U8(0), //
+ REPEAT_32(COMMA, //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(2)), //
+ B(LdaSmi8), U8(3), //
+ B(Return)},
+ 1,
+ {260, 0, 0, 0}},
+ {"var x = 0; var a = 2, b = 3; return (x < 5) && ("
+ REPEAT_32(SPACE, "a = 1, b = 2, ")
+ "3);",
+ 4 * kPointerSize,
+ 1,
+ 280,
+ {B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(5), //
+ B(TestLessThan), R(3), //
+ B(JumpIfFalseConstant), U8(0), //
+ REPEAT_32(COMMA, //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(2)), //
+ B(LdaSmi8), U8(3), //
+ B(Return)},
+ 1,
+ {260, 0, 0, 0}},
+ {"return 0 && 3;",
+ 0 * kPointerSize,
+ 1,
+ 2,
+ {B(LdaZero), //
+ B(Return)},
+ 0},
+ {"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,
+ 14,
+ {B(LdaSmi8), U8(1), //
+ B(Star), 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 =
+ helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(Parameters) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"function f() { return this; }",
+ 0,
+ 1,
+ 3,
+ {B(Ldar), THIS(1), B(Return)},
+ 0},
+ {"function f(arg1) { return arg1; }",
+ 0,
+ 2,
+ 3,
+ {B(Ldar), A(1, 2), B(Return)},
+ 0},
+ {"function f(arg1) { return this; }",
+ 0,
+ 2,
+ 3,
+ {B(Ldar), THIS(2), B(Return)},
+ 0},
+ {"function f(arg1, arg2, arg3, arg4, arg5, arg6, arg7) { return arg4; }",
+ 0,
+ 8,
+ 3,
+ {B(Ldar), A(4, 8), B(Return)},
+ 0},
+ {"function f(arg1, arg2, arg3, arg4, arg5, arg6, arg7) { return this; }",
+ 0,
+ 8,
+ 3,
+ {B(Ldar), THIS(8), B(Return)},
+ 0},
+ {"function f(arg1) { arg1 = 1; }",
+ 0,
+ 2,
+ 6,
+ {B(LdaSmi8), U8(1), //
+ B(Star), A(1, 2), //
+ B(LdaUndefined), //
+ B(Return)},
+ 0},
+ {"function f(arg1, arg2, arg3, arg4) { arg2 = 1; }",
+ 0,
+ 5,
+ 6,
+ {B(LdaSmi8), U8(1), //
+ B(Star), A(2, 5), //
+ B(LdaUndefined), //
+ B(Return)},
+ 0},
+ };
+
+ 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(IntegerConstants) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ 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}}};
+
+ 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(HeapNumberConstants) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ int wide_idx = 0;
+
+ ExpectedSnippet<double, 257> 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,
+ {3.14, 3.14}},
+ {"var a;"
+ REPEAT_256(SPACE, " a = 1.414;")
+ " a = 3.14;",
+ 1 * kPointerSize,
+ 1,
+ 1031,
+ {
+ REPEAT_256(COMMA, //
+ B(LdaConstant), U8(wide_idx++), //
+ B(Star), R(0)), //
+ B(LdaConstantWide), U16(wide_idx), //
+ B(Star), R(0), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 257,
+ {REPEAT_256(COMMA, 1.414),
+ 3.14}}
+ };
+ 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(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"}}};
+
+ 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(PropertyLoads) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddLoadICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddLoadICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ // These are a hack used by the LoadICXXXWide tests below.
+ int wide_idx_1 = vector->GetIndex(slot1) - 2;
+ int wide_idx_2 = vector->GetIndex(slot1) - 2;
+ int wide_idx_3 = vector->GetIndex(slot1) - 2;
+ int wide_idx_4 = vector->GetIndex(slot1) - 2;
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"function f(a) { return a.name; }\nf({name : \"test\"})",
+ 1 * kPointerSize,
+ 2,
+ 9,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICSloppy), R(0), U8(0), U8(vector->GetIndex(slot1)), //
+ B(Return), //
+ },
+ 1,
+ {"name"}},
+ {"function f(a) { return a[\"key\"]; }\nf({key : \"test\"})",
+ 1 * kPointerSize,
+ 2,
+ 9,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICSloppy), R(0), U8(0), U8(vector->GetIndex(slot1)), //
+ B(Return) //
+ },
+ 1,
+ {"key"}},
+ {"function f(a) { return a[100]; }\nf({100 : \"test\"})",
+ 1 * kPointerSize,
+ 2,
+ 10,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(100), //
+ B(KeyedLoadICSloppy), R(0), U8(vector->GetIndex(slot1)), //
+ B(Return) //
+ },
+ 0},
+ {"function f(a, b) { return a[b]; }\nf({arg : \"test\"}, \"arg\")",
+ 1 * kPointerSize,
+ 3,
+ 10,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(1, 2), //
+ B(KeyedLoadICSloppy), R(0), U8(vector->GetIndex(slot1)), //
+ B(Return) //
+ },
+ 0},
+ {"function f(a) { var b = a.name; return a[-124]; }\n"
+ "f({\"-124\" : \"test\", name : 123 })",
+ 2 * kPointerSize,
+ 2,
+ 20,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(0), U8(vector->GetIndex(slot1)), //
+ B(Star), R(0), //
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(-124), //
+ B(KeyedLoadICSloppy), R(1), U8(vector->GetIndex(slot2)), //
+ B(Return), //
+ },
+ 1,
+ {"name"}},
+ {"function f(a) { \"use strict\"; return a.name; }\nf({name : \"test\"})",
+ 1 * kPointerSize,
+ 2,
+ 9,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICStrict), R(0), U8(0), U8(vector->GetIndex(slot1)), //
+ B(Return), //
+ },
+ 1,
+ {"name"}},
+ {"function f(a, b) { \"use strict\"; return a[b]; }\n"
+ "f({arg : \"test\"}, \"arg\")",
+ 1 * kPointerSize,
+ 3,
+ 10,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(KeyedLoadICStrict), R(0), U8(vector->GetIndex(slot1)), //
+ B(Return), //
+ },
+ 0},
+ {"function f(a) {\n"
+ " var b;\n"
+ "b = a.name;"
+ REPEAT_127(SPACE, " b = a.name; ")
+ " return a.name; }\n"
+ "f({name : \"test\"})\n",
+ 2 * kPointerSize,
+ 2,
+ 1291,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(0), U8(wide_idx_1 += 2), //
+ B(Star), R(0), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(0), //
+ U8((wide_idx_1 += 2)), //
+ B(Star), R(0)), //
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LoadICSloppyWide), R(1), U16(0), U16(wide_idx_1 + 2), //
+ B(Return), //
+ },
+ 1,
+ {"name"}},
+ {"function f(a) {\n"
+ " 'use strict'; var b;\n"
+ " b = a.name;\n"
+ REPEAT_127(SPACE, " b = a.name; ")
+ " return a.name; }\n"
+ "f({name : \"test\"})\n",
+ 2 * kPointerSize,
+ 2,
+ 1291,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LoadICStrict), R(1), U8(0), U8((wide_idx_2 += 2)), //
+ B(Star), R(0), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LoadICStrict), R(1), U8(0), //
+ U8((wide_idx_2 += 2)), //
+ B(Star), R(0)), //
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LoadICStrictWide), R(1), U16(0), U16(wide_idx_2 + 2), //
+ B(Return), //
+ },
+ 1,
+ {"name"}},
+ {"function f(a, b) {\n"
+ " var c;\n"
+ " c = a[b];"
+ REPEAT_127(SPACE, " c = a[b]; ")
+ " return a[b]; }\n"
+ "f({name : \"test\"}, \"name\")\n",
+ 2 * kPointerSize,
+ 3,
+ 1419,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(1), //
+ B(Ldar), A(2, 3), //
+ B(KeyedLoadICSloppy), R(1), U8((wide_idx_3 += 2)), //
+ B(Star), R(0), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 3), //
+ B(Star), R(1), //
+ B(Ldar), A(2, 3), //
+ B(KeyedLoadICSloppy), R(1), U8((wide_idx_3 += 2)), //
+ B(Star), R(0)), //
+ B(Ldar), A(1, 3), //
+ B(Star), R(1), //
+ B(Ldar), A(2, 3), //
+ B(KeyedLoadICSloppyWide), R(1), U16(wide_idx_3 + 2), //
+ B(Return), //
+ }},
+ {"function f(a, b) {\n"
+ " 'use strict'; var c;\n"
+ " c = a[b];"
+ REPEAT_127(SPACE, " c = a[b]; ")
+ " return a[b]; }\n"
+ "f({name : \"test\"}, \"name\")\n",
+ 2 * kPointerSize,
+ 3,
+ 1419,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(1), //
+ B(Ldar), A(2, 3), //
+ B(KeyedLoadICStrict), R(1), U8((wide_idx_4 += 2)), //
+ B(Star), R(0), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 3), //
+ B(Star), R(1), //
+ B(Ldar), A(2, 3), //
+ B(KeyedLoadICStrict), R(1), U8((wide_idx_4 += 2)), //
+ B(Star), R(0)), //
+ B(Ldar), A(1, 3), //
+ B(Star), R(1), //
+ B(Ldar), A(2, 3), //
+ B(KeyedLoadICStrictWide), R(1), U16(wide_idx_4 + 2), //
+ B(Return), //
+ }},
+ };
+ 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(PropertyStores) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddStoreICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddStoreICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ // These are a hack used by the StoreICXXXWide tests below.
+ int wide_idx_1 = vector->GetIndex(slot1) - 2;
+ int wide_idx_2 = vector->GetIndex(slot1) - 2;
+ int wide_idx_3 = vector->GetIndex(slot1) - 2;
+ int wide_idx_4 = vector->GetIndex(slot1) - 2;
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"function f(a) { a.name = \"val\"; }\nf({name : \"test\"})",
+ kPointerSize,
+ 2,
+ 12,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaConstant), U8(0), //
+ B(StoreICSloppy), R(0), U8(1), U8(vector->GetIndex(slot1)), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 2,
+ {"val", "name"}},
+ {"function f(a) { a[\"key\"] = \"val\"; }\nf({key : \"test\"})",
+ kPointerSize,
+ 2,
+ 12,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaConstant), U8(0), //
+ B(StoreICSloppy), R(0), U8(1), U8(vector->GetIndex(slot1)), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 2,
+ {"val", "key"}},
+ {"function f(a) { a[100] = \"val\"; }\nf({100 : \"test\"})",
+ 2 * kPointerSize,
+ 2,
+ 16,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(100), //
+ B(Star), R(1), //
+ B(LdaConstant), U8(0), //
+ B(KeyedStoreICSloppy), R(0), R(1), //
+ U8(vector->GetIndex(slot1)), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {"val"}},
+ {"function f(a, b) { a[b] = \"val\"; }\nf({arg : \"test\"}, \"arg\")",
+ 2 * kPointerSize,
+ 3,
+ 16,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(1), //
+ B(LdaConstant), U8(0), //
+ B(KeyedStoreICSloppy), R(0), R(1), //
+ U8(vector->GetIndex(slot1)), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {"val"}},
+ {"function f(a) { a.name = a[-124]; }\n"
+ "f({\"-124\" : \"test\", name : 123 })",
+ 2 * kPointerSize,
+ 2,
+ 19,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(-124), //
+ B(KeyedLoadICSloppy), R(1), U8(vector->GetIndex(slot1)), //
+ B(StoreICSloppy), R(0), U8(0), U8(vector->GetIndex(slot2)), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {"name"}},
+ {"function f(a) { \"use strict\"; a.name = \"val\"; }\n"
+ "f({name : \"test\"})",
+ kPointerSize,
+ 2,
+ 12,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaConstant), U8(0), //
+ B(StoreICStrict), R(0), U8(1), U8(vector->GetIndex(slot1)), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 2,
+ {"val", "name"}},
+ {"function f(a, b) { \"use strict\"; a[b] = \"val\"; }\n"
+ "f({arg : \"test\"}, \"arg\")",
+ 2 * kPointerSize,
+ 3,
+ 16,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(1), //
+ B(LdaConstant), U8(0), //
+ B(KeyedStoreICStrict), R(0), R(1), U8(vector->GetIndex(slot1)), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {"val"}},
+ {"function f(a) {\n"
+ "a.name = 1;"
+ REPEAT_127(SPACE, " a.name = 1; ")
+ " a.name = 2; }\n"
+ "f({name : \"test\"})\n",
+ kPointerSize,
+ 2,
+ 1294,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(StoreICSloppy), R(0), U8(0), U8((wide_idx_1 += 2)), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(StoreICSloppy), R(0), U8(0), //
+ U8((wide_idx_1 += 2))), //
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(StoreICSloppyWide), R(0), U16(0), U16(wide_idx_1 + 2), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {"name"}},
+ {"function f(a) {\n"
+ " 'use strict';\n"
+ " a.name = 1;"
+ REPEAT_127(SPACE, " a.name = 1; ")
+ " a.name = 2; }\n"
+ "f({name : \"test\"})\n",
+ kPointerSize,
+ 2,
+ 1294,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(StoreICStrict), R(0), U8(0), U8(wide_idx_2 += 2), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(StoreICStrict), R(0), U8(0), //
+ U8((wide_idx_2 += 2))), //
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(StoreICStrictWide), R(0), U16(0), U16(wide_idx_2 + 2), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {"name"}},
+ {"function f(a, b) {\n"
+ " a[b] = 1;"
+ REPEAT_127(SPACE, " a[b] = 1; ")
+ " a[b] = 2; }\n"
+ "f({name : \"test\"})\n",
+ 2 * kPointerSize,
+ 3,
+ 1809,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(KeyedStoreICSloppy), R(0), R(1), U8(wide_idx_3 += 2), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(KeyedStoreICSloppy), R(0), R(1), //
+ U8((wide_idx_3 += 2))), //
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(KeyedStoreICSloppyWide), R(0), R(1), U16(wide_idx_3 + 2), //
+ B(LdaUndefined), //
+ B(Return), //
+ }},
+ {"function f(a, b) {\n"
+ " 'use strict';\n"
+ " a[b] = 1;"
+ REPEAT_127(SPACE, " a[b] = 1; ")
+ " a[b] = 2; }\n"
+ "f({name : \"test\"})\n",
+ 2 * kPointerSize,
+ 3,
+ 1809,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(KeyedStoreICStrict), R(0), R(1), U8(wide_idx_4 += 2), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(KeyedStoreICStrict), R(0), R(1), //
+ U8((wide_idx_4 += 2))), //
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(KeyedStoreICStrictWide), R(0), R(1), U16(wide_idx_4 + 2), //
+ B(LdaUndefined), //
+ B(Return), //
+ }}};
+ 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);
+ }
+}
+
+
+#define FUNC_ARG "new (function Obj() { this.func = function() { return; }})()"
+
+
+TEST(PropertyCall) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddCallICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddLoadICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ // These are a hack used by the CallWide test below.
+ int wide_idx = vector->GetIndex(slot1) - 2;
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"function f(a) { return a.func(); }\nf(" FUNC_ARG ")",
+ 2 * kPointerSize,
+ 2,
+ 16,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Star), R(0), //
+ B(Call), R(0), R(1), U8(0), U8(vector->GetIndex(slot1)), //
+ B(Return), //
+ },
+ 1,
+ {"func"}},
+ {"function f(a, b, c) { return a.func(b, c); }\nf(" FUNC_ARG ", 1, 2)",
+ 4 * kPointerSize,
+ 4,
+ 24,
+ {
+ B(Ldar), A(1, 4), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 4), //
+ B(Star), R(2), //
+ B(Ldar), A(3, 4), //
+ B(Star), R(3), //
+ B(Call), R(0), R(1), U8(2), U8(vector->GetIndex(slot1)), //
+ B(Return) //
+ },
+ 1,
+ {"func"}},
+ {"function f(a, b) { return a.func(b + b, b); }\nf(" FUNC_ARG ", 1)",
+ 4 * kPointerSize,
+ 3,
+ 30,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(3), //
+ B(Ldar), A(2, 3), //
+ B(Add), R(3), //
+ B(Star), R(2), //
+ B(Ldar), A(2, 3), //
+ B(Star), R(3), //
+ B(Call), R(0), R(1), U8(2), U8(vector->GetIndex(slot1)), //
+ B(Return), //
+ },
+ 1,
+ {"func"}},
+ {"function f(a) {\n"
+ " a.func;\n"
+ REPEAT_127(SPACE, " a.func;\n")
+ " return a.func(); }\nf(" FUNC_ARG ")",
+ 2 * kPointerSize,
+ 2,
+ 1044,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICSloppy), R(0), U8(0), U8(wide_idx += 2), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICSloppy), R(0), U8(0), U8((wide_idx += 2))), //
+ B(Ldar), A(1, 2), //
+ B(Star), R(1), //
+ B(LoadICSloppyWide), R(1), U16(0), U16(wide_idx + 4), //
+ B(Star), R(0), //
+ B(CallWide), R(0), R(1), U16(0), U16(wide_idx + 2), //
+ B(Return), //
+ },
+ 1,
+ {"func"}},
+ };
+ 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(LoadGlobal) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ // These are a hack used by the LdaGlobalXXXWide tests below.
+ int wide_idx_1 = vector->GetIndex(slot) - 2;
+ int wide_idx_2 = vector->GetIndex(slot) - 2;
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"var a = 1;\nfunction f() { return a; }\nf()",
+ 0,
+ 1,
+ 4,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)), //
+ B(Return) //
+ },
+ 1,
+ {"a"}},
+ {"function t() { }\nfunction f() { return t; }\nf()",
+ 0,
+ 1,
+ 4,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)), //
+ B(Return) //
+ },
+ 1,
+ {"t"}},
+ {"'use strict'; var a = 1;\nfunction f() { return a; }\nf()",
+ 0,
+ 1,
+ 4,
+ {
+ B(LdaGlobalStrict), U8(0), U8(vector->GetIndex(slot)), //
+ B(Return) //
+ },
+ 1,
+ {"a"}},
+ {"a = 1;\nfunction f() { return a; }\nf()",
+ 0,
+ 1,
+ 4,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)), //
+ B(Return) //
+ },
+ 1,
+ {"a"}},
+ {"a = 1;"
+ "function f(b) {\n"
+ " b.name;\n"
+ REPEAT_127(SPACE, "b.name; ")
+ " return a;"
+ "}\nf({name: 1});",
+ kPointerSize,
+ 2,
+ 1030,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICSloppy), R(0), U8(0), U8(wide_idx_1 += 2), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICSloppy), R(0), U8(0), U8(wide_idx_1 += 2)), //
+ B(LdaGlobalSloppyWide), U16(1), U16(wide_idx_1 + 2), //
+ B(Return), //
+ },
+ 2,
+ {"name", "a"}},
+ {"a = 1;"
+ "function f(b) {\n"
+ " 'use strict';\n"
+ " b.name\n"
+ REPEAT_127(SPACE, "b.name; ")
+ " return a;"
+ "}\nf({name: 1});",
+ kPointerSize,
+ 2,
+ 1030,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICStrict), R(0), U8(0), U8(wide_idx_2 += 2), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICStrict), R(0), U8(0), U8(wide_idx_2 += 2)), //
+ B(LdaGlobalStrictWide), U16(1), U16(wide_idx_2 + 2), //
+ B(Return), //
+ },
+ 2,
+ {"name", "a"}},
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(snippets[i].code_snippet, "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(StoreGlobal) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot = feedback_spec.AddStoreICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ // These are a hack used by the StaGlobalXXXWide tests below.
+ int wide_idx_1 = vector->GetIndex(slot) - 2;
+ int wide_idx_2 = vector->GetIndex(slot) - 2;
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"var a = 1;\nfunction f() { a = 2; }\nf()",
+ 0,
+ 1,
+ 7,
+ {
+ B(LdaSmi8), U8(2), //
+ B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)), //
+ B(LdaUndefined), //
+ B(Return) //
+ },
+ 1,
+ {"a"}},
+ {"var a = \"test\"; function f(b) { a = b; }\nf(\"global\")",
+ 0,
+ 2,
+ 7,
+ {
+ B(Ldar), R(helper.kLastParamIndex), //
+ B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)), //
+ B(LdaUndefined), //
+ B(Return) //
+ },
+ 1,
+ {"a"}},
+ {"'use strict'; var a = 1;\nfunction f() { a = 2; }\nf()",
+ 0,
+ 1,
+ 7,
+ {
+ B(LdaSmi8), U8(2), //
+ B(StaGlobalStrict), U8(0), U8(vector->GetIndex(slot)), //
+ B(LdaUndefined), //
+ B(Return) //
+ },
+ 1,
+ {"a"}},
+ {"a = 1;\nfunction f() { a = 2; }\nf()",
+ 0,
+ 1,
+ 7,
+ {
+ B(LdaSmi8), U8(2), //
+ B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)), //
+ B(LdaUndefined), //
+ B(Return) //
+ },
+ 1,
+ {"a"}},
+ {"a = 1;"
+ "function f(b) {"
+ " b.name;\n"
+ REPEAT_127(SPACE, "b.name; ")
+ " a = 2; }\n"
+ "f({name: 1});",
+ kPointerSize,
+ 2,
+ 1033,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICSloppy), R(0), U8(0), U8(wide_idx_1 += 2), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICSloppy), R(0), U8(0), U8(wide_idx_1 += 2)), //
+ B(LdaSmi8), U8(2), //
+ B(StaGlobalSloppyWide), U16(1), U16(wide_idx_1 + 2), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 2,
+ {"name", "a"}},
+ {"a = 1;"
+ "function f(b) {\n"
+ " 'use strict';\n"
+ " b.name;\n"
+ REPEAT_127(SPACE, "b.name; ")
+ " a = 2; }\n"
+ "f({name: 1});",
+ kPointerSize,
+ 2,
+ 1033,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICStrict), R(0), U8(0), U8(wide_idx_2 += 2), //
+ REPEAT_127(COMMA, //
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LoadICStrict), R(0), U8(0), U8(wide_idx_2 += 2)), //
+ B(LdaSmi8), U8(2), //
+ B(StaGlobalStrictWide), U16(1), U16(wide_idx_2 + 2), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 2,
+ {"name", "a"}},
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(snippets[i].code_snippet, "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(CallGlobal) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddCallICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddLoadICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"function t() { }\nfunction f() { return t(); }\nf()",
+ 2 * kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaUndefined), //
+ B(Star), R(1), //
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Star), R(0), //
+ B(Call), R(0), R(1), U8(0), U8(vector->GetIndex(slot1)), //
+ B(Return) //
+ },
+ 1,
+ {"t"}},
+ {"function t(a, b, c) { }\nfunction f() { return t(1, 2, 3); }\nf()",
+ 5 * kPointerSize,
+ 1,
+ 26,
+ {
+ B(LdaUndefined), //
+ B(Star), R(1), //
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(4), //
+ B(Call), R(0), R(1), U8(3), U8(vector->GetIndex(slot1)), //
+ B(Return) //
+ },
+ 1,
+ {"t"}},
+ };
+
+ size_t num_snippets = sizeof(snippets) / sizeof(snippets[0]);
+ for (size_t i = 0; i < num_snippets; i++) {
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(snippets[i].code_snippet, "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(CallRuntime) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {
+ "function f() { %TheHole() }\nf()",
+ 0,
+ 1,
+ 7,
+ {
+ B(CallRuntime), U16(Runtime::kTheHole), R(0), U8(0), //
+ B(LdaUndefined), //
+ B(Return) //
+ },
+ },
+ {
+ "function f(a) { return %IsArray(a) }\nf(undefined)",
+ 1 * kPointerSize,
+ 2,
+ 10,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(CallRuntime), U16(Runtime::kIsArray), R(0), U8(1), //
+ B(Return) //
+ },
+ },
+ {
+ "function f() { return %Add(1, 2) }\nf()",
+ 2 * kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(1), //
+ B(CallRuntime), U16(Runtime::kAdd), R(0), U8(2), //
+ B(Return) //
+ },
+ },
+ {
+ "function f() { return %spread_iterable([1]) }\nf()",
+ 2 * kPointerSize,
+ 1,
+ 15,
+ {
+ B(LdaUndefined), //
+ B(Star), R(0), //
+ B(CreateArrayLiteral), U8(0), U8(0), U8(3), //
+ B(Star), R(1), //
+ B(CallJSRuntime), U16(Context::SPREAD_ITERABLE_INDEX), R(0), //
+ U8(1), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE},
+ },
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(snippets[i].code_snippet, "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+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; } } f()",
+ 0,
+ 1,
+ 3,
+ {
+ B(LdaSmi8), U8(-1), //
+ B(Return), //
+ },
+ 0,
+ {unused, unused, unused, unused, unused, unused}},
+ {"function f() { if ('lucky') { return 1; } else { return -1; } } f();",
+ 0,
+ 1,
+ 3,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Return), //
+ },
+ 0,
+ {unused, unused, unused, unused, unused, unused}},
+ {"function f() { if (false) { return 1; } else { return -1; } } f();",
+ 0,
+ 1,
+ 3,
+ {
+ B(LdaSmi8), U8(-1), //
+ B(Return), //
+ },
+ 0,
+ {unused, unused, unused, unused, unused, unused}},
+ {"function f() { if (false) { return 1; } } f();",
+ 0,
+ 1,
+ 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();",
+ 2 * kPointerSize,
+ 1,
+ 23,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(JumpIfToBooleanFalse), U8(14), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(5), //
+ B(LdaSmi8), U8(2), //
+ B(Return), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 0,
+ {unused, unused, unused, unused, unused, unused}},
+ {"function f(a) { if (a <= 0) { return 200; } else { return -200; } }"
+ "f(99);",
+ kPointerSize,
+ 2,
+ 17,
+ {
+ B(Ldar), A(1, 2), //
+ B(Star), R(0), //
+ B(LdaZero), //
+ B(TestLessThanOrEqual), R(0), //
+ B(JumpIfFalse), U8(5), //
+ B(LdaConstant), U8(0), //
+ B(Return), //
+ B(LdaConstant), U8(1), //
+ B(Return), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 2,
+ {helper.factory()->NewNumberFromInt(200),
+ helper.factory()->NewNumberFromInt(-200), unused, unused, unused,
+ unused}},
+ {"function f(a, b) { if (a in b) { return 200; } }"
+ "f('prop', { prop: 'yes'});",
+ kPointerSize,
+ 3,
+ 15,
+ {
+ B(Ldar), A(1, 3), //
+ B(Star), R(0), //
+ B(Ldar), A(2, 3), //
+ B(TestIn), R(0), //
+ 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_64(SPACE, "b = a; a = b; ")
+ " return 200; } else { return -200; } } f(0.001)",
+ 3 * kPointerSize,
+ 2,
+ 282,
+ {
+ 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), //
+ B(Ldar), R(0), //
+ REPEAT_64(COMMA, //
+ B(Star), 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(263),
+ helper.factory()->NewNumberFromInt(-200), unused, unused}},
+ {"function f() { var a = 0; var b = 0; if (a) { "
+ REPEAT_64(SPACE, "b = a; a = b; ")
+ " return 200; } else { return -200; } } f()",
+ 2 * kPointerSize,
+ 1,
+ 276,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaZero), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(JumpIfToBooleanFalseConstant), U8(1), //
+ B(Ldar), R(0), //
+ REPEAT_64(COMMA, //
+ B(Star), 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(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"
+ " if (a instanceof b) { return 1; }\n"
+ " return 0;\n"
+ "} f(1, 1);",
+ kPointerSize,
+ 3,
+ 106,
+ {
+#define IF_CONDITION_RETURN(condition) \
+ B(Ldar), A(1, 3), \
+ B(Star), R(0), \
+ B(Ldar), A(2, 3), \
+ B(condition), R(0), \
+ B(JumpIfFalse), U8(5), \
+ B(LdaSmi8), U8(1), \
+ B(Return),
+ 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) //
+ B(LdaZero), //
+ B(Return)}, //
+#undef IF_CONDITION_RETURN
+ 0,
+ {unused, unused, unused, unused, unused, unused}},
+ {"function f() {"
+ " var a = 0;"
+ " if (a) {"
+ " return 20;"
+ "} else {"
+ " return -20;}"
+ "};"
+ "f();",
+ 1 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(LdaZero), //
+ B(Star), 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}}};
+
+ 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) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ // Create different feedback vector specs to be precise on slot numbering.
+ FeedbackVectorSpec feedback_spec_stores(&zone);
+ FeedbackVectorSlot store_slot_1 = feedback_spec_stores.AddStoreICSlot();
+ FeedbackVectorSlot store_slot_2 = feedback_spec_stores.AddStoreICSlot();
+ USE(store_slot_1);
+
+ Handle<i::TypeFeedbackVector> store_vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec_stores);
+
+ FeedbackVectorSpec feedback_spec_loads(&zone);
+ FeedbackVectorSlot load_slot_1 = feedback_spec_loads.AddLoadICSlot();
+ FeedbackVectorSlot call_slot_1 = feedback_spec_loads.AddCallICSlot();
+
+ Handle<i::TypeFeedbackVector> load_vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec_loads);
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"var a = 1;",
+ 4 * kPointerSize,
+ 1,
+ 30,
+ {
+ 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(LdaUndefined), //
+ B(Return) //
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"function f() {}",
+ 2 * kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(0), //
+ B(LdaZero), //
+ 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,
+ 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(Return) //
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"function f() {}\nf();",
+ 3 * kPointerSize,
+ 1,
+ 28,
+ {
+ 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), //
+ U8(load_vector->GetIndex(call_slot_1)), //
+ B(Star), 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);
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(BreakableBlocks) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"var x = 0;\n"
+ "label: {\n"
+ " x = x + 1;\n"
+ " break label;\n"
+ " x = x + 1;\n"
+ "}\n"
+ "return x;",
+ 2 * kPointerSize,
+ 1,
+ 16,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(2), //
+ B(Ldar), R(0), //
+ B(Return) //
+ }},
+ {"var sum = 0;\n"
+ "outer: {\n"
+ " for (var x = 0; x < 10; ++x) {\n"
+ " for (var y = 0; y < 3; ++y) {\n"
+ " ++sum;\n"
+ " if (x + y == 12) { break outer; }\n"
+ " }\n"
+ " }\n"
+ "}\n"
+ "return sum;",
+ 5 * kPointerSize,
+ 1,
+ 72,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaZero), //
+ B(Star), R(1), //
+ B(Ldar), R(1), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(10), //
+ B(TestLessThan), R(3), //
+ B(JumpIfFalse), U8(55), //
+ B(LdaZero), //
+ B(Star), R(2), //
+ B(Ldar), R(2), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(3), //
+ B(TestLessThan), R(3), //
+ B(JumpIfFalse), U8(34), //
+ B(Ldar), R(0), //
+ B(ToNumber), //
+ B(Inc), //
+ B(Star), R(0), //
+ B(Ldar), R(1), //
+ B(Star), R(3), //
+ B(Ldar), R(2), //
+ B(Add), R(3), //
+ B(Star), R(4), //
+ B(LdaSmi8), U8(12), //
+ B(TestEqual), R(4), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(18), //
+ B(Ldar), R(2), //
+ B(ToNumber), //
+ B(Inc), //
+ B(Star), R(2), //
+ B(Jump), U8(-40), //
+ B(Ldar), R(1), //
+ B(ToNumber), //
+ B(Inc), //
+ B(Star), R(1), //
+ B(Jump), U8(-61), //
+ 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(BasicLoops) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"var x = 0;\n"
+ "while (false) { x = 99; break; continue; }\n"
+ "return x;",
+ 1 * kPointerSize,
+ 1,
+ 4,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Return) //
+ }},
+ {"var x = 0;"
+ "while (false) {"
+ " x = x + 1;"
+ "};"
+ "return x;",
+ 1 * kPointerSize,
+ 1,
+ 4,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 0;"
+ "var y = 1;"
+ "while (x < 10) {"
+ " y = y * 12;"
+ " x = x + 1;"
+ " if (x == 3) continue;"
+ " if (x == 4) break;"
+ "}"
+ "return y;",
+ 3 * kPointerSize,
+ 1,
+ 64,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(10), //
+ B(TestLessThan), R(2), //
+ B(JumpIfFalse), U8(46), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(12), //
+ B(Mul), R(2), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(2), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(3), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(-38), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(4), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(4), //
+ B(Jump), U8(-52), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var i = 0;"
+ "while (true) {"
+ " if (i < 0) continue;"
+ " if (i == 3) break;"
+ " if (i == 4) break;"
+ " if (i == 10) continue;"
+ " if (i == 5) break;"
+ " i = i + 1;"
+ "}"
+ "return i;",
+ 2 * kPointerSize,
+ 1,
+ 77,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaZero), //
+ B(TestLessThan), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(-9), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(50), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(4), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(38), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(10), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(-45), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(5), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(14), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(-69), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var i = 0;"
+ "while (true) {"
+ " while (i < 3) {"
+ " if (i == 2) break;"
+ " i = i + 1;"
+ " }"
+ " i = i + 1;"
+ " break;"
+ "}"
+ "return i;",
+ 2 * kPointerSize,
+ 1,
+ 54,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(TestLessThan), R(1), //
+ B(JumpIfFalse), U8(26), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(14), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(-32), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(4), //
+ B(Jump), U8(-46), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 10;"
+ "var y = 1;"
+ "while (x) {"
+ " y = y * 12;"
+ " x = x - 1;"
+ "}"
+ "return y;",
+ 3 * kPointerSize,
+ 1,
+ 37,
+ {
+ B(LdaSmi8), U8(10), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(JumpIfToBooleanFalse), U8(24), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(12), //
+ B(Mul), R(2), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Sub), R(2), //
+ B(Star), R(0), //
+ B(Jump), U8(-24), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 0; var y = 1;"
+ "do {"
+ " y = y * 10;"
+ " if (x == 5) break;"
+ " if (x == 6) continue;"
+ " x = x + 1;"
+ "} while (x < 10);"
+ "return y;",
+ 3 * kPointerSize,
+ 1,
+ 64,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(10), //
+ B(Mul), R(2), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(5), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(34), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(6), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(12), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(2), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(10), //
+ B(TestLessThan), R(2), //
+ B(JumpIfTrue), U8(-52), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 10;"
+ "var y = 1;"
+ "do {"
+ " y = y * 12;"
+ " x = x - 1;"
+ "} while (x);"
+ "return y;",
+ 3 * kPointerSize,
+ 1,
+ 35,
+ {
+ B(LdaSmi8), U8(10), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(12), //
+ B(Mul), R(2), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Sub), R(2), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(JumpIfToBooleanTrue), U8(-22), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 0; var y = 1;"
+ "do {"
+ " y = y * 10;"
+ " if (x == 5) break;"
+ " x = x + 1;"
+ " if (x == 6) continue;"
+ "} while (false);"
+ "return y;",
+ 3 * kPointerSize,
+ 1,
+ 52,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(10), //
+ B(Mul), R(2), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(5), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(22), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(2), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(6), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(2), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 0; var y = 1;"
+ "do {"
+ " y = y * 10;"
+ " if (x == 5) break;"
+ " x = x + 1;"
+ " if (x == 6) continue;"
+ "} while (true);"
+ "return y;",
+ 3 * kPointerSize,
+ 1,
+ 54,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(10), //
+ B(Mul), R(2), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(5), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(24), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(2), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(6), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(-40), //
+ B(Jump), U8(-42), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 0; "
+ "for (;;) {"
+ " if (x == 1) break;"
+ " if (x == 2) continue;"
+ " x = x + 1;"
+ "}",
+ 2 * kPointerSize,
+ 1,
+ 41,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(26), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(-22), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(-34), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 0},
+ {"for (var x = 0;;) {"
+ " if (x == 1) break;"
+ " if (x == 2) continue;"
+ " x = x + 1;"
+ "}",
+ 2 * kPointerSize,
+ 1,
+ 41,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(26), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(-22), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(-34), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 0; "
+ "for (;; x = x + 1) {"
+ " if (x == 1) break;"
+ " if (x == 2) continue;"
+ "}",
+ 2 * kPointerSize,
+ 1,
+ 41,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(26), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(2), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(-34), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 0},
+ {"for (var x = 0;; x = x + 1) {"
+ " if (x == 1) break;"
+ " if (x == 2) continue;"
+ "}",
+ 2 * kPointerSize,
+ 1,
+ 41,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(26), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqual), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(2), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(-34), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 0},
+ {"var u = 0;"
+ "for (var i = 0; i < 100; i = i + 1) {"
+ " u = u + 1;"
+ " continue;"
+ "}",
+ 3 * kPointerSize,
+ 1,
+ 42,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaZero), //
+ B(Star), R(1), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(100), //
+ B(TestLessThan), R(2), //
+ B(JumpIfFalse), U8(26), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(2), //
+ B(Star), R(0), //
+ B(Jump), U8(2), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(2), //
+ B(Star), R(1), //
+ B(Jump), U8(-32), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 0},
+ {"var y = 1;"
+ "for (var x = 10; x; --x) {"
+ " y = y * 12;"
+ "}"
+ "return y;",
+ 3 * kPointerSize,
+ 1,
+ 33,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(10), //
+ B(Star), R(1), //
+ B(Ldar), R(1), //
+ B(JumpIfToBooleanFalse), U8(20), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(12), //
+ B(Mul), R(2), //
+ B(Star), R(0), //
+ B(Ldar), R(1), //
+ B(ToNumber), //
+ B(Dec), //
+ B(Star), R(1), //
+ B(Jump), U8(-20), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 0;"
+ "for (var i = 0; false; i++) {"
+ " x = x + 1;"
+ "};"
+ "return x;",
+ 2 * kPointerSize,
+ 1,
+ 9,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaZero), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 0;"
+ "for (var i = 0; true; ++i) {"
+ " x = x + 1;"
+ " if (x == 20) break;"
+ "};"
+ "return x;",
+ 3 * kPointerSize,
+ 1,
+ 37,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(LdaZero), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(2), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(20), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(10), //
+ B(Ldar), R(1), //
+ B(ToNumber), //
+ B(Inc), //
+ B(Star), R(1), //
+ B(Jump), U8(-26), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 0},
+ };
+
+ 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(JumpsRequiringConstantWideOperands) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ int constant_count = 0;
+ ExpectedSnippet<Handle<Object>, 316> snippets[] = {
+ {
+ REPEAT_256(SPACE, "var x = 0.1;")
+ REPEAT_32(SPACE, "var x = 0.2;")
+ REPEAT_16(SPACE, "var x = 0.3;")
+ REPEAT_8(SPACE, "var x = 0.4;")
+ "for (var i = 0; i < 3; i++) {\n"
+ " if (i == 1) continue;\n"
+ " if (i == 2) break;\n"
+ "}\n"
+ "return 3;",
+ kPointerSize * 3,
+ 1,
+ 1359,
+ {
+#define L(c) B(LdaConstant), U8(c), B(Star), R(0)
+ REPEAT_256(COMMA, L(constant_count++)),
+#undef L
+#define LW(c) B(LdaConstantWide), U16I(c), B(Star), R(0)
+ REPEAT_32(COMMA, LW(constant_count)),
+ REPEAT_16(COMMA, LW(constant_count)),
+ REPEAT_8(COMMA, LW(constant_count)),
+#undef LW
+ B(LdaZero), //
+ B(Star), R(1), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(3), //
+ B(TestLessThan), R(2), //
+ B(JumpIfFalseConstantWide), U16(313), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalseConstantWide), U16(312), //
+ B(JumpConstantWide), U16(315), //
+ B(Ldar), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqual), R(2), //
+ B(JumpIfFalseConstantWide), U16(312), //
+ B(JumpConstantWide), U16(314), //
+ B(Ldar), R(1), //
+ B(ToNumber), //
+ B(Star), R(2), //
+ B(Inc), //
+ B(Star), R(1), //
+ B(Jump), U8(-47), //
+ B(LdaSmi8), U8(3), //
+ B(Return) //
+ },
+ 316,
+ {
+#define S(x) CcTest::i_isolate()->factory()->NewNumber(x)
+ REPEAT_256(COMMA, S(0.1)),
+ REPEAT_32(COMMA, S(0.2)),
+ REPEAT_16(COMMA, S(0.3)),
+ REPEAT_8(COMMA, S(0.4)),
+#undef S
+#define N(x) CcTest::i_isolate()->factory()->NewNumberFromInt(x)
+ N(6), N(41), N(13), N(17)
+#undef N
+ }}};
+
+ 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(UnaryOperators) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"var x = 0;"
+ "while (x != 10) {"
+ " x = x + 10;"
+ "}"
+ "return x;",
+ 2 * kPointerSize,
+ 1,
+ 29,
+ {
+ B(LdaZero), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(10), //
+ B(TestEqual), R(1), //
+ B(LogicalNot), //
+ B(JumpIfFalse), U8(14), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(10), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Jump), U8(-21), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var x = false;"
+ "do {"
+ " x = !x;"
+ "} while(x == false);"
+ "return x;",
+ 2 * kPointerSize,
+ 1,
+ 20,
+ {
+ B(LdaFalse), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(LogicalNot), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaFalse), //
+ B(TestEqual), R(1), //
+ B(JumpIfTrue), U8(-12), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 101;"
+ "return void(x * 3);",
+ 2 * kPointerSize,
+ 1,
+ 12,
+ {
+ B(LdaSmi8), U8(101), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Mul), R(1), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 1234;"
+ "var y = void (x * x - 1);"
+ "return y;",
+ 4 * kPointerSize,
+ 1,
+ 20,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(Mul), R(2), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(1), //
+ B(Sub), R(3), //
+ B(LdaUndefined), //
+ B(Star), R(1), //
+ B(Return), //
+ },
+ 1,
+ {1234}},
+ {"var x = 13;"
+ "return ~x;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {
+ B(LdaSmi8), U8(13), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(-1), //
+ B(BitwiseXor), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 13;"
+ "return +x;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {
+ B(LdaSmi8), U8(13), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Mul), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 13;"
+ "return -x;",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {
+ B(LdaSmi8), U8(13), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(-1), //
+ B(Mul), R(1), //
+ B(Return), //
+ },
+ 0}};
+
+ 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(Typeof) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
+
+ 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,
+ 6,
+ {
+ B(LdaSmi8), U8(13), //
+ B(Star), R(0), //
+ B(TypeOf), //
+ B(Return), //
+ }},
+ {"var x = 13;\n"
+ "function f() {\n"
+ " return typeof(x);\n"
+ "}; f();",
+ 0,
+ 1,
+ 5,
+ {
+ B(LdaGlobalInsideTypeofSloppy), U8(0), //
+ U8(vector->GetIndex(slot)), //
+ B(TypeOf), //
+ B(Return), //
+ },
+ 1,
+ {"x"}},
+ {"var x = 13;\n"
+ "function f() {\n"
+ " 'use strict';\n"
+ " return typeof(x);\n"
+ "}; f();",
+ 0,
+ 1,
+ 5,
+ {
+ B(LdaGlobalInsideTypeofStrict), U8(0), //
+ U8(vector->GetIndex(slot)), //
+ B(TypeOf), //
+ B(Return), //
+ },
+ 1,
+ {"x"}},
+ };
+
+ 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(Delete) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ int deep_elements_flags =
+ ObjectLiteral::kFastElements | ObjectLiteral::kDisableMementos;
+ int closure = Register::function_closure().index();
+ int first_context_slot = Context::MIN_CONTEXT_SLOTS;
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"var a = {x:13, y:14}; return delete a.x;",
+ 2 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaConstant), U8(1), //
+ B(DeletePropertySloppy), R(1), //
+ B(Return)
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"'use strict'; var a = {x:13, y:14}; return delete a.x;",
+ 2 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaConstant), U8(1), //
+ B(DeletePropertyStrict), R(1), //
+ B(Return)
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"var a = {1:13, 2:14}; return delete a[2];",
+ 2 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(DeletePropertySloppy), R(1), //
+ B(Return)
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ {"var a = 10; return delete a;",
+ 1 * kPointerSize,
+ 1,
+ 6,
+ {
+ B(LdaSmi8), U8(10), //
+ B(Star), R(0), //
+ B(LdaFalse), //
+ B(Return)
+ },
+ 0},
+ {"'use strict';"
+ "var a = {1:10};"
+ "(function f1() {return a;});"
+ "return delete a[1];",
+ 2 * kPointerSize,
+ 1,
+ 27,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(0), //
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateClosure), U8(1), U8(0), //
+ B(LdaContextSlot), R(0), U8(first_context_slot), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(DeletePropertyStrict), R(1), //
+ B(Return)
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"return delete 'test';",
+ 0 * kPointerSize,
+ 1,
+ 2,
+ {
+ B(LdaTrue), //
+ B(Return)
+ },
+ 0},
+ };
+
+ 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(GlobalDelete) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ int context = Register::function_context().index();
+ int native_context_index = Context::NATIVE_CONTEXT_INDEX;
+ int global_context_index = Context::EXTENSION_INDEX;
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"var a = {x:13, y:14};\n function f() { return delete a.x; };\n f();",
+ 1 * kPointerSize,
+ 1,
+ 10,
+ {B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot)), //
+ B(Star), R(0), //
+ B(LdaConstant), U8(1), //
+ B(DeletePropertySloppy), R(0), //
+ B(Return)},
+ 2,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"a = {1:13, 2:14};\n"
+ "function f() {'use strict'; return delete a[1];};\n f();",
+ 1 * kPointerSize,
+ 1,
+ 10,
+ {B(LdaGlobalStrict), U8(0), U8(vector->GetIndex(slot)), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(DeletePropertyStrict), R(0), //
+ B(Return)},
+ 1,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"var a = {x:13, y:14};\n function f() { return delete a; };\n f();",
+ 2 * kPointerSize,
+ 1,
+ 15,
+ {B(LdaContextSlot), R(context), U8(native_context_index), //
+ B(Star), R(0), //
+ B(LdaContextSlot), R(0), U8(global_context_index), //
+ B(Star), R(1), //
+ B(LdaConstant), U8(0), //
+ B(DeletePropertySloppy), R(1), //
+ B(Return)},
+ 1,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"b = 30;\n function f() { return delete b; };\n f();",
+ 2 * kPointerSize,
+ 1,
+ 15,
+ {B(LdaContextSlot), R(context), U8(native_context_index), //
+ B(Star), R(0), //
+ B(LdaContextSlot), R(0), U8(global_context_index), //
+ B(Star), R(1), //
+ B(LdaConstant), U8(0), //
+ B(DeletePropertySloppy), R(1), //
+ B(Return)},
+ 1,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}}};
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(snippets[i].code_snippet, "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(FunctionLiterals) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot = feedback_spec.AddCallICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"return function(){ }",
+ 0,
+ 1,
+ 4,
+ {
+ B(CreateClosure), U8(0), U8(0), //
+ B(Return) //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"return (function(){ })()",
+ 2 * kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaUndefined), //
+ B(Star), R(1), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Star), R(0), //
+ B(Call), R(0), R(1), U8(0), U8(vector->GetIndex(slot)), //
+ B(Return) //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"return (function(x){ return x; })(1)",
+ 3 * kPointerSize,
+ 1,
+ 18,
+ {
+ B(LdaUndefined), //
+ B(Star), R(1), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(2), //
+ B(Call), R(0), R(1), U8(1), U8(vector->GetIndex(slot)), //
+ B(Return) //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ };
+
+ 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(RegExpLiterals) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddCallICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddLoadICSlot();
+ uint8_t i_flags = JSRegExp::kIgnoreCase;
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"return /ab+d/;",
+ 0 * kPointerSize,
+ 1,
+ 5,
+ {
+ B(CreateRegExpLiteral), U8(0), U8(0), U8(0), //
+ B(Return), //
+ },
+ 1,
+ {"ab+d"}},
+ {"return /(\\w+)\\s(\\w+)/i;",
+ 0 * kPointerSize,
+ 1,
+ 5,
+ {
+ B(CreateRegExpLiteral), U8(0), U8(0), U8(i_flags), //
+ B(Return), //
+ },
+ 1,
+ {"(\\w+)\\s(\\w+)"}},
+ {"return /ab+d/.exec('abdd');",
+ 3 * kPointerSize,
+ 1,
+ 22,
+ {
+ B(CreateRegExpLiteral), U8(0), U8(0), U8(0), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(1), U8(vector->GetIndex(slot2)), //
+ B(Star), R(0), //
+ B(LdaConstant), U8(2), //
+ B(Star), R(2), //
+ B(Call), R(0), R(1), U8(1), U8(vector->GetIndex(slot1)), //
+ B(Return), //
+ },
+ 3,
+ {"ab+d", "exec", "abdd"}},
+ };
+
+ 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(RegExpLiteralsWide) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ int wide_idx = 0;
+
+ ExpectedSnippet<InstanceType, 257> snippets[] = {
+ {"var a;" REPEAT_256(SPACE, "a = 1.23;") "return /ab+d/;",
+ 1 * kPointerSize,
+ 1,
+ 1031,
+ {
+ REPEAT_256(COMMA, //
+ B(LdaConstant), U8(wide_idx++), //
+ B(Star), R(0)), //
+ B(CreateRegExpLiteralWide), U16(256), U16(0), U8(0), //
+ B(Return) //
+ },
+ 257,
+ {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ };
+
+ 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(ArrayLiterals) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddKeyedStoreICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddKeyedStoreICSlot();
+ FeedbackVectorSlot slot3 = feedback_spec.AddKeyedStoreICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ int simple_flags =
+ ArrayLiteral::kDisableMementos | ArrayLiteral::kShallowElements;
+ int deep_elements_flags = ArrayLiteral::kDisableMementos;
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"return [ 1, 2 ];",
+ 0,
+ 1,
+ 5,
+ {
+ B(CreateArrayLiteral), U8(0), U8(0), U8(simple_flags), //
+ B(Return) //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ {"var a = 1; return [ a, a + 1 ];",
+ 4 * kPointerSize,
+ 1,
+ 38,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(CreateArrayLiteral), U8(0), U8(0), U8(3), //
+ B(Star), R(2), //
+ B(LdaZero), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(KeyedStoreICSloppy), R(2), R(1), U8(vector->GetIndex(slot1)), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(3), //
+ B(KeyedStoreICSloppy), R(2), R(1), U8(vector->GetIndex(slot1)), //
+ B(Ldar), R(2), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ {"return [ [ 1, 2 ], [ 3 ] ];",
+ 0,
+ 1,
+ 5,
+ {
+ B(CreateArrayLiteral), U8(0), U8(2), U8(deep_elements_flags), //
+ B(Return) //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ {"var a = 1; return [ [ a, 2 ], [ a + 2 ] ];",
+ 6 * kPointerSize,
+ 1,
+ 68,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(CreateArrayLiteral), U8(0), U8(2), U8(deep_elements_flags), //
+ B(Star), R(2), //
+ B(LdaZero), //
+ B(Star), R(1), //
+ B(CreateArrayLiteral), U8(1), U8(0), U8(simple_flags), //
+ B(Star), R(4), //
+ B(LdaZero), //
+ B(Star), R(3), //
+ B(Ldar), R(0), //
+ B(KeyedStoreICSloppy), R(4), R(3), U8(vector->GetIndex(slot1)), //
+ B(Ldar), R(4), //
+ B(KeyedStoreICSloppy), R(2), R(1), U8(vector->GetIndex(slot3)), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(CreateArrayLiteral), U8(2), U8(1), U8(simple_flags), //
+ B(Star), R(4), //
+ B(LdaZero), //
+ B(Star), R(3), //
+ B(Ldar), R(0), //
+ B(Star), R(5), //
+ B(LdaSmi8), U8(2), //
+ B(Add), R(5), //
+ B(KeyedStoreICSloppy), R(4), R(3), U8(vector->GetIndex(slot2)), //
+ B(Ldar), R(4), //
+ B(KeyedStoreICSloppy), R(2), R(1), U8(vector->GetIndex(slot3)), //
+ B(Ldar), R(2), //
+ B(Return), //
+ },
+ 3,
+ {InstanceType::FIXED_ARRAY_TYPE, InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE}},
+ };
+
+ 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(ArrayLiteralsWide) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ int wide_idx = 0;
+ int simple_flags =
+ ArrayLiteral::kDisableMementos | ArrayLiteral::kShallowElements;
+
+ ExpectedSnippet<InstanceType, 257> snippets[] = {
+ {"var a;" REPEAT_256(SPACE, "a = 1.23;") "return [ 1 , 2 ];",
+ 1 * kPointerSize,
+ 1,
+ 1031,
+ {
+ REPEAT_256(COMMA, //
+ B(LdaConstant), U8(wide_idx++), //
+ B(Star), R(0)), //
+ B(CreateArrayLiteralWide), U16(256), U16(0), U8(simple_flags), //
+ B(Return) //
+ },
+ 257,
+ {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+ InstanceType::FIXED_ARRAY_TYPE}},
+ };
+
+ 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(ObjectLiterals) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddStoreICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ int simple_flags = ObjectLiteral::kFastElements |
+ ObjectLiteral::kShallowProperties |
+ ObjectLiteral::kDisableMementos;
+ int deep_elements_flags =
+ ObjectLiteral::kFastElements | ObjectLiteral::kDisableMementos;
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"return { };",
+ 0,
+ 1,
+ 5,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(simple_flags), //
+ B(Return) //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ {"return { name: 'string', val: 9.2 };",
+ 0,
+ 1,
+ 5,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Return) //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ {"var a = 1; return { name: 'string', val: a };",
+ 2 * kPointerSize,
+ 1,
+ 19,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(StoreICSloppy), R(1), U8(1), U8(vector->GetIndex(slot1)), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"var a = 1; return { val: a, val: a + 1 };",
+ 3 * kPointerSize,
+ 1,
+ 25,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(2), //
+ B(StoreICSloppy), R(1), U8(1), U8(vector->GetIndex(slot1)), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"return { func: function() { } };",
+ 1 * kPointerSize,
+ 1,
+ 16,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(0), //
+ B(CreateClosure), U8(1), U8(0), //
+ B(StoreICSloppy), R(0), U8(2), U8(vector->GetIndex(slot1)), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 3,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"return { func(a) { return a; } };",
+ 1 * kPointerSize,
+ 1,
+ 16,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(0), //
+ B(CreateClosure), U8(1), U8(0), //
+ B(StoreICSloppy), R(0), U8(2), U8(vector->GetIndex(slot1)), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 3,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"return { get a() { return 2; } };",
+ 5 * kPointerSize,
+ 1,
+ 29,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(0), //
+ B(LdaConstant), U8(1), //
+ B(Star), R(1), //
+ B(CreateClosure), U8(2), U8(0), //
+ B(Star), R(2), //
+ B(LdaNull), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), //
+ R(0), U8(5), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 3,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"return { get a() { return this.x; }, set a(val) { this.x = val } };",
+ 5 * kPointerSize,
+ 1,
+ 31,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(0), //
+ B(LdaConstant), U8(1), //
+ B(Star), R(1), //
+ B(CreateClosure), U8(2), U8(0), //
+ B(Star), R(2), //
+ B(CreateClosure), U8(3), U8(0), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), //
+ R(0), U8(5), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 4,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"return { set b(val) { this.y = val } };",
+ 5 * kPointerSize,
+ 1,
+ 29,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(0), //
+ B(LdaConstant), U8(1), //
+ B(Star), R(1), //
+ B(LdaNull), //
+ B(Star), R(2), //
+ B(CreateClosure), U8(2), U8(0), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kDefineAccessorPropertyUnchecked), //
+ R(0), U8(5), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 3,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"var a = 1; return { 1: a };",
+ 5 * kPointerSize,
+ 1,
+ 29,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kSetProperty), R(1), U8(4), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ {"return { __proto__: null }",
+ 2 * kPointerSize,
+ 1,
+ 17,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(simple_flags), //
+ B(Star), R(0), //
+ B(LdaNull), B(Star), R(1), //
+ B(CallRuntime), U16(Runtime::kInternalSetPrototype), R(0), U8(2), //
+ B(Ldar), R(0), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ {"var a = 'test'; return { [a]: 1 }",
+ 5 * kPointerSize,
+ 1,
+ 30,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(0), //
+ B(CreateObjectLiteral), U8(1), U8(0), U8(simple_flags), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(ToName), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyUnchecked), R(1), //
+ U8(4), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE}},
+ {"var a = 'test'; return { val: a, [a]: 1 }",
+ 5 * kPointerSize,
+ 1,
+ 36,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(0), //
+ B(CreateObjectLiteral), U8(1), U8(0), U8(deep_elements_flags), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(StoreICSloppy), R(1), U8(2), U8(vector->GetIndex(slot1)), //
+ B(Ldar), R(0), //
+ B(ToName), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyUnchecked), R(1), //
+ U8(4), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 3,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"var a = 'test'; return { [a]: 1, __proto__: {} }",
+ 5 * kPointerSize,
+ 1,
+ 41,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(0), //
+ B(CreateObjectLiteral), U8(1), U8(1), U8(simple_flags), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(ToName), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyUnchecked), R(1), //
+ U8(4), //
+ B(CreateObjectLiteral), U8(1), U8(0), U8(13), //
+ B(Star), R(2), //
+ B(CallRuntime), U16(Runtime::kInternalSetPrototype), R(1), U8(2), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE}},
+ {"var n = 'name'; return { [n]: 'val', get a() { }, set a(b) {} };",
+ 5 * kPointerSize,
+ 1,
+ 64,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(0), //
+ B(CreateObjectLiteral), U8(1), U8(0), U8(simple_flags), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(ToName), //
+ B(Star), R(2), //
+ B(LdaConstant), U8(2), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kDefineDataPropertyUnchecked), R(1), //
+ U8(4), //
+ B(LdaConstant), U8(3), //
+ B(Star), R(2), //
+ B(CreateClosure), U8(4), U8(0), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kDefineGetterPropertyUnchecked), //
+ R(1), U8(4), //
+ B(LdaConstant), U8(3), //
+ B(Star), R(2), //
+ B(CreateClosure), U8(5), U8(0), //
+ B(Star), R(3), //
+ B(LdaZero), //
+ B(Star), R(4), //
+ B(CallRuntime), U16(Runtime::kDefineSetterPropertyUnchecked), //
+ R(1), U8(4), //
+ B(Ldar), R(1), //
+ B(Return), //
+ },
+ 6,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ };
+
+ 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(ObjectLiteralsWide) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ int deep_elements_flags =
+ ObjectLiteral::kFastElements | ObjectLiteral::kDisableMementos;
+ int wide_idx = 0;
+
+ ExpectedSnippet<InstanceType, 257> snippets[] = {
+ {"var a;" REPEAT_256(SPACE,
+ "a = 1.23;") "return { name: 'string', val: 9.2 };",
+ 1 * kPointerSize,
+ 1,
+ 1031,
+ {
+ REPEAT_256(COMMA, //
+ B(LdaConstant), U8(wide_idx++), //
+ B(Star), R(0)), //
+ B(CreateObjectLiteralWide), U16(256), U16(0), //
+ U8(deep_elements_flags), //
+ B(Return) //
+ },
+ 257,
+ {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+ InstanceType::FIXED_ARRAY_TYPE}},
+ };
+
+ 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(TopLevelObjectLiterals) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ int has_function_flags = ObjectLiteral::kFastElements |
+ ObjectLiteral::kHasFunction |
+ ObjectLiteral::kDisableMementos;
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"var a = { func: function() { } };",
+ 5 * kPointerSize,
+ 1,
+ 48,
+ {
+ 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(CreateObjectLiteral), U8(2), U8(0), U8(has_function_flags), //
+ B(Star), R(4), //
+ B(CreateClosure), U8(3), U8(1), //
+ B(StoreICSloppy), R(4), U8(4), U8(3), //
+ B(CallRuntime), U16(Runtime::kToFastProperties), R(4), U8(1), //
+ B(Ldar), R(4), //
+ B(Star), R(3), //
+ B(CallRuntime), U16(Runtime::kInitializeVarGlobal), R(1), U8(3), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 5,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_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);
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(TryCatch) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ // TODO(rmcilroy): modify tests when we have real try catch support.
+ ExpectedSnippet<int> snippets[] = {
+ {"try { return 1; } catch(e) { return 2; }",
+ kPointerSize,
+ 1,
+ 3,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Return), //
+ },
+ 0},
+ };
+
+ 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(TryFinally) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ // TODO(rmcilroy): modify tests when we have real try finally support.
+ ExpectedSnippet<int> snippets[] = {
+ {"var a = 1; try { a = 2; } finally { a = 3; }",
+ kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(0), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 0},
+ {"var a = 1; try { a = 2; } catch(e) { a = 20 } finally { a = 3; }",
+ 2 * kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(0), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 0},
+ };
+
+ 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(Throw) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ // TODO(rmcilroy): modify tests when we have real try catch support.
+ ExpectedSnippet<const char*> snippets[] = {
+ {"throw 1;",
+ 0,
+ 1,
+ 3,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Throw), //
+ },
+ 0},
+ {"throw 'Error';",
+ 0,
+ 1,
+ 3,
+ {
+ B(LdaConstant), U8(0), //
+ B(Throw), //
+ },
+ 1,
+ {"Error"}},
+ {"var a = 1; if (a) { throw 'Error'; };",
+ 1 * kPointerSize,
+ 1,
+ 11,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(JumpIfToBooleanFalse), U8(5), //
+ B(LdaConstant), U8(0), //
+ B(Throw), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {"Error"}},
+ };
+
+ 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(CallNew) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddGeneralSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddLoadICSlot();
+ USE(slot1);
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"function bar() { this.value = 0; }\n"
+ "function f() { return new bar(); }\n"
+ "f()",
+ 1 * kPointerSize,
+ 1,
+ 10,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Star), R(0), //
+ B(New), R(0), R(0), U8(0), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"function bar(x) { this.value = 18; this.x = x;}\n"
+ "function f() { return new bar(3); }\n"
+ "f()",
+ 2 * kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(1), //
+ B(New), R(0), R(1), U8(1), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"function bar(w, x, y, z) {\n"
+ " this.value = 18;\n"
+ " this.x = x;\n"
+ " this.y = y;\n"
+ " this.z = z;\n"
+ "}\n"
+ "function f() { return new bar(3, 4, 5); }\n"
+ "f()",
+ 4 * kPointerSize,
+ 1,
+ 22,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(4), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(5), //
+ B(Star), R(3), //
+ B(New), R(0), R(1), U8(3), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(snippets[i].code_snippet, "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(ContextVariables) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot = feedback_spec.AddCallICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ int closure = Register::function_closure().index();
+ int new_target = Register::new_target().index();
+ int first_context_slot = Context::MIN_CONTEXT_SLOTS;
+
+ // The wide check below relies on MIN_CONTEXT_SLOTS + 3 + 249 == 256, if this
+ // ever changes, the REPEAT_XXX should be changed to output the correct number
+ // of unique variables to trigger the wide slot load / store.
+ STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS + 3 + 249 == 256);
+ int wide_slot = first_context_slot + 3;
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"var a; return function() { a = 1; };",
+ 1 * kPointerSize,
+ 1,
+ 11,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(0), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"var a = 1; return function() { a = 2; };",
+ 1 * kPointerSize,
+ 1,
+ 16,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"var a = 1; var b = 2; return function() { a = 2; b = 3 };",
+ 1 * kPointerSize,
+ 1,
+ 21,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(LdaSmi8), U8(2), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 1), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"var a; (function() { a = 2; })(); return a;",
+ 3 * kPointerSize,
+ 1,
+ 24,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(0), //
+ B(LdaUndefined), //
+ B(Star), R(2), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Star), R(1), //
+ B(Call), R(1), R(2), U8(0), U8(vector->GetIndex(slot)), //
+ B(LdaContextSlot), R(0), U8(first_context_slot), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"'use strict'; let a = 1; { let b = 2; return function() { a + b; }; }",
+ 4 * kPointerSize,
+ 1,
+ 44,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(0), //
+ B(LdaTheHole), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(LdaSmi8), U8(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(LdaConstant), U8(0), //
+ B(Star), R(2), //
+ B(Ldar), R(closure), //
+ B(Star), R(3), //
+ B(CallRuntime), U16(Runtime::kPushBlockContext), R(2), U8(2), //
+ B(PushContext), R(1), //
+ B(LdaTheHole), //
+ B(StaContextSlot), R(1), U8(first_context_slot), //
+ B(LdaSmi8), U8(2), //
+ B(StaContextSlot), R(1), U8(first_context_slot), //
+ B(CreateClosure), U8(1), U8(0), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"'use strict';\n"
+ REPEAT_249_UNIQUE_VARS()
+ "eval();"
+ "var b = 100;"
+ "return b",
+ 3 * kPointerSize,
+ 1,
+ 1041,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
+ U8(1), //
+ B(PushContext), R(0), //
+ B(Ldar), THIS(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateUnmappedArguments), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 1), //
+ B(Ldar), R(new_target), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 2), //
+ REPEAT_249(COMMA, //
+ B(LdaZero), //
+ B(StaContextSlot), R(0), U8(wide_slot++)), //
+ B(LdaUndefined), //
+ B(Star), R(2), //
+ B(LdaGlobalStrict), U8(0), U8(1), //
+ B(Star), R(1), //
+ B(Call), R(1), R(2), U8(0), U8(0), //
+ B(LdaSmi8), U8(100), //
+ B(StaContextSlotWide), R(0), U16(256), //
+ B(LdaContextSlotWide), R(0), U16(256), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ };
+
+ 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(ContextParameters) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ int closure = Register::function_closure().index();
+ int first_context_slot = Context::MIN_CONTEXT_SLOTS;
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"function f(arg1) { return function() { arg1 = 2; }; }",
+ 1 * kPointerSize,
+ 2,
+ 16,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(0), //
+ B(Ldar), R(helper.kLastParamIndex), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"function f(arg1) { var a = function() { arg1 = 2; }; return arg1; }",
+ 2 * kPointerSize,
+ 2,
+ 21,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(1), //
+ B(Ldar), R(helper.kLastParamIndex), //
+ B(StaContextSlot), R(1), U8(first_context_slot), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Star), R(0), //
+ B(LdaContextSlot), R(1), U8(first_context_slot), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"function f(a1, a2, a3, a4) { return function() { a1 = a3; }; }",
+ 1 * kPointerSize,
+ 5,
+ 21,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(0), //
+ B(Ldar), R(helper.kLastParamIndex - 3), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 1), //
+ B(Ldar), R(helper.kLastParamIndex -1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"function f() { var self = this; return function() { self = 2; }; }",
+ 1 * kPointerSize,
+ 1,
+ 16,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), //
+ R(closure), U8(1), //
+ B(PushContext), R(0), //
+ B(Ldar), R(helper.kLastParamIndex), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ };
+
+ 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(OuterContextVariables) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ int context = Register::function_context().index();
+ int first_context_slot = Context::MIN_CONTEXT_SLOTS;
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"function Outer() {"
+ " var outerVar = 1;"
+ " function Inner(innerArg) {"
+ " this.innerFunc = function() { return outerVar * innerArg; }"
+ " }"
+ " this.getInnerFunc = function() { return new Inner(1).innerFunc; }"
+ "}"
+ "var f = new Outer().getInnerFunc();",
+ 2 * kPointerSize,
+ 1,
+ 20,
+ {
+ B(Ldar), R(context), //
+ B(Star), R(0), //
+ B(LdaContextSlot), R(0), U8(Context::PREVIOUS_INDEX), //
+ B(Star), R(0), //
+ B(LdaContextSlot), R(0), U8(first_context_slot), //
+ B(Star), R(1), //
+ B(LdaContextSlot), R(context), U8(first_context_slot), //
+ B(Mul), R(1), //
+ B(Return), //
+ }},
+ {"function Outer() {"
+ " var outerVar = 1;"
+ " function Inner(innerArg) {"
+ " this.innerFunc = function() { outerVar = innerArg; }"
+ " }"
+ " this.getInnerFunc = function() { return new Inner(1).innerFunc; }"
+ "}"
+ "var f = new Outer().getInnerFunc();",
+ 2 * kPointerSize,
+ 1,
+ 21,
+ {
+ B(LdaContextSlot), R(context), U8(first_context_slot), //
+ B(Star), R(0), //
+ B(Ldar), R(context), //
+ B(Star), R(1), //
+ B(LdaContextSlot), R(1), U8(Context::PREVIOUS_INDEX), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(StaContextSlot), R(1), U8(first_context_slot), //
+ B(LdaUndefined), //
+ B(Return), //
+ }},
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecodeForFunctionNoFilter(snippets[i].code_snippet);
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(CountOperators) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddLoadICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddStoreICSlot();
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ FeedbackVectorSpec store_feedback_spec(&zone);
+ FeedbackVectorSlot store_slot = store_feedback_spec.AddStoreICSlot();
+ Handle<i::TypeFeedbackVector> store_vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &store_feedback_spec);
+
+ int closure = Register::function_closure().index();
+ int first_context_slot = Context::MIN_CONTEXT_SLOTS;
+
+ 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,
+ 9,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(ToNumber), //
+ B(Inc), //
+ B(Star), R(0), //
+ B(Return), //
+ }},
+ {"var a = 1; return a++;",
+ 2 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), 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,
+ 9,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(ToNumber), //
+ B(Dec), //
+ B(Star), R(0), //
+ B(Return), //
+ }},
+ {"var a = 1; return a--;",
+ 2 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), 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++;",
+ 3 * kPointerSize,
+ 1,
+ 23,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(object_literal_flags), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(1), U8(vector->GetIndex(slot1)), //
+ B(ToNumber), //
+ B(Star), R(2), //
+ B(Inc), //
+ B(StoreICSloppy), R(1), U8(1), U8(vector->GetIndex(slot2)), //
+ B(Ldar), R(2), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"var a = { val: 1 }; return --a.val;",
+ 2 * kPointerSize,
+ 1,
+ 19,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(object_literal_flags), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(1), U8(vector->GetIndex(slot1)), //
+ B(ToNumber), //
+ B(Dec), //
+ B(StoreICSloppy), R(1), U8(1), U8(vector->GetIndex(slot2)), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"var name = 'var'; var a = { val: 1 }; return a[name]--;",
+ 5 * kPointerSize,
+ 1,
+ 30,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(0), //
+ B(CreateObjectLiteral), U8(1), U8(0), U8(object_literal_flags), //
+ B(Star), R(1), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(Star), R(3), //
+ B(KeyedLoadICSloppy), R(2), U8(vector->GetIndex(slot1)), //
+ B(ToNumber), //
+ B(Star), R(4), //
+ B(Dec), //
+ B(KeyedStoreICSloppy), R(2), R(3), U8(vector->GetIndex(slot2)), //
+ B(Ldar), R(4), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE}},
+ {"var name = 'var'; var a = { val: 1 }; return ++a[name];",
+ 4 * kPointerSize,
+ 1,
+ 26,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(0), //
+ B(CreateObjectLiteral), U8(1), U8(0), U8(object_literal_flags), //
+ B(Star), R(1), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(Star), R(3), //
+ B(KeyedLoadICSloppy), R(2), U8(vector->GetIndex(slot1)), //
+ B(ToNumber), //
+ B(Inc), //
+ B(KeyedStoreICSloppy), R(2), R(3), U8(vector->GetIndex(slot2)), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::FIXED_ARRAY_TYPE}},
+ {"var a = 1; var b = function() { return a }; return ++a;",
+ 2 * kPointerSize,
+ 1,
+ 26,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
+ U8(1), //
+ B(PushContext), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(StaContextSlot), R(1), U8(first_context_slot), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Star), R(0), //
+ B(LdaContextSlot), R(1), U8(first_context_slot), //
+ B(ToNumber), //
+ B(Inc), //
+ B(StaContextSlot), R(1), U8(first_context_slot), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"var a = 1; var b = function() { return a }; return a--;",
+ 3 * kPointerSize,
+ 1,
+ 30,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
+ U8(1), //
+ B(PushContext), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(StaContextSlot), R(1), U8(first_context_slot), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(Star), R(0), //
+ B(LdaContextSlot), R(1), U8(first_context_slot), //
+ B(ToNumber), //
+ B(Star), R(2), //
+ B(Dec), //
+ B(StaContextSlot), R(1), U8(first_context_slot), //
+ B(Ldar), R(2), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ {"var idx = 1; var a = [1, 2]; return a[idx++] = 2;",
+ 4 * kPointerSize,
+ 1,
+ 27,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(CreateArrayLiteral), U8(0), U8(0), U8(array_literal_flags), //
+ B(Star), R(1), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(ToNumber), //
+ B(Star), R(3), //
+ B(Inc), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(2), //
+ B(KeyedStoreICSloppy), R(2), R(3), //
+ U8(store_vector->GetIndex(store_slot)), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ };
+
+ 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(GlobalCountOperators) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddLoadICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddStoreICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"var global = 1;\nfunction f() { return ++global; }\nf()",
+ 0,
+ 1,
+ 9,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot1)), //
+ B(ToNumber), //
+ B(Inc), //
+ B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Return), //
+ },
+ 1,
+ {"global"}},
+ {"var global = 1;\nfunction f() { return global--; }\nf()",
+ 1 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot1)), //
+ B(ToNumber), //
+ B(Star), R(0), //
+ B(Dec), //
+ B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Ldar), R(0), //
+ B(Return),
+ },
+ 1,
+ {"global"}},
+ {"unallocated = 1;\nfunction f() { 'use strict'; return --unallocated; }"
+ "f()",
+ 0,
+ 1,
+ 9,
+ {
+ B(LdaGlobalStrict), U8(0), U8(vector->GetIndex(slot1)), //
+ B(ToNumber), //
+ B(Dec), //
+ B(StaGlobalStrict), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Return), //
+ },
+ 1,
+ {"unallocated"}},
+ {"unallocated = 1;\nfunction f() { return unallocated++; }\nf()",
+ 1 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot1)), //
+ B(ToNumber), //
+ B(Star), R(0), //
+ B(Inc), //
+ B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Ldar), R(0), //
+ B(Return),
+ },
+ 1,
+ {"unallocated"}},
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(snippets[i].code_snippet, "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(CompoundExpressions) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ int closure = Register::function_closure().index();
+ int first_context_slot = Context::MIN_CONTEXT_SLOTS;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddLoadICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddStoreICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ int object_literal_flags =
+ ObjectLiteral::kFastElements | ObjectLiteral::kDisableMementos;
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"var a = 1; a += 2;",
+ 2 * kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(LdaUndefined), //
+ B(Return), //
+ }},
+ {"var a = 1; a /= 2;",
+ 2 * kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(Div), R(1), //
+ B(Star), R(0), //
+ B(LdaUndefined), //
+ B(Return), //
+ }},
+ {"var a = { val: 2 }; a.name *= 2;",
+ 3 * kPointerSize,
+ 1,
+ 24,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(object_literal_flags), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LoadICSloppy), R(1), U8(1), U8(vector->GetIndex(slot1)), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(2), //
+ B(Mul), R(2), //
+ B(StoreICSloppy), R(1), U8(1), U8(vector->GetIndex(slot2)), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"var a = { 1: 2 }; a[1] ^= 2;",
+ 4 * kPointerSize,
+ 1,
+ 27,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(object_literal_flags), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(2), //
+ B(KeyedLoadICSloppy), R(1), U8(vector->GetIndex(slot1)), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(2), //
+ B(BitwiseXor), R(3), //
+ B(KeyedStoreICSloppy), R(1), R(2), U8(vector->GetIndex(slot2)), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::FIXED_ARRAY_TYPE}},
+ {"var a = 1; (function f() { return a; }); a |= 24;",
+ 2 * kPointerSize,
+ 1,
+ 29,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
+ U8(1), //
+ B(PushContext), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(LdaContextSlot), R(0), U8(first_context_slot), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(24), //
+ B(BitwiseOr), R(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
+ };
+
+ 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(GlobalCompoundExpressions) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddLoadICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddStoreICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"var global = 1;\nfunction f() { return global &= 1; }\nf()",
+ 1 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot1)), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(BitwiseAnd), R(0), //
+ B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Return), //
+ },
+ 1,
+ {"global"}},
+ {"unallocated = 1;\nfunction f() { return unallocated += 1; }\nf()",
+ 1 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(LdaGlobalSloppy), U8(0), U8(vector->GetIndex(slot1)), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(0), //
+ B(StaGlobalSloppy), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Return), //
+ },
+ 1,
+ {"unallocated"}},
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(snippets[i].code_snippet, "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(CreateArguments) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ int closure = Register::function_closure().index();
+ int first_context_slot = Context::MIN_CONTEXT_SLOTS;
+
+ 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,
+ 4,
+ {
+ B(CreateMappedArguments), //
+ B(Star), R(0), //
+ B(Return), //
+ }},
+ {"function f() { return arguments[0]; }",
+ 2 * kPointerSize,
+ 1,
+ 10,
+ {
+ B(CreateMappedArguments), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaZero), //
+ B(KeyedLoadICSloppy), R(1), U8(vector->GetIndex(slot)), //
+ B(Return), //
+ }},
+ {"function f() { 'use strict'; return arguments; }",
+ 1 * kPointerSize,
+ 1,
+ 4,
+ {
+ B(CreateUnmappedArguments), //
+ B(Star), R(0), //
+ B(Return), //
+ }},
+ {"function f(a) { return arguments[0]; }",
+ 3 * kPointerSize,
+ 2,
+ 22,
+ {
+ 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(Star), R(2), //
+ B(LdaZero), //
+ B(KeyedLoadICSloppy), R(2), U8(vector->GetIndex(slot)), //
+ B(Return), //
+ }},
+ {"function f(a, b, c) { return arguments; }",
+ 2 * kPointerSize,
+ 4,
+ 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(Return), //
+ }},
+ {"function f(a, b, c) { 'use strict'; return arguments; }",
+ 1 * kPointerSize,
+ 4,
+ 4,
+ {
+ B(CreateUnmappedArguments), //
+ B(Star), 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(IllegalRedeclaration) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ CHECK_GE(MessageTemplate::kVarRedeclaration, 128);
+ // Must adapt bytecode if this changes.
+
+ ExpectedSnippet<Handle<Object>, 2> snippets[] = {
+ {"const a = 1; { var a = 2; }",
+ 3 * kPointerSize,
+ 1,
+ 14,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(1), //
+ B(LdaConstant), U8(1), //
+ B(Star), R(2), //
+ B(CallRuntime), U16(Runtime::kNewSyntaxError), R(1), U8(2), //
+ B(Throw), //
+ },
+ 2,
+ {helper.factory()->NewNumberFromInt(MessageTemplate::kVarRedeclaration),
+ helper.factory()->NewStringFromAsciiChecked("a")}},
+ };
+
+ 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(ForIn) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ int simple_flags =
+ ArrayLiteral::kDisableMementos | ArrayLiteral::kShallowElements;
+ int deep_elements_flags =
+ ObjectLiteral::kFastElements | ObjectLiteral::kDisableMementos;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ feedback_spec.AddStoreICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddStoreICSlot();
+ FeedbackVectorSlot slot3 = feedback_spec.AddStoreICSlot();
+ FeedbackVectorSlot slot4 = feedback_spec.AddStoreICSlot();
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"for (var p in null) {}",
+ 2 * kPointerSize,
+ 1,
+ 2,
+ {B(LdaUndefined), B(Return)},
+ 0},
+ {"for (var p in undefined) {}",
+ 2 * kPointerSize,
+ 1,
+ 2,
+ {B(LdaUndefined), B(Return)},
+ 0},
+ {"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; }",
+ 8 * kPointerSize,
+ 1,
+ 45,
+ {
+ B(LdaConstant), U8(0), //
+ B(Star), R(1), //
+ B(JumpIfUndefined), U8(39), //
+ B(JumpIfNull), U8(37), //
+ B(ToObject), //
+ B(JumpIfNull), U8(34), //
+ B(Star), R(3), //
+ B(ForInPrepare), R(4), R(5), R(6), //
+ B(LdaZero), //
+ B(Star), R(7), //
+ B(ForInDone), R(7), R(6), //
+ B(JumpIfTrue), U8(20), //
+ B(ForInNext), R(3), R(4), R(5), R(7), //
+ B(JumpIfUndefined), U8(7), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(Return), //
+ B(ForInStep), R(7), //
+ B(Star), R(7), //
+ B(Jump), U8(-21), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"var x = 0;\n"
+ "for (var p in [1,2,3]) { x += p; }",
+ 9 * kPointerSize,
+ 1,
+ 57,
+ {
+ B(LdaZero), //
+ B(Star), R(1), //
+ B(CreateArrayLiteral), U8(0), U8(0), U8(3), //
+ B(JumpIfUndefined), U8(48), //
+ B(JumpIfNull), U8(46), //
+ B(ToObject), //
+ B(JumpIfNull), U8(43), //
+ B(Star), R(3), //
+ B(ForInPrepare), R(4), R(5), R(6), //
+ B(LdaZero), //
+ B(Star), R(7), //
+ B(ForInDone), R(7), R(6), //
+ B(JumpIfTrue), U8(29), //
+ B(ForInNext), R(3), R(4), R(5), R(7), //
+ B(JumpIfUndefined), U8(16), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(Ldar), R(1), //
+ B(Star), R(8), //
+ B(Ldar), R(2), //
+ B(Add), R(8), //
+ B(Star), R(1), //
+ B(ForInStep), R(7), //
+ B(Star), R(7), //
+ B(Jump), U8(-30), //
+ 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"
+ "}",
+ 8 * kPointerSize,
+ 1,
+ 94,
+ {
+ B(CreateObjectLiteral), U8(0), U8(0), U8(deep_elements_flags), //
+ B(Star), R(0), //
+ B(CreateArrayLiteral), U8(1), U8(1), U8(simple_flags), //
+ B(JumpIfUndefined), U8(82), //
+ B(JumpIfNull), U8(80), //
+ B(ToObject), //
+ B(JumpIfNull), U8(77), //
+ B(Star), R(1), //
+ B(ForInPrepare), R(2), R(3), R(4), //
+ B(LdaZero), //
+ B(Star), R(5), //
+ B(ForInDone), R(5), R(4), //
+ B(JumpIfTrue), U8(63), //
+ B(ForInNext), R(1), R(2), R(3), R(5), //
+ B(JumpIfUndefined), U8(50), //
+ B(Star), R(6), //
+ B(Ldar), R(0), //
+ B(Star), R(7), //
+ B(Ldar), R(6), //
+ B(StoreICSloppy), R(7), U8(2), U8(vector->GetIndex(slot4)), //
+ B(Ldar), R(0), //
+ B(Star), R(6), //
+ B(LoadICSloppy), R(6), U8(2), U8(vector->GetIndex(slot2)), //
+ B(Star), R(7), //
+ B(LdaSmi8), U8(10), //
+ B(TestEqual), R(7), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(20), //
+ B(Ldar), R(0), //
+ B(Star), R(6), //
+ B(LoadICSloppy), R(6), U8(2), U8(vector->GetIndex(slot3)), //
+ B(Star), R(7), //
+ B(LdaSmi8), U8(20), //
+ B(TestEqual), R(7), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(8), //
+ B(ForInStep), R(5), //
+ B(Star), R(5), //
+ B(Jump), U8(-64), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 3,
+ {InstanceType::FIXED_ARRAY_TYPE, InstanceType::FIXED_ARRAY_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"var x = [ 10, 11, 12 ] ;\n"
+ "for (x[0] in [1,2,3]) { return x[3]; }",
+ 9 * kPointerSize,
+ 1,
+ 71,
+ {
+ B(CreateArrayLiteral), U8(0), U8(0), U8(simple_flags), //
+ B(Star), R(0), //
+ B(CreateArrayLiteral), U8(1), U8(1), U8(simple_flags), //
+ B(JumpIfUndefined), U8(59), //
+ B(JumpIfNull), U8(57), //
+ B(ToObject), //
+ B(JumpIfNull), U8(54), //
+ B(Star), R(1), //
+ B(ForInPrepare), R(2), R(3), R(4), //
+ B(LdaZero), //
+ B(Star), R(5), //
+ B(ForInDone), R(5), R(4), //
+ B(JumpIfTrue), U8(40), //
+ B(ForInNext), R(1), R(2), R(3), R(5), //
+ B(JumpIfUndefined), U8(27), //
+ B(Star), R(6), //
+ B(Ldar), R(0), //
+ B(Star), R(7), //
+ B(LdaZero), //
+ B(Star), R(8), //
+ B(Ldar), R(6), //
+ B(KeyedStoreICSloppy), R(7), R(8), U8(vector->GetIndex(slot3)), //
+ B(Ldar), R(0), //
+ B(Star), R(6), //
+ B(LdaSmi8), U8(3), //
+ B(KeyedLoadICSloppy), R(6), U8(vector->GetIndex(slot2)), //
+ B(Return), //
+ B(ForInStep), R(5), //
+ B(Star), R(5), //
+ B(Jump), U8(-41), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 2,
+ {InstanceType::FIXED_ARRAY_TYPE, InstanceType::FIXED_ARRAY_TYPE}},
+ };
+
+ 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(Conditional) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"return 1 ? 2 : 3;",
+ 0,
+ 1,
+ 11,
+ {
+ B(LdaSmi8), U8(1), //
+ B(JumpIfToBooleanFalse), U8(6), //
+ B(LdaSmi8), U8(2), //
+ B(Jump), U8(4), //
+ B(LdaSmi8), U8(3), //
+ B(Return), //
+ }},
+ {"return 1 ? 2 ? 3 : 4 : 5;",
+ 0,
+ 1,
+ 19,
+ {
+ B(LdaSmi8), U8(1), //
+ B(JumpIfToBooleanFalse), U8(14), //
+ B(LdaSmi8), U8(2), //
+ B(JumpIfToBooleanFalse), U8(6), //
+ B(LdaSmi8), U8(3), //
+ B(Jump), U8(4), //
+ B(LdaSmi8), U8(4), //
+ B(Jump), U8(4), //
+ B(LdaSmi8), U8(5), //
+ 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(Switch) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"var a = 1;\n"
+ "switch(a) {\n"
+ " case 1: return 2;\n"
+ " case 2: return 3;\n"
+ "}\n",
+ 3 * kPointerSize,
+ 1,
+ 30,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), // The tag variable is allocated as a
+ B(Star), R(0), // local by the parser, hence the store
+ B(Star), R(2), // to another local register.
+ B(LdaSmi8), U8(1), //
+ B(TestEqualStrict), R(2), //
+ B(JumpIfTrue), U8(10), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqualStrict), R(2), //
+ 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",
+ 3 * kPointerSize,
+ 1,
+ 36,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqualStrict), R(2), //
+ B(JumpIfTrue), U8(10), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqualStrict), R(2), //
+ 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",
+ 3 * kPointerSize,
+ 1,
+ 34,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqualStrict), R(2), //
+ B(JumpIfTrue), U8(10), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqualStrict), R(2), //
+ 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",
+ 3 * kPointerSize,
+ 1,
+ 34,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqualStrict), R(2), //
+ B(JumpIfTrue), U8(10), //
+ B(LdaSmi8), U8(3), //
+ B(TestEqualStrict), R(2), //
+ 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",
+ 3 * kPointerSize,
+ 1,
+ 43,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(TypeOf), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqualStrict), R(2), //
+ B(JumpIfTrue), U8(10), //
+ B(LdaSmi8), U8(3), //
+ B(TestEqualStrict), R(2), //
+ 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",
+ 3 * kPointerSize,
+ 1,
+ 31,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(Ldar), R(1), //
+ B(TypeOf), //
+ B(TestEqualStrict), R(2), //
+ 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",
+ 3 * kPointerSize,
+ 1,
+ 288,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqualStrict), R(2), //
+ B(JumpIfTrue), U8(10), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqualStrict), R(2), //
+ B(JumpIfTrueConstant), U8(0), //
+ B(JumpConstant), U8(1), //
+ REPEAT_64(COMMA, //
+ 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), //
+ },
+ 2,
+ {262, 266}},
+ {"var a = 1;\n"
+ "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",
+ 5 * kPointerSize,
+ 1,
+ 60,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(2), //
+ B(Star), R(0), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(1), //
+ B(TestEqualStrict), R(3), //
+ B(JumpIfTrue), U8(10), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqualStrict), R(3), //
+ B(JumpIfTrue), U8(36), //
+ B(Jump), U8(38), //
+ B(Ldar), R(2), //
+ B(Star), R(4), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(4), //
+ B(Star), R(1), //
+ B(Star), R(4), //
+ B(LdaSmi8), U8(2), //
+ B(TestEqualStrict), R(4), //
+ B(JumpIfTrue), U8(4), //
+ B(Jump), U8(8), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(2), //
+ B(Jump), U8(8), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(2), //
+ B(Jump), U8(2), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(2), //
+ B(LdaUndefined), //
+ 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(BasicBlockToBoolean) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ // Check that we generate JumpIfToBoolean if they are at the start of basic
+ // blocks.
+ ExpectedSnippet<int> snippets[] = {
+ {"var a = 1; if (a || a < 0) { return 1; }",
+ 2 * kPointerSize,
+ 1,
+ 20,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(JumpIfToBooleanTrue), U8(9), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaZero), //
+ B(TestLessThan), R(1), //
+ B(JumpIfToBooleanFalse), U8(5), //
+ B(LdaSmi8), U8(1), //
+ B(Return), //
+ B(LdaUndefined), //
+ B(Return), //
+ }},
+ {"var a = 1; if (a && a < 0) { return 1; }",
+ 2 * kPointerSize,
+ 1,
+ 20,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(JumpIfToBooleanFalse), U8(9), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaZero), //
+ B(TestLessThan), R(1), //
+ B(JumpIfToBooleanFalse), U8(5), //
+ B(LdaSmi8), U8(1), //
+ B(Return), //
+ B(LdaUndefined), //
+ B(Return), //
+ }},
+ {"var a = 1; a = (a || a < 0) ? 2 : 3;",
+ 2 * kPointerSize,
+ 1,
+ 25,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(JumpIfToBooleanTrue), U8(9), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(LdaZero), //
+ B(TestLessThan), R(1), //
+ B(JumpIfToBooleanFalse), U8(6), //
+ B(LdaSmi8), U8(2), //
+ B(Jump), U8(4), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(0), //
+ B(LdaUndefined), //
+ 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(DeadCodeRemoval) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<int> snippets[] = {
+ {"return; var a = 1; a();",
+ 1 * kPointerSize,
+ 1,
+ 2,
+ {
+ B(LdaUndefined), //
+ B(Return), //
+ }},
+ {"if (false) { return; }; var a = 1;",
+ 1 * kPointerSize,
+ 1,
+ 6,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(LdaUndefined), //
+ B(Return), //
+ }},
+ {"if (true) { return 1; } else { return 2; };",
+ 0,
+ 1,
+ 3,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Return), //
+ }},
+ {"var a = 1; if (a) { return 1; }; return 2;",
+ 1 * kPointerSize,
+ 1,
+ 12,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), 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 =
+ helper.MakeBytecodeForFunctionBody(snippets[i].code_snippet);
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(ThisFunction) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ int closure = Register::function_closure().index();
+
+ ExpectedSnippet<int> snippets[] = {
+ {"var f;\n f = function f() { }",
+ 1 * kPointerSize,
+ 1,
+ 9,
+ {
+ 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,
+ 8,
+ {
+ B(LdaTheHole), //
+ B(Star), R(0), //
+ B(Ldar), R(closure), //
+ B(Star), 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;
+
+ int new_target = Register::new_target().index();
+
+ ExpectedSnippet<int> snippets[] = {
+ {"return new.target;",
+ 1 * kPointerSize,
+ 1,
+ 5,
+ {
+ B(Ldar), R(new_target), //
+ B(Star), R(0), //
+ B(Return), //
+ }},
+ {"new.target;",
+ 1 * kPointerSize,
+ 1,
+ 6,
+ {
+ B(Ldar), R(new_target), //
+ B(Star), R(0), //
+ B(LdaUndefined), //
+ 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 does not
+ "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;",
+ 2 * kPointerSize,
+ 1,
+ 29,
+ {B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Ldar), R(0), // This load should not be removed as it
+ B(Star), R(1), // is the target of the branch.
+ B(Ldar), R(0), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(10), //
+ B(TestGreaterThan), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(4), //
+ B(Jump), U8(-20), //
+ 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;",
+ 2 * kPointerSize,
+ 1,
+ 27,
+ {B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Ldar), R(0), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(10), //
+ B(TestGreaterThan), R(1), //
+ B(JumpIfFalse), U8(4), //
+ B(Jump), U8(2), //
+ B(Ldar), R(0), //
+ B(Return)}},
+ {"var ld_a = 1;\n"
+ " ld_a = ld_a + ld_a;\n"
+ " return ld_a;",
+ 2 * kPointerSize,
+ 1,
+ 13,
+ {
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Add), R(1), //
+ B(Star), 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(AssignmentsInBinaryExpression) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"var x = 0, y = 1;\n"
+ "return (x = 2, y = 3, x = 4, y = 5)",
+ 2 * kPointerSize,
+ 1,
+ 24,
+ {
+ B(LdaZero), B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(4), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(5), //
+ B(Star), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 55;\n"
+ "var y = (x = 100);\n"
+ "return y",
+ 2 * kPointerSize,
+ 1,
+ 11,
+ {
+ B(LdaSmi8), U8(55), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(100), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 55;\n"
+ "x = x + (x = 100) + (x = 101);\n"
+ "return x;",
+ 3 * kPointerSize,
+ 1,
+ 23,
+ {
+ B(LdaSmi8), U8(55), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(100), //
+ B(Star), R(0), //
+ B(Add), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(101), //
+ B(Star), R(0), //
+ B(Add), R(2), //
+ B(Star), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 55;\n"
+ "x = (x = 56) - x + (x = 57);\n"
+ "x++;\n"
+ "return x;",
+ 3 * kPointerSize,
+ 1,
+ 31,
+ {
+ B(LdaSmi8), U8(55), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(56), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Sub), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(57), //
+ B(Star), R(0), //
+ B(Add), R(2), //
+ B(Star), R(0), //
+ B(ToNumber), //
+ B(Star), R(1), //
+ B(Inc), //
+ B(Star), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 55;\n"
+ "var y = x + (x = 1) + (x = 2) + (x = 3);\n"
+ "return y;",
+ 4 * kPointerSize,
+ 1,
+ 31,
+ {
+ B(LdaSmi8), U8(55), //
+ B(Star), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Add), R(2), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(0), //
+ B(Add), R(3), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(0), //
+ B(Add), R(2), //
+ B(Star), R(1), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 55;\n"
+ "var x = x + (x = 1) + (x = 2) + (x = 3);\n"
+ "return x;",
+ 3 * kPointerSize,
+ 1,
+ 31,
+ {
+ B(LdaSmi8), U8(55), //
+ B(Star), R(0), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Add), R(1), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(0), //
+ B(Add), R(2), //
+ B(Star), R(1), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(0), //
+ B(Add), R(1), //
+ B(Star), R(0), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 10, y = 20;\n"
+ "return x + (x = 1) + (x + 1) * (y = 2) + (y = 3) + (x = 4) + (y = 5) + "
+ "y;\n",
+ 5 * kPointerSize,
+ 1,
+ 69,
+ {
+ B(LdaSmi8), U8(10), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(20), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(0), //
+ B(Add), R(2), //
+ B(Star), R(3), //
+ B(Ldar), R(0), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(1), //
+ B(Add), R(2), //
+ B(Star), R(4), //
+ B(LdaSmi8), U8(2), //
+ B(Star), R(1), //
+ B(Mul), R(4), //
+ B(Add), R(3), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(3), //
+ B(Star), R(1), //
+ B(Add), R(2), //
+ B(Star), R(3), //
+ B(LdaSmi8), U8(4), //
+ B(Star), R(0), //
+ B(Add), R(3), //
+ B(Star), R(2), //
+ B(LdaSmi8), U8(5), //
+ B(Star), R(1), //
+ B(Add), R(2), //
+ B(Star), R(3), //
+ B(Ldar), R(1), //
+ B(Add), R(3), //
+ B(Return), //
+ },
+ 0},
+ {"var x = 17;\n"
+ "return 1 + x + (x++) + (++x);\n",
+ 4 * kPointerSize,
+ 1,
+ 37,
+ {
+ B(LdaSmi8), U8(17), //
+ B(Star), R(0), //
+ B(LdaSmi8), U8(1), //
+ B(Star), R(1), //
+ B(Ldar), R(0), //
+ B(Add), R(1), //
+ B(Star), R(2), //
+ B(Ldar), R(0), //
+ B(ToNumber), //
+ B(Star), R(1), //
+ B(Inc), //
+ B(Star), R(0), //
+ B(Ldar), R(1), //
+ B(Add), R(2), //
+ B(Star), R(3), //
+ B(Ldar), R(0), //
+ B(ToNumber), //
+ B(Inc), //
+ B(Star), R(0), //
+ B(Add), R(3), //
+ B(Return), //
+ },
+ 0}};
+
+ 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(Eval) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ int closure = Register::function_closure().index();
+ int context = Register::function_context().index();
+ int new_target = Register::new_target().index();
+
+ int first_context_slot = Context::MIN_CONTEXT_SLOTS;
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"return eval('1;');",
+ 9 * kPointerSize,
+ 1,
+ 67,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
+ U8(1), //
+ B(PushContext), R(0), //
+ B(Ldar), THIS(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateMappedArguments), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 1), //
+ B(Ldar), R(new_target), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 2), //
+ B(Mov), R(context), R(3), //
+ B(LdaConstant), U8(0), //
+ B(Star), R(4), //
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlot), //
+ R(3), U8(2), R(1), //
+ B(LdaConstant), U8(1), //
+ B(Star), R(3), //
+ B(Mov), R(1), R(4), //
+ B(Mov), R(3), R(5), //
+ B(Mov), R(closure), R(6), //
+ B(LdaZero), //
+ B(Star), R(7), //
+ B(LdaSmi8), U8(10), //
+ B(Star), R(8), //
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), //
+ U8(5), //
+ B(Star), R(1), //
+ B(Call), R(1), R(2), U8(1), U8(0), //
+ B(Return), //
+ },
+ 2,
+ {"eval", "1;"}},
+ };
+
+ 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(LookupSlot) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ int closure = Register::function_closure().index();
+ int first_context_slot = Context::MIN_CONTEXT_SLOTS;
+ int context = Register::function_context().index();
+ int new_target = Register::new_target().index();
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"eval('var x = 10;'); return x;",
+ 9 * kPointerSize,
+ 1,
+ 69,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
+ U8(1), //
+ B(PushContext), R(0), //
+ B(Ldar), THIS(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateMappedArguments), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 1), //
+ B(Ldar), R(new_target), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 2), //
+ B(Mov), R(context), R(3), //
+ B(LdaConstant), U8(0), //
+ B(Star), R(4), //
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlot), //
+ R(3), U8(2), R(1), //
+ B(LdaConstant), U8(1), //
+ B(Star), R(3), //
+ B(Mov), R(1), R(4), //
+ B(Mov), R(3), R(5), //
+ B(Mov), R(closure), R(6), //
+ B(LdaZero), //
+ B(Star), R(7), //
+ B(LdaSmi8), U8(10), //
+ B(Star), R(8), //
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), //
+ U8(5), //
+ B(Star), R(1), //
+ B(Call), R(1), R(2), U8(1), U8(0), //
+ B(LdaLookupSlot), U8(2), //
+ B(Return), //
+ },
+ 3,
+ {"eval", "var x = 10;", "x"}},
+ {"eval('var x = 10;'); return typeof x;",
+ 9 * kPointerSize,
+ 1,
+ 70,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
+ U8(1), //
+ B(PushContext), R(0), //
+ B(Ldar), THIS(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateMappedArguments), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 1), //
+ B(Ldar), R(new_target), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 2), //
+ B(Mov), R(context), R(3), //
+ B(LdaConstant), U8(0), //
+ B(Star), R(4), //
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlot), //
+ R(3), U8(2), R(1), //
+ B(LdaConstant), U8(1), //
+ B(Star), R(3), //
+ B(Mov), R(1), R(4), //
+ B(Mov), R(3), R(5), //
+ B(Mov), R(closure), R(6), //
+ B(LdaZero), //
+ B(Star), R(7), //
+ B(LdaSmi8), U8(10), //
+ B(Star), R(8), //
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), //
+ U8(5), //
+ B(Star), R(1), //
+ B(Call), R(1), R(2), U8(1), U8(0), //
+ B(LdaLookupSlotInsideTypeof), U8(2), //
+ B(TypeOf), //
+ B(Return), //
+ },
+ 3,
+ {"eval", "var x = 10;", "x"}},
+ {"x = 20; return eval('');",
+ 9 * kPointerSize,
+ 1,
+ 71,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
+ U8(1), //
+ B(PushContext), R(0), //
+ B(Ldar), THIS(1), //
+ B(StaContextSlot), R(0), U8(first_context_slot), //
+ B(CreateMappedArguments), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 1), //
+ B(Ldar), R(new_target), //
+ B(StaContextSlot), R(0), U8(first_context_slot + 2), //
+ B(LdaSmi8), U8(20), //
+ B(StaLookupSlotSloppy), U8(0), //
+ B(Mov), R(context), R(3), //
+ B(LdaConstant), U8(1), //
+ B(Star), R(4), //
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlot), //
+ R(3), U8(2), R(1), //
+ B(LdaConstant), U8(2), //
+ B(Star), R(3), //
+ B(Mov), R(1), R(4), //
+ B(Mov), R(3), R(5), //
+ B(Mov), R(closure), R(6), //
+ B(LdaZero), //
+ B(Star), R(7), //
+ B(LdaSmi8), U8(10), //
+ B(Star), R(8), //
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), //
+ U8(5), //
+ B(Star), R(1), //
+ B(Call), R(1), R(2), U8(1), U8(0), //
+ B(Return), //
+ },
+ 3,
+ {"x", "eval", ""}},
+ };
+
+ 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(CallLookupSlot) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+ Zone zone;
+
+ FeedbackVectorSpec feedback_spec(&zone);
+ FeedbackVectorSlot slot1 = feedback_spec.AddLoadICSlot();
+ FeedbackVectorSlot slot2 = feedback_spec.AddCallICSlot();
+ USE(slot1);
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(helper.isolate(), &feedback_spec);
+
+ int closure = Register::function_closure().index();
+ int context = Register::function_context().index();
+ int new_target = Register::new_target().index();
+
+ ExpectedSnippet<InstanceType> snippets[] = {
+ {"g = function(){}; eval(''); return g();",
+ 9 * kPointerSize,
+ 1,
+ 90,
+ {
+ B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure), //
+ U8(1), //
+ B(PushContext), R(0), //
+ B(Ldar), THIS(1), //
+ B(StaContextSlot), R(0), U8(4), //
+ B(CreateMappedArguments), //
+ B(StaContextSlot), R(0), U8(5), //
+ B(Ldar), R(new_target), //
+ B(StaContextSlot), R(0), U8(6), //
+ B(CreateClosure), U8(0), U8(0), //
+ B(StaLookupSlotSloppy), U8(1), //
+ B(Mov), R(context), R(3), //
+ B(LdaConstant), U8(2), //
+ B(Star), R(4), //
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlot), //
+ R(3), U8(2), R(1), //
+ B(LdaConstant), U8(3), //
+ B(Star), R(3), //
+ B(Mov), R(1), R(4), //
+ B(Mov), R(3), R(5), //
+ B(Mov), R(closure), R(6), //
+ B(LdaZero), //
+ B(Star), R(7), //
+ B(LdaSmi8), U8(10), //
+ B(Star), R(8), //
+ B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4), //
+ U8(5), //
+ B(Star), R(1), //
+ B(Call), R(1), R(2), U8(1), U8(0), //
+ B(Mov), R(context), R(3), //
+ B(LdaConstant), U8(1), //
+ B(Star), R(4), //
+ B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlot), //
+ R(3), U8(2), R(1), //
+ B(Call), R(1), R(2), U8(0), U8(vector->GetIndex(slot2)), //
+ B(Return), //
+ },
+ 4,
+ {InstanceType::SHARED_FUNCTION_INFO_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE,
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ };
+
+ 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(LookupSlotInEval) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ const char* function_prologue = "var f;"
+ "var x = 1;"
+ "function f1() {"
+ " eval(\"function t() {";
+ const char* function_epilogue = " }; f = t; f();\");"
+ "}"
+ "f1();";
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"return x;",
+ 0 * kPointerSize,
+ 1,
+ 3,
+ {
+ B(LdaLookupSlot), U8(0), //
+ B(Return) //
+ },
+ 1,
+ {"x"}},
+ {"x = 10;",
+ 0 * kPointerSize,
+ 1,
+ 6,
+ {
+ B(LdaSmi8), U8(10), //
+ B(StaLookupSlotSloppy), U8(0), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {"x"}},
+ {"'use strict'; x = 10;",
+ 0 * kPointerSize,
+ 1,
+ 6,
+ {
+ B(LdaSmi8), U8(10), //
+ B(StaLookupSlotStrict), U8(0), //
+ B(LdaUndefined), //
+ B(Return), //
+ },
+ 1,
+ {"x"}},
+ {"return typeof x;",
+ 0 * kPointerSize,
+ 1,
+ 4,
+ {
+ B(LdaLookupSlotInsideTypeof), U8(0), //
+ B(TypeOf), //
+ B(Return), //
+ },
+ 1,
+ {"x"}},
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ std::string script = std::string(function_prologue) +
+ std::string(snippets[i].code_snippet) +
+ std::string(function_epilogue);
+ // TODO(mythria): use * as filter when function declarations are supported
+ // inside eval.
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(script.c_str(), "t", "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(LookupSlotWideInEval) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ const char* function_prologue =
+ "var f;"
+ "var x = 1;"
+ "function f1() {"
+ " eval(\"function t() {";
+ const char* function_epilogue =
+ " }; f = t; f();\");"
+ "}"
+ "f1();";
+
+ int const_count[] = {0, 0, 0, 0};
+ ExpectedSnippet<InstanceType, 257> snippets[] = {
+ {REPEAT_256(SPACE, "var y = 2.3;")
+ "return x;",
+ 1 * kPointerSize,
+ 1,
+ 1028,
+ {
+ REPEAT_256(SPACE, //
+ B(LdaConstant), U8(const_count[0]++), //
+ B(Star), R(0), ) //
+ B(LdaLookupSlotWide), U16(256), //
+ B(Return) //
+ },
+ 257,
+ {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {REPEAT_256(SPACE, "var y = 2.3;")
+ "return typeof x;",
+ 1 * kPointerSize,
+ 1,
+ 1029,
+ {
+ REPEAT_256(SPACE, //
+ B(LdaConstant), U8(const_count[1]++), //
+ B(Star), R(0), ) //
+ B(LdaLookupSlotInsideTypeofWide), U16(256), //
+ B(TypeOf), //
+ B(Return) //
+ },
+ 257,
+ {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {REPEAT_256(SPACE, "var y = 2.3;")
+ "x = 10;",
+ 1 * kPointerSize,
+ 1,
+ 1031,
+ {
+ REPEAT_256(SPACE, //
+ B(LdaConstant), U8(const_count[2]++), //
+ B(Star), R(0), ) //
+ B(LdaSmi8), U8(10), //
+ B(StaLookupSlotSloppyWide), U16(256), //
+ B(LdaUndefined), //
+ B(Return) //
+ },
+ 257,
+ {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ {"'use strict';"
+ REPEAT_256(SPACE, "var y = 2.3;")
+ "x = 10;",
+ 1 * kPointerSize,
+ 1,
+ 1031,
+ {
+ REPEAT_256(SPACE,
+ B(LdaConstant), U8(const_count[3]++), //
+ B(Star), R(0), ) //
+ B(LdaSmi8), U8(10), //
+ B(StaLookupSlotStrictWide), U16(256), //
+ B(LdaUndefined), //
+ B(Return) //
+ },
+ 257,
+ {REPEAT_256(COMMA, InstanceType::HEAP_NUMBER_TYPE),
+ InstanceType::ONE_BYTE_INTERNALIZED_STRING_TYPE}},
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ std::string script = std::string(function_prologue) +
+ std::string(snippets[i].code_snippet) +
+ std::string(function_epilogue);
+ // TODO(mythria): use * as filter when function declarations are supported
+ // inside eval.
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(script.c_str(), "t", "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+
+TEST(DeleteLookupSlotInEval) {
+ InitializedHandleScope handle_scope;
+ BytecodeGeneratorHelper helper;
+
+ const char* function_prologue = "var f;"
+ "var x = 1;"
+ "z = 10;"
+ "function f1() {"
+ " var y;"
+ " eval(\"function t() {";
+ const char* function_epilogue = " }; f = t; f();\");"
+ "}"
+ "f1();";
+
+ ExpectedSnippet<const char*> snippets[] = {
+ {"delete x;",
+ 0 * kPointerSize,
+ 1,
+ 5,
+ {
+ B(LdaConstant), U8(0), //
+ B(DeleteLookupSlot), //
+ B(LdaUndefined), //
+ B(Return) //
+ },
+ 1,
+ {"x"}},
+ {"return delete y;",
+ 0 * kPointerSize,
+ 1,
+ 2,
+ {
+ B(LdaFalse), //
+ B(Return) //
+ },
+ 0},
+ {"return delete z;",
+ 0 * kPointerSize,
+ 1,
+ 4,
+ {
+ B(LdaConstant), U8(0), //
+ B(DeleteLookupSlot), //
+ B(Return) //
+ },
+ 1,
+ {"z"}},
+ };
+
+ for (size_t i = 0; i < arraysize(snippets); i++) {
+ std::string script = std::string(function_prologue) +
+ std::string(snippets[i].code_snippet) +
+ std::string(function_epilogue);
+ Handle<BytecodeArray> bytecode_array =
+ helper.MakeBytecode(script.c_str(), "t", "f");
+ CheckBytecodeArrayEqual(snippets[i], bytecode_array);
+ }
+}
+
+} // namespace interpreter
+} // namespace internal
+} // namespace v8
diff --git a/test/cctest/interpreter/test-interpreter.cc b/test/cctest/interpreter/test-interpreter.cc
new file mode 100644
index 0000000..506cf00
--- /dev/null
+++ b/test/cctest/interpreter/test-interpreter.cc
@@ -0,0 +1,3567 @@
+// 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/execution.h"
+#include "src/handles.h"
+#include "src/interpreter/bytecode-array-builder.h"
+#include "src/interpreter/interpreter.h"
+#include "test/cctest/cctest.h"
+#include "test/cctest/test-feedback-vector.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+
+static MaybeHandle<Object> CallInterpreter(Isolate* isolate,
+ Handle<JSFunction> function) {
+ return Execution::Call(isolate, function,
+ isolate->factory()->undefined_value(), 0, nullptr);
+}
+
+
+template <class... A>
+static MaybeHandle<Object> CallInterpreter(Isolate* isolate,
+ Handle<JSFunction> function,
+ A... args) {
+ Handle<Object> argv[] = { args... };
+ return Execution::Call(isolate, function,
+ isolate->factory()->undefined_value(), sizeof...(args),
+ argv);
+}
+
+
+template <class... A>
+class InterpreterCallable {
+ public:
+ InterpreterCallable(Isolate* isolate, Handle<JSFunction> function)
+ : isolate_(isolate), function_(function) {}
+ virtual ~InterpreterCallable() {}
+
+ MaybeHandle<Object> operator()(A... args) {
+ return CallInterpreter(isolate_, function_, args...);
+ }
+
+ private:
+ Isolate* isolate_;
+ Handle<JSFunction> function_;
+};
+
+
+static const char* kFunctionName = "f";
+
+
+class InterpreterTester {
+ public:
+ InterpreterTester(Isolate* isolate, const char* source,
+ MaybeHandle<BytecodeArray> bytecode,
+ MaybeHandle<TypeFeedbackVector> feedback_vector,
+ const char* filter)
+ : isolate_(isolate),
+ source_(source),
+ bytecode_(bytecode),
+ feedback_vector_(feedback_vector) {
+ i::FLAG_ignition = true;
+ i::FLAG_ignition_fake_try_catch = true;
+ i::FLAG_ignition_fallback_on_eval_and_catch = false;
+ i::FLAG_always_opt = false;
+ // Set ignition filter flag via SetFlagsFromString to avoid double-free
+ // (or potential leak with StrDup() based on ownership confusion).
+ ScopedVector<char> ignition_filter(64);
+ SNPrintF(ignition_filter, "--ignition-filter=%s", filter);
+ FlagList::SetFlagsFromString(ignition_filter.start(),
+ ignition_filter.length());
+ // Ensure handler table is generated.
+ isolate->interpreter()->Initialize();
+ }
+
+ InterpreterTester(Isolate* isolate, Handle<BytecodeArray> bytecode,
+ MaybeHandle<TypeFeedbackVector> feedback_vector =
+ MaybeHandle<TypeFeedbackVector>(),
+ const char* filter = kFunctionName)
+ : InterpreterTester(isolate, nullptr, bytecode, feedback_vector, filter) {
+ }
+
+
+ InterpreterTester(Isolate* isolate, const char* source,
+ const char* filter = kFunctionName)
+ : InterpreterTester(isolate, source, MaybeHandle<BytecodeArray>(),
+ MaybeHandle<TypeFeedbackVector>(), filter) {}
+
+ virtual ~InterpreterTester() {}
+
+ template <class... A>
+ InterpreterCallable<A...> GetCallable() {
+ return InterpreterCallable<A...>(isolate_, GetBytecodeFunction<A...>());
+ }
+
+ static Handle<Object> NewObject(const char* script) {
+ return v8::Utils::OpenHandle(*CompileRun(script));
+ }
+
+ static Handle<String> GetName(Isolate* isolate, const char* name) {
+ Handle<String> result = isolate->factory()->NewStringFromAsciiChecked(name);
+ return isolate->factory()->string_table()->LookupString(isolate, result);
+ }
+
+ static std::string SourceForBody(const char* body) {
+ return "function " + function_name() + "() {\n" + std::string(body) + "\n}";
+ }
+
+ static std::string function_name() {
+ return std::string(kFunctionName);
+ }
+
+ private:
+ Isolate* isolate_;
+ const char* source_;
+ MaybeHandle<BytecodeArray> bytecode_;
+ MaybeHandle<TypeFeedbackVector> feedback_vector_;
+
+ template <class... A>
+ Handle<JSFunction> GetBytecodeFunction() {
+ Handle<JSFunction> function;
+ if (source_) {
+ CompileRun(source_);
+ v8::Local<v8::Context> context =
+ v8::Isolate::GetCurrent()->GetCurrentContext();
+ Local<Function> api_function =
+ Local<Function>::Cast(CcTest::global()
+ ->Get(context, v8_str(kFunctionName))
+ .ToLocalChecked());
+ function = Handle<JSFunction>::cast(v8::Utils::OpenHandle(*api_function));
+ } else {
+ int arg_count = sizeof...(A);
+ std::string source("(function " + function_name() + "(");
+ for (int i = 0; i < arg_count; i++) {
+ source += i == 0 ? "a" : ", a";
+ }
+ source += "){})";
+ function = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+ *v8::Local<v8::Function>::Cast(CompileRun(source.c_str()))));
+ function->ReplaceCode(
+ *isolate_->builtins()->InterpreterEntryTrampoline());
+ }
+
+ if (!bytecode_.is_null()) {
+ function->shared()->set_function_data(*bytecode_.ToHandleChecked());
+ }
+ if (!feedback_vector_.is_null()) {
+ function->shared()->set_feedback_vector(
+ *feedback_vector_.ToHandleChecked());
+ }
+ return function;
+ }
+
+ DISALLOW_COPY_AND_ASSIGN(InterpreterTester);
+};
+
+
+TEST(InterpreterReturn) {
+ HandleAndZoneScope handles;
+ Handle<Object> undefined_value =
+ handles.main_isolate()->factory()->undefined_value();
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK(return_val.is_identical_to(undefined_value));
+}
+
+
+TEST(InterpreterLoadUndefined) {
+ HandleAndZoneScope handles;
+ Handle<Object> undefined_value =
+ handles.main_isolate()->factory()->undefined_value();
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadUndefined().Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK(return_val.is_identical_to(undefined_value));
+}
+
+
+TEST(InterpreterLoadNull) {
+ HandleAndZoneScope handles;
+ Handle<Object> null_value = handles.main_isolate()->factory()->null_value();
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadNull().Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK(return_val.is_identical_to(null_value));
+}
+
+
+TEST(InterpreterLoadTheHole) {
+ HandleAndZoneScope handles;
+ Handle<Object> the_hole_value =
+ handles.main_isolate()->factory()->the_hole_value();
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadTheHole().Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK(return_val.is_identical_to(the_hole_value));
+}
+
+
+TEST(InterpreterLoadTrue) {
+ HandleAndZoneScope handles;
+ Handle<Object> true_value = handles.main_isolate()->factory()->true_value();
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadTrue().Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK(return_val.is_identical_to(true_value));
+}
+
+
+TEST(InterpreterLoadFalse) {
+ HandleAndZoneScope handles;
+ Handle<Object> false_value = handles.main_isolate()->factory()->false_value();
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadFalse().Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK(return_val.is_identical_to(false_value));
+}
+
+
+TEST(InterpreterLoadLiteral) {
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+
+ // Small Smis.
+ for (int i = -128; i < 128; i++) {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadLiteral(Smi::FromInt(i)).Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(i));
+ }
+
+ // Large Smis.
+ {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadLiteral(Smi::FromInt(0x12345678)).Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(0x12345678));
+ }
+
+ // Heap numbers.
+ {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadLiteral(factory->NewHeapNumber(-2.1e19)).Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(i::HeapNumber::cast(*return_val)->value(), -2.1e19);
+ }
+
+ // Strings.
+ {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ Handle<i::String> string = factory->NewStringFromAsciiChecked("String");
+ builder.LoadLiteral(string).Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK(i::String::cast(*return_val)->Equals(*string));
+ }
+}
+
+
+TEST(InterpreterLoadStoreRegisters) {
+ HandleAndZoneScope handles;
+ Handle<Object> true_value = handles.main_isolate()->factory()->true_value();
+ for (int i = 0; i <= kMaxInt8; i++) {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(i + 1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ Register reg(i);
+ builder.LoadTrue()
+ .StoreAccumulatorInRegister(reg)
+ .LoadFalse()
+ .LoadAccumulatorWithRegister(reg)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK(return_val.is_identical_to(true_value));
+ }
+}
+
+
+TEST(InterpreterExchangeRegisters) {
+ for (int locals_count = 2; locals_count < 300; locals_count += 126) {
+ HandleAndZoneScope handles;
+ for (int exchanges = 1; exchanges < 4; exchanges++) {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(locals_count);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+
+ Register r0(0);
+ Register r1(locals_count - 1);
+ builder.LoadTrue();
+ builder.StoreAccumulatorInRegister(r0);
+ builder.ExchangeRegisters(r0, r1);
+ builder.LoadFalse();
+ builder.StoreAccumulatorInRegister(r0);
+
+ bool expected = false;
+ for (int i = 0; i < exchanges; i++) {
+ builder.ExchangeRegisters(r0, r1);
+ expected = !expected;
+ }
+ builder.LoadAccumulatorWithRegister(r0);
+ builder.Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ Handle<Object> expected_val =
+ handles.main_isolate()->factory()->ToBoolean(expected);
+ CHECK(return_val.is_identical_to(expected_val));
+ }
+ }
+}
+
+
+TEST(InterpreterExchangeRegistersWithParameter) {
+ for (int locals_count = 2; locals_count < 300; locals_count += 126) {
+ HandleAndZoneScope handles;
+ for (int exchanges = 1; exchanges < 4; exchanges++) {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(locals_count);
+ builder.set_context_count(0);
+ builder.set_parameter_count(3);
+
+ Register r0 = Register::FromParameterIndex(2, 3);
+ Register r1(locals_count - 1);
+ builder.LoadTrue();
+ builder.StoreAccumulatorInRegister(r0);
+ builder.ExchangeRegisters(r0, r1);
+ builder.LoadFalse();
+ builder.StoreAccumulatorInRegister(r0);
+
+ bool expected = false;
+ for (int i = 0; i < exchanges; i++) {
+ builder.ExchangeRegisters(r0, r1);
+ expected = !expected;
+ }
+ builder.LoadAccumulatorWithRegister(r0);
+ builder.Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ Handle<Object> expected_val =
+ handles.main_isolate()->factory()->ToBoolean(expected);
+ CHECK(return_val.is_identical_to(expected_val));
+ }
+ }
+}
+
+
+TEST(InterpreterExchangeWideRegisters) {
+ for (int locals_count = 3; locals_count < 300; locals_count += 126) {
+ HandleAndZoneScope handles;
+ for (int exchanges = 0; exchanges < 7; exchanges++) {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(locals_count);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+
+ Register r0(0);
+ Register r1(locals_count - 1);
+ Register r2(locals_count - 2);
+ builder.LoadLiteral(Smi::FromInt(200));
+ builder.StoreAccumulatorInRegister(r0);
+ builder.ExchangeRegisters(r0, r1);
+ builder.LoadLiteral(Smi::FromInt(100));
+ builder.StoreAccumulatorInRegister(r0);
+ builder.ExchangeRegisters(r0, r2);
+ builder.LoadLiteral(Smi::FromInt(0));
+ builder.StoreAccumulatorInRegister(r0);
+ for (int i = 0; i < exchanges; i++) {
+ builder.ExchangeRegisters(r1, r2);
+ builder.ExchangeRegisters(r0, r1);
+ }
+ builder.LoadAccumulatorWithRegister(r0);
+ builder.Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ Handle<Object> expected_val =
+ handles.main_isolate()->factory()->NewNumberFromInt(100 *
+ (exchanges % 3));
+ CHECK(return_val.is_identical_to(expected_val));
+ }
+ }
+}
+
+
+static const Token::Value kShiftOperators[] = {
+ Token::Value::SHL, Token::Value::SAR, Token::Value::SHR};
+
+
+static const Token::Value kArithmeticOperators[] = {
+ Token::Value::BIT_OR, Token::Value::BIT_XOR, Token::Value::BIT_AND,
+ Token::Value::SHL, Token::Value::SAR, Token::Value::SHR,
+ Token::Value::ADD, Token::Value::SUB, Token::Value::MUL,
+ Token::Value::DIV, Token::Value::MOD};
+
+
+static double BinaryOpC(Token::Value op, double lhs, double rhs) {
+ switch (op) {
+ case Token::Value::ADD:
+ return lhs + rhs;
+ case Token::Value::SUB:
+ return lhs - rhs;
+ case Token::Value::MUL:
+ return lhs * rhs;
+ case Token::Value::DIV:
+ return lhs / rhs;
+ case Token::Value::MOD:
+ return std::fmod(lhs, rhs);
+ case Token::Value::BIT_OR:
+ return (v8::internal::DoubleToInt32(lhs) |
+ v8::internal::DoubleToInt32(rhs));
+ case Token::Value::BIT_XOR:
+ return (v8::internal::DoubleToInt32(lhs) ^
+ v8::internal::DoubleToInt32(rhs));
+ case Token::Value::BIT_AND:
+ return (v8::internal::DoubleToInt32(lhs) &
+ v8::internal::DoubleToInt32(rhs));
+ case Token::Value::SHL: {
+ int32_t val = v8::internal::DoubleToInt32(lhs);
+ uint32_t count = v8::internal::DoubleToUint32(rhs) & 0x1F;
+ int32_t result = val << count;
+ return result;
+ }
+ case Token::Value::SAR: {
+ int32_t val = v8::internal::DoubleToInt32(lhs);
+ uint32_t count = v8::internal::DoubleToUint32(rhs) & 0x1F;
+ int32_t result = val >> count;
+ return result;
+ }
+ case Token::Value::SHR: {
+ uint32_t val = v8::internal::DoubleToUint32(lhs);
+ uint32_t count = v8::internal::DoubleToUint32(rhs) & 0x1F;
+ uint32_t result = val >> count;
+ return result;
+ }
+ default:
+ UNREACHABLE();
+ return std::numeric_limits<double>::min();
+ }
+}
+
+
+TEST(InterpreterShiftOpsSmi) {
+ int lhs_inputs[] = {0, -17, -182, 1073741823, -1};
+ int rhs_inputs[] = {5, 2, 1, -1, -2, 0, 31, 32, -32, 64, 37};
+ for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
+ for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
+ for (size_t o = 0; o < arraysize(kShiftOperators); o++) {
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+ BytecodeArrayBuilder builder(handles.main_isolate(),
+ handles.main_zone());
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ Register reg(0);
+ int lhs = lhs_inputs[l];
+ int rhs = rhs_inputs[r];
+ builder.LoadLiteral(Smi::FromInt(lhs))
+ .StoreAccumulatorInRegister(reg)
+ .LoadLiteral(Smi::FromInt(rhs))
+ .BinaryOperation(kShiftOperators[o], reg, Strength::WEAK)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ Handle<Object> expected_value =
+ factory->NewNumber(BinaryOpC(kShiftOperators[o], lhs, rhs));
+ CHECK(return_value->SameValue(*expected_value));
+ }
+ }
+ }
+}
+
+
+TEST(InterpreterBinaryOpsSmi) {
+ int lhs_inputs[] = {3266, 1024, 0, -17, -18000};
+ int rhs_inputs[] = {3266, 5, 4, 3, 2, 1, -1, -2};
+ for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
+ for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
+ for (size_t o = 0; o < arraysize(kArithmeticOperators); o++) {
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+ BytecodeArrayBuilder builder(handles.main_isolate(),
+ handles.main_zone());
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ Register reg(0);
+ int lhs = lhs_inputs[l];
+ int rhs = rhs_inputs[r];
+ builder.LoadLiteral(Smi::FromInt(lhs))
+ .StoreAccumulatorInRegister(reg)
+ .LoadLiteral(Smi::FromInt(rhs))
+ .BinaryOperation(kArithmeticOperators[o], reg, Strength::WEAK)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ Handle<Object> expected_value =
+ factory->NewNumber(BinaryOpC(kArithmeticOperators[o], lhs, rhs));
+ CHECK(return_value->SameValue(*expected_value));
+ }
+ }
+ }
+}
+
+
+TEST(InterpreterBinaryOpsHeapNumber) {
+ double lhs_inputs[] = {3266.101, 1024.12, 0.01, -17.99, -18000.833, 9.1e17};
+ double rhs_inputs[] = {3266.101, 5.999, 4.778, 3.331, 2.643,
+ 1.1, -1.8, -2.9, 8.3e-27};
+ for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
+ for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
+ for (size_t o = 0; o < arraysize(kArithmeticOperators); o++) {
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+ BytecodeArrayBuilder builder(handles.main_isolate(),
+ handles.main_zone());
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ Register reg(0);
+ double lhs = lhs_inputs[l];
+ double rhs = rhs_inputs[r];
+ builder.LoadLiteral(factory->NewNumber(lhs))
+ .StoreAccumulatorInRegister(reg)
+ .LoadLiteral(factory->NewNumber(rhs))
+ .BinaryOperation(kArithmeticOperators[o], reg, Strength::WEAK)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ Handle<Object> expected_value =
+ factory->NewNumber(BinaryOpC(kArithmeticOperators[o], lhs, rhs));
+ CHECK(return_value->SameValue(*expected_value));
+ }
+ }
+ }
+}
+
+
+TEST(InterpreterStringAdd) {
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+
+ struct TestCase {
+ Handle<Object> lhs;
+ Handle<Object> rhs;
+ Handle<Object> expected_value;
+ } test_cases[] = {
+ {factory->NewStringFromStaticChars("a"),
+ factory->NewStringFromStaticChars("b"),
+ factory->NewStringFromStaticChars("ab")},
+ {factory->NewStringFromStaticChars("aaaaaa"),
+ factory->NewStringFromStaticChars("b"),
+ factory->NewStringFromStaticChars("aaaaaab")},
+ {factory->NewStringFromStaticChars("aaa"),
+ factory->NewStringFromStaticChars("bbbbb"),
+ factory->NewStringFromStaticChars("aaabbbbb")},
+ {factory->NewStringFromStaticChars(""),
+ factory->NewStringFromStaticChars("b"),
+ factory->NewStringFromStaticChars("b")},
+ {factory->NewStringFromStaticChars("a"),
+ factory->NewStringFromStaticChars(""),
+ factory->NewStringFromStaticChars("a")},
+ {factory->NewStringFromStaticChars("1.11"), factory->NewHeapNumber(2.5),
+ factory->NewStringFromStaticChars("1.112.5")},
+ {factory->NewStringFromStaticChars("-1.11"), factory->NewHeapNumber(2.56),
+ factory->NewStringFromStaticChars("-1.112.56")},
+ {factory->NewStringFromStaticChars(""), factory->NewHeapNumber(2.5),
+ factory->NewStringFromStaticChars("2.5")},
+ };
+
+ for (size_t i = 0; i < arraysize(test_cases); i++) {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ Register reg(0);
+ builder.LoadLiteral(test_cases[i].lhs)
+ .StoreAccumulatorInRegister(reg)
+ .LoadLiteral(test_cases[i].rhs)
+ .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*test_cases[i].expected_value));
+ }
+}
+
+
+TEST(InterpreterParameter1) {
+ HandleAndZoneScope handles;
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadAccumulatorWithRegister(builder.Parameter(0)).Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ // Check for heap objects.
+ Handle<Object> true_value = handles.main_isolate()->factory()->true_value();
+ Handle<Object> return_val = callable(true_value).ToHandleChecked();
+ CHECK(return_val.is_identical_to(true_value));
+
+ // Check for Smis.
+ return_val = callable(Handle<Smi>(Smi::FromInt(3), handles.main_isolate()))
+ .ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(3));
+}
+
+
+TEST(InterpreterParameter8) {
+ HandleAndZoneScope handles;
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(8);
+ builder.LoadAccumulatorWithRegister(builder.Parameter(0))
+ .BinaryOperation(Token::Value::ADD, builder.Parameter(1), Strength::WEAK)
+ .BinaryOperation(Token::Value::ADD, builder.Parameter(2), Strength::WEAK)
+ .BinaryOperation(Token::Value::ADD, builder.Parameter(3), Strength::WEAK)
+ .BinaryOperation(Token::Value::ADD, builder.Parameter(4), Strength::WEAK)
+ .BinaryOperation(Token::Value::ADD, builder.Parameter(5), Strength::WEAK)
+ .BinaryOperation(Token::Value::ADD, builder.Parameter(6), Strength::WEAK)
+ .BinaryOperation(Token::Value::ADD, builder.Parameter(7), Strength::WEAK)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ typedef Handle<Object> H;
+ auto callable = tester.GetCallable<H, H, H, H, H, H, H, H>();
+
+ Handle<Smi> arg1 = Handle<Smi>(Smi::FromInt(1), handles.main_isolate());
+ Handle<Smi> arg2 = Handle<Smi>(Smi::FromInt(2), handles.main_isolate());
+ Handle<Smi> arg3 = Handle<Smi>(Smi::FromInt(3), handles.main_isolate());
+ Handle<Smi> arg4 = Handle<Smi>(Smi::FromInt(4), handles.main_isolate());
+ Handle<Smi> arg5 = Handle<Smi>(Smi::FromInt(5), handles.main_isolate());
+ Handle<Smi> arg6 = Handle<Smi>(Smi::FromInt(6), handles.main_isolate());
+ Handle<Smi> arg7 = Handle<Smi>(Smi::FromInt(7), handles.main_isolate());
+ Handle<Smi> arg8 = Handle<Smi>(Smi::FromInt(8), handles.main_isolate());
+ // Check for Smis.
+ Handle<Object> return_val =
+ callable(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+ .ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(36));
+}
+
+
+TEST(InterpreterParameter1Assign) {
+ HandleAndZoneScope handles;
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadLiteral(Smi::FromInt(5))
+ .StoreAccumulatorInRegister(builder.Parameter(0))
+ .LoadAccumulatorWithRegister(builder.Parameter(0))
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ Handle<Object> return_val =
+ callable(Handle<Smi>(Smi::FromInt(3), handles.main_isolate()))
+ .ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(5));
+}
+
+
+TEST(InterpreterLoadGlobal) {
+ HandleAndZoneScope handles;
+
+ // Test loading a global.
+ std::string source(
+ "var global = 321;\n"
+ "function " + InterpreterTester::function_name() + "() {\n"
+ " return global;\n"
+ "}");
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(321));
+}
+
+
+TEST(InterpreterStoreGlobal) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ // Test storing to a global.
+ std::string source(
+ "var global = 321;\n"
+ "function " + InterpreterTester::function_name() + "() {\n"
+ " global = 999;\n"
+ "}");
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ callable().ToHandleChecked();
+ Handle<i::String> name = factory->InternalizeUtf8String("global");
+ Handle<i::Object> global_obj =
+ Object::GetProperty(isolate->global_object(), name).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*global_obj), Smi::FromInt(999));
+}
+
+
+TEST(InterpreterCallGlobal) {
+ HandleAndZoneScope handles;
+
+ // Test calling a global function.
+ std::string source(
+ "function g_add(a, b) { return a + b; }\n"
+ "function " + InterpreterTester::function_name() + "() {\n"
+ " return g_add(5, 10);\n"
+ "}");
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(15));
+}
+
+
+TEST(InterpreterLoadUnallocated) {
+ HandleAndZoneScope handles;
+
+ // Test loading an unallocated global.
+ std::string source(
+ "unallocated = 123;\n"
+ "function " + InterpreterTester::function_name() + "() {\n"
+ " return unallocated;\n"
+ "}");
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(123));
+}
+
+
+TEST(InterpreterStoreUnallocated) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ // Test storing to an unallocated global.
+ std::string source(
+ "unallocated = 321;\n"
+ "function " + InterpreterTester::function_name() + "() {\n"
+ " unallocated = 999;\n"
+ "}");
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ callable().ToHandleChecked();
+ Handle<i::String> name = factory->InternalizeUtf8String("unallocated");
+ Handle<i::Object> global_obj =
+ Object::GetProperty(isolate->global_object(), name).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*global_obj), Smi::FromInt(999));
+}
+
+
+TEST(InterpreterLoadNamedProperty) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+ i::Zone zone;
+
+ i::FeedbackVectorSpec feedback_spec(&zone);
+ i::FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
+ Handle<i::String> name = factory->NewStringFromAsciiChecked("val");
+ name = factory->string_table()->LookupString(isolate, name);
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadNamedProperty(builder.Parameter(0), name, vector->GetIndex(slot),
+ i::SLOPPY)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ Handle<Object> object = InterpreterTester::NewObject("({ val : 123 })");
+ // Test IC miss.
+ Handle<Object> return_val = callable(object).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(123));
+
+ // Test transition to monomorphic IC.
+ return_val = callable(object).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(123));
+
+ // Test transition to polymorphic IC.
+ Handle<Object> object2 =
+ InterpreterTester::NewObject("({ val : 456, other : 123 })");
+ return_val = callable(object2).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(456));
+
+ // Test transition to megamorphic IC.
+ Handle<Object> object3 =
+ InterpreterTester::NewObject("({ val : 789, val2 : 123 })");
+ callable(object3).ToHandleChecked();
+ Handle<Object> object4 =
+ InterpreterTester::NewObject("({ val : 789, val3 : 123 })");
+ callable(object4).ToHandleChecked();
+ Handle<Object> object5 =
+ InterpreterTester::NewObject("({ val : 789, val4 : 123 })");
+ return_val = callable(object5).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(789));
+}
+
+
+TEST(InterpreterLoadKeyedProperty) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+ i::Zone zone;
+
+ i::FeedbackVectorSpec feedback_spec(&zone);
+ i::FeedbackVectorSlot slot = feedback_spec.AddKeyedLoadICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
+ Handle<i::String> key = factory->NewStringFromAsciiChecked("key");
+ key = factory->string_table()->LookupString(isolate, key);
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadLiteral(key)
+ .LoadKeyedProperty(builder.Parameter(0), vector->GetIndex(slot),
+ i::STRICT)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ Handle<Object> object = InterpreterTester::NewObject("({ key : 123 })");
+ // Test IC miss.
+ Handle<Object> return_val = callable(object).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(123));
+
+ // Test transition to monomorphic IC.
+ return_val = callable(object).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(123));
+
+ // Test transition to megamorphic IC.
+ Handle<Object> object3 =
+ InterpreterTester::NewObject("({ key : 789, val2 : 123 })");
+ return_val = callable(object3).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(789));
+}
+
+
+TEST(InterpreterStoreNamedProperty) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+ i::Zone zone;
+
+ i::FeedbackVectorSpec feedback_spec(&zone);
+ i::FeedbackVectorSlot slot = feedback_spec.AddStoreICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
+ Handle<i::String> name = factory->NewStringFromAsciiChecked("val");
+ name = factory->string_table()->LookupString(isolate, name);
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadLiteral(Smi::FromInt(999))
+ .StoreNamedProperty(builder.Parameter(0), name, vector->GetIndex(slot),
+ i::STRICT)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(isolate, bytecode_array, vector);
+ auto callable = tester.GetCallable<Handle<Object>>();
+ Handle<Object> object = InterpreterTester::NewObject("({ val : 123 })");
+ // Test IC miss.
+ Handle<Object> result;
+ callable(object).ToHandleChecked();
+ CHECK(Runtime::GetObjectProperty(isolate, object, name).ToHandle(&result));
+ CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
+
+ // Test transition to monomorphic IC.
+ callable(object).ToHandleChecked();
+ CHECK(Runtime::GetObjectProperty(isolate, object, name).ToHandle(&result));
+ CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
+
+ // Test transition to polymorphic IC.
+ Handle<Object> object2 =
+ InterpreterTester::NewObject("({ val : 456, other : 123 })");
+ callable(object2).ToHandleChecked();
+ CHECK(Runtime::GetObjectProperty(isolate, object2, name).ToHandle(&result));
+ CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
+
+ // Test transition to megamorphic IC.
+ Handle<Object> object3 =
+ InterpreterTester::NewObject("({ val : 789, val2 : 123 })");
+ callable(object3).ToHandleChecked();
+ Handle<Object> object4 =
+ InterpreterTester::NewObject("({ val : 789, val3 : 123 })");
+ callable(object4).ToHandleChecked();
+ Handle<Object> object5 =
+ InterpreterTester::NewObject("({ val : 789, val4 : 123 })");
+ callable(object5).ToHandleChecked();
+ CHECK(Runtime::GetObjectProperty(isolate, object5, name).ToHandle(&result));
+ CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
+}
+
+
+TEST(InterpreterStoreKeyedProperty) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+ i::Zone zone;
+
+ i::FeedbackVectorSpec feedback_spec(&zone);
+ i::FeedbackVectorSlot slot = feedback_spec.AddKeyedStoreICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
+ Handle<i::String> name = factory->NewStringFromAsciiChecked("val");
+ name = factory->string_table()->LookupString(isolate, name);
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadLiteral(name)
+ .StoreAccumulatorInRegister(Register(0))
+ .LoadLiteral(Smi::FromInt(999))
+ .StoreKeyedProperty(builder.Parameter(0), Register(0),
+ vector->GetIndex(slot), i::SLOPPY)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(isolate, bytecode_array, vector);
+ auto callable = tester.GetCallable<Handle<Object>>();
+ Handle<Object> object = InterpreterTester::NewObject("({ val : 123 })");
+ // Test IC miss.
+ Handle<Object> result;
+ callable(object).ToHandleChecked();
+ CHECK(Runtime::GetObjectProperty(isolate, object, name).ToHandle(&result));
+ CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
+
+ // Test transition to monomorphic IC.
+ callable(object).ToHandleChecked();
+ CHECK(Runtime::GetObjectProperty(isolate, object, name).ToHandle(&result));
+ CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
+
+ // Test transition to megamorphic IC.
+ Handle<Object> object2 =
+ InterpreterTester::NewObject("({ val : 456, other : 123 })");
+ callable(object2).ToHandleChecked();
+ CHECK(Runtime::GetObjectProperty(isolate, object2, name).ToHandle(&result));
+ CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
+}
+
+
+TEST(InterpreterCall) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+ i::Zone zone;
+
+ i::FeedbackVectorSpec feedback_spec(&zone);
+ i::FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
+
+ Handle<i::TypeFeedbackVector> vector =
+ i::NewTypeFeedbackVector(isolate, &feedback_spec);
+ int slot_index = vector->GetIndex(slot);
+
+ Handle<i::String> name = factory->NewStringFromAsciiChecked("func");
+ name = factory->string_table()->LookupString(isolate, name);
+
+ // Check with no args.
+ {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadNamedProperty(builder.Parameter(0), name, slot_index, i::SLOPPY)
+ .StoreAccumulatorInRegister(Register(0))
+ .Call(Register(0), builder.Parameter(0), 0, 0)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ Handle<Object> object = InterpreterTester::NewObject(
+ "new (function Obj() { this.func = function() { return 0x265; }})()");
+ Handle<Object> return_val = callable(object).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(0x265));
+ }
+
+ // Check that receiver is passed properly.
+ {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadNamedProperty(builder.Parameter(0), name, slot_index, i::SLOPPY)
+ .StoreAccumulatorInRegister(Register(0))
+ .Call(Register(0), builder.Parameter(0), 0, 0)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ Handle<Object> object = InterpreterTester::NewObject(
+ "new (function Obj() {"
+ " this.val = 1234;"
+ " this.func = function() { return this.val; };"
+ "})()");
+ Handle<Object> return_val = callable(object).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(1234));
+ }
+
+ // Check with two parameters (+ receiver).
+ {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(4);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadNamedProperty(builder.Parameter(0), name, slot_index, i::SLOPPY)
+ .StoreAccumulatorInRegister(Register(0))
+ .LoadAccumulatorWithRegister(builder.Parameter(0))
+ .StoreAccumulatorInRegister(Register(1))
+ .LoadLiteral(Smi::FromInt(51))
+ .StoreAccumulatorInRegister(Register(2))
+ .LoadLiteral(Smi::FromInt(11))
+ .StoreAccumulatorInRegister(Register(3))
+ .Call(Register(0), Register(1), 2, 0)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ Handle<Object> object = InterpreterTester::NewObject(
+ "new (function Obj() { "
+ " this.func = function(a, b) { return a - b; }"
+ "})()");
+ Handle<Object> return_val = callable(object).ToHandleChecked();
+ CHECK(return_val->SameValue(Smi::FromInt(40)));
+ }
+
+ // Check with 10 parameters (+ receiver).
+ {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(12);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadNamedProperty(builder.Parameter(0), name, slot_index, i::SLOPPY)
+ .StoreAccumulatorInRegister(Register(0))
+ .LoadAccumulatorWithRegister(builder.Parameter(0))
+ .StoreAccumulatorInRegister(Register(1))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("a"))
+ .StoreAccumulatorInRegister(Register(2))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("b"))
+ .StoreAccumulatorInRegister(Register(3))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("c"))
+ .StoreAccumulatorInRegister(Register(4))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("d"))
+ .StoreAccumulatorInRegister(Register(5))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("e"))
+ .StoreAccumulatorInRegister(Register(6))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("f"))
+ .StoreAccumulatorInRegister(Register(7))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("g"))
+ .StoreAccumulatorInRegister(Register(8))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("h"))
+ .StoreAccumulatorInRegister(Register(9))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("i"))
+ .StoreAccumulatorInRegister(Register(10))
+ .LoadLiteral(factory->NewStringFromAsciiChecked("j"))
+ .StoreAccumulatorInRegister(Register(11))
+ .Call(Register(0), Register(1), 10, 0)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ Handle<Object> object = InterpreterTester::NewObject(
+ "new (function Obj() { "
+ " this.prefix = \"prefix_\";"
+ " this.func = function(a, b, c, d, e, f, g, h, i, j) {"
+ " return this.prefix + a + b + c + d + e + f + g + h + i + j;"
+ " }"
+ "})()");
+ Handle<Object> return_val = callable(object).ToHandleChecked();
+ Handle<i::String> expected =
+ factory->NewStringFromAsciiChecked("prefix_abcdefghij");
+ CHECK(i::String::cast(*return_val)->Equals(*expected));
+ }
+}
+
+
+static BytecodeArrayBuilder& SetRegister(BytecodeArrayBuilder& builder,
+ Register reg, int value,
+ Register scratch) {
+ return builder.StoreAccumulatorInRegister(scratch)
+ .LoadLiteral(Smi::FromInt(value))
+ .StoreAccumulatorInRegister(reg)
+ .LoadAccumulatorWithRegister(scratch);
+}
+
+
+static BytecodeArrayBuilder& IncrementRegister(BytecodeArrayBuilder& builder,
+ Register reg, int value,
+ Register scratch) {
+ return builder.StoreAccumulatorInRegister(scratch)
+ .LoadLiteral(Smi::FromInt(value))
+ .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK)
+ .StoreAccumulatorInRegister(reg)
+ .LoadAccumulatorWithRegister(scratch);
+}
+
+
+TEST(InterpreterJumps) {
+ HandleAndZoneScope handles;
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(2);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ Register reg(0), scratch(1);
+ BytecodeLabel label[3];
+
+ builder.LoadLiteral(Smi::FromInt(0))
+ .StoreAccumulatorInRegister(reg)
+ .Jump(&label[1]);
+ SetRegister(builder, reg, 1024, scratch).Bind(&label[0]);
+ IncrementRegister(builder, reg, 1, scratch).Jump(&label[2]);
+ SetRegister(builder, reg, 2048, scratch).Bind(&label[1]);
+ IncrementRegister(builder, reg, 2, scratch).Jump(&label[0]);
+ SetRegister(builder, reg, 4096, scratch).Bind(&label[2]);
+ IncrementRegister(builder, reg, 4, scratch)
+ .LoadAccumulatorWithRegister(reg)
+ .Return();
+
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_value)->value(), 7);
+}
+
+
+TEST(InterpreterConditionalJumps) {
+ HandleAndZoneScope handles;
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(2);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ Register reg(0), scratch(1);
+ BytecodeLabel label[2];
+ BytecodeLabel done, done1;
+
+ builder.LoadLiteral(Smi::FromInt(0))
+ .StoreAccumulatorInRegister(reg)
+ .LoadFalse()
+ .JumpIfFalse(&label[0]);
+ IncrementRegister(builder, reg, 1024, scratch)
+ .Bind(&label[0])
+ .LoadTrue()
+ .JumpIfFalse(&done);
+ IncrementRegister(builder, reg, 1, scratch).LoadTrue().JumpIfTrue(&label[1]);
+ IncrementRegister(builder, reg, 2048, scratch).Bind(&label[1]);
+ IncrementRegister(builder, reg, 2, scratch).LoadFalse().JumpIfTrue(&done1);
+ IncrementRegister(builder, reg, 4, scratch)
+ .LoadAccumulatorWithRegister(reg)
+ .Bind(&done)
+ .Bind(&done1)
+ .Return();
+
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_value)->value(), 7);
+}
+
+
+TEST(InterpreterConditionalJumps2) {
+ // TODO(oth): Add tests for all conditional jumps near and far.
+ HandleAndZoneScope handles;
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(2);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ Register reg(0), scratch(1);
+ BytecodeLabel label[2];
+ BytecodeLabel done, done1;
+
+ builder.LoadLiteral(Smi::FromInt(0))
+ .StoreAccumulatorInRegister(reg)
+ .LoadFalse()
+ .JumpIfFalse(&label[0]);
+ IncrementRegister(builder, reg, 1024, scratch)
+ .Bind(&label[0])
+ .LoadTrue()
+ .JumpIfFalse(&done);
+ IncrementRegister(builder, reg, 1, scratch).LoadTrue().JumpIfTrue(&label[1]);
+ IncrementRegister(builder, reg, 2048, scratch).Bind(&label[1]);
+ IncrementRegister(builder, reg, 2, scratch).LoadFalse().JumpIfTrue(&done1);
+ IncrementRegister(builder, reg, 4, scratch)
+ .LoadAccumulatorWithRegister(reg)
+ .Bind(&done)
+ .Bind(&done1)
+ .Return();
+
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_value)->value(), 7);
+}
+
+
+static const Token::Value kComparisonTypes[] = {
+ Token::Value::EQ, Token::Value::NE, Token::Value::EQ_STRICT,
+ Token::Value::NE_STRICT, Token::Value::LT, Token::Value::LTE,
+ Token::Value::GT, Token::Value::GTE};
+
+
+template <typename T>
+bool CompareC(Token::Value op, T lhs, T rhs, bool types_differed = false) {
+ switch (op) {
+ case Token::Value::EQ:
+ return lhs == rhs;
+ case Token::Value::NE:
+ return lhs != rhs;
+ case Token::Value::EQ_STRICT:
+ return (lhs == rhs) && !types_differed;
+ case Token::Value::NE_STRICT:
+ return (lhs != rhs) || types_differed;
+ case Token::Value::LT:
+ return lhs < rhs;
+ case Token::Value::LTE:
+ return lhs <= rhs;
+ case Token::Value::GT:
+ return lhs > rhs;
+ case Token::Value::GTE:
+ return lhs >= rhs;
+ default:
+ UNREACHABLE();
+ return false;
+ }
+}
+
+
+TEST(InterpreterSmiComparisons) {
+ // NB Constants cover 31-bit space.
+ int inputs[] = {v8::internal::kMinInt / 2,
+ v8::internal::kMinInt / 4,
+ -108733832,
+ -999,
+ -42,
+ -2,
+ -1,
+ 0,
+ +1,
+ +2,
+ 42,
+ 12345678,
+ v8::internal::kMaxInt / 4,
+ v8::internal::kMaxInt / 2};
+
+ for (size_t c = 0; c < arraysize(kComparisonTypes); c++) {
+ Token::Value comparison = kComparisonTypes[c];
+ for (size_t i = 0; i < arraysize(inputs); i++) {
+ for (size_t j = 0; j < arraysize(inputs); j++) {
+ HandleAndZoneScope handles;
+ BytecodeArrayBuilder builder(handles.main_isolate(),
+ handles.main_zone());
+ Register r0(0);
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ builder.LoadLiteral(Smi::FromInt(inputs[i]))
+ .StoreAccumulatorInRegister(r0)
+ .LoadLiteral(Smi::FromInt(inputs[j]))
+ .CompareOperation(comparison, r0, Strength::WEAK)
+ .Return();
+
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->IsBoolean());
+ CHECK_EQ(return_value->BooleanValue(),
+ CompareC(comparison, inputs[i], inputs[j]));
+ }
+ }
+ }
+}
+
+
+TEST(InterpreterHeapNumberComparisons) {
+ double inputs[] = {std::numeric_limits<double>::min(),
+ std::numeric_limits<double>::max(),
+ -0.001,
+ 0.01,
+ 0.1000001,
+ 1e99,
+ -1e-99};
+ for (size_t c = 0; c < arraysize(kComparisonTypes); c++) {
+ Token::Value comparison = kComparisonTypes[c];
+ for (size_t i = 0; i < arraysize(inputs); i++) {
+ for (size_t j = 0; j < arraysize(inputs); j++) {
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+ BytecodeArrayBuilder builder(handles.main_isolate(),
+ handles.main_zone());
+ Register r0(0);
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ builder.LoadLiteral(factory->NewHeapNumber(inputs[i]))
+ .StoreAccumulatorInRegister(r0)
+ .LoadLiteral(factory->NewHeapNumber(inputs[j]))
+ .CompareOperation(comparison, r0, Strength::WEAK)
+ .Return();
+
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->IsBoolean());
+ CHECK_EQ(return_value->BooleanValue(),
+ CompareC(comparison, inputs[i], inputs[j]));
+ }
+ }
+ }
+}
+
+
+TEST(InterpreterStringComparisons) {
+ std::string inputs[] = {"A", "abc", "z", "", "Foo!", "Foo"};
+
+ for (size_t c = 0; c < arraysize(kComparisonTypes); c++) {
+ Token::Value comparison = kComparisonTypes[c];
+ for (size_t i = 0; i < arraysize(inputs); i++) {
+ for (size_t j = 0; j < arraysize(inputs); j++) {
+ const char* lhs = inputs[i].c_str();
+ const char* rhs = inputs[j].c_str();
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+ BytecodeArrayBuilder builder(handles.main_isolate(),
+ handles.main_zone());
+ Register r0(0);
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ builder.LoadLiteral(factory->NewStringFromAsciiChecked(lhs))
+ .StoreAccumulatorInRegister(r0)
+ .LoadLiteral(factory->NewStringFromAsciiChecked(rhs))
+ .CompareOperation(comparison, r0, Strength::WEAK)
+ .Return();
+
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->IsBoolean());
+ CHECK_EQ(return_value->BooleanValue(),
+ CompareC(comparison, inputs[i], inputs[j]));
+ }
+ }
+ }
+}
+
+
+TEST(InterpreterMixedComparisons) {
+ // This test compares a HeapNumber with a String. The latter is
+ // convertible to a HeapNumber so comparison will be between numeric
+ // values except for the strict comparisons where no conversion is
+ // performed.
+ const char* inputs[] = {"-1.77", "-40.333", "0.01", "55.77e5", "2.01"};
+
+ i::UnicodeCache unicode_cache;
+
+ for (size_t c = 0; c < arraysize(kComparisonTypes); c++) {
+ Token::Value comparison = kComparisonTypes[c];
+ for (size_t i = 0; i < arraysize(inputs); i++) {
+ for (size_t j = 0; j < arraysize(inputs); j++) {
+ for (int pass = 0; pass < 2; pass++) {
+ const char* lhs_cstr = inputs[i];
+ const char* rhs_cstr = inputs[j];
+ double lhs = StringToDouble(&unicode_cache, lhs_cstr,
+ i::ConversionFlags::NO_FLAGS);
+ double rhs = StringToDouble(&unicode_cache, rhs_cstr,
+ i::ConversionFlags::NO_FLAGS);
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+ BytecodeArrayBuilder builder(handles.main_isolate(),
+ handles.main_zone());
+ Register r0(0);
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ if (pass == 0) {
+ // Comparison with HeapNumber on the lhs and String on the rhs
+ builder.LoadLiteral(factory->NewNumber(lhs))
+ .StoreAccumulatorInRegister(r0)
+ .LoadLiteral(factory->NewStringFromAsciiChecked(rhs_cstr))
+ .CompareOperation(comparison, r0, Strength::WEAK)
+ .Return();
+ } else {
+ // Comparison with HeapNumber on the rhs and String on the lhs
+ builder.LoadLiteral(factory->NewStringFromAsciiChecked(lhs_cstr))
+ .StoreAccumulatorInRegister(r0)
+ .LoadLiteral(factory->NewNumber(rhs))
+ .CompareOperation(comparison, r0, Strength::WEAK)
+ .Return();
+ }
+
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->IsBoolean());
+ CHECK_EQ(return_value->BooleanValue(),
+ CompareC(comparison, lhs, rhs, true));
+ }
+ }
+ }
+ }
+}
+
+
+TEST(InterpreterInstanceOf) {
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+ Handle<i::String> name = factory->NewStringFromAsciiChecked("cons");
+ Handle<i::JSFunction> func = factory->NewFunction(name);
+ Handle<i::JSObject> instance = factory->NewJSObject(func);
+ Handle<i::Object> other = factory->NewNumber(3.3333);
+ Handle<i::Object> cases[] = {Handle<i::Object>::cast(instance), other};
+ for (size_t i = 0; i < arraysize(cases); i++) {
+ bool expected_value = (i == 0);
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ Register r0(0);
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ builder.LoadLiteral(cases[i]);
+ builder.StoreAccumulatorInRegister(r0)
+ .LoadLiteral(func)
+ .CompareOperation(Token::Value::INSTANCEOF, r0, Strength::WEAK)
+ .Return();
+
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->IsBoolean());
+ CHECK_EQ(return_value->BooleanValue(), expected_value);
+ }
+}
+
+
+TEST(InterpreterTestIn) {
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+ // Allocate an array
+ Handle<i::JSArray> array =
+ factory->NewJSArray(i::ElementsKind::FAST_SMI_ELEMENTS);
+ // Check for these properties on the array object
+ const char* properties[] = {"length", "fuzzle", "x", "0"};
+ for (size_t i = 0; i < arraysize(properties); i++) {
+ bool expected_value = (i == 0);
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ Register r0(0);
+ builder.set_locals_count(1);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ builder.LoadLiteral(factory->NewStringFromAsciiChecked(properties[i]))
+ .StoreAccumulatorInRegister(r0)
+ .LoadLiteral(Handle<Object>::cast(array))
+ .CompareOperation(Token::Value::IN, r0, Strength::WEAK)
+ .Return();
+
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->IsBoolean());
+ CHECK_EQ(return_value->BooleanValue(), expected_value);
+ }
+}
+
+
+TEST(InterpreterUnaryNot) {
+ HandleAndZoneScope handles;
+ for (size_t i = 1; i < 10; i++) {
+ bool expected_value = ((i & 1) == 1);
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ Register r0(0);
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ builder.LoadFalse();
+ for (size_t j = 0; j < i; j++) {
+ builder.LogicalNot();
+ }
+ builder.Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->IsBoolean());
+ CHECK_EQ(return_value->BooleanValue(), expected_value);
+ }
+}
+
+
+static void LoadAny(BytecodeArrayBuilder* builder,
+ v8::internal::Factory* factory, Handle<Object> obj) {
+ if (obj->IsOddball()) {
+ if (obj->SameValue(*factory->true_value())) {
+ builder->LoadTrue();
+ } else if (obj->SameValue(*factory->false_value())) {
+ builder->LoadFalse();
+ } else if (obj->SameValue(*factory->the_hole_value())) {
+ builder->LoadTheHole();
+ } else if (obj->SameValue(*factory->null_value())) {
+ builder->LoadNull();
+ } else if (obj->SameValue(*factory->undefined_value())) {
+ builder->LoadUndefined();
+ } else {
+ UNREACHABLE();
+ }
+ } else if (obj->IsSmi()) {
+ builder->LoadLiteral(*Handle<Smi>::cast(obj));
+ } else {
+ builder->LoadLiteral(obj);
+ }
+}
+
+
+TEST(InterpreterUnaryNotNonBoolean) {
+ HandleAndZoneScope handles;
+ i::Factory* factory = handles.main_isolate()->factory();
+
+ std::pair<Handle<Object>, bool> object_type_tuples[] = {
+ std::make_pair(factory->undefined_value(), true),
+ std::make_pair(factory->null_value(), true),
+ std::make_pair(factory->false_value(), true),
+ std::make_pair(factory->true_value(), false),
+ std::make_pair(factory->NewNumber(9.1), false),
+ std::make_pair(factory->NewNumberFromInt(0), true),
+ std::make_pair(
+ Handle<Object>::cast(factory->NewStringFromStaticChars("hello")),
+ false),
+ std::make_pair(
+ Handle<Object>::cast(factory->NewStringFromStaticChars("")), true),
+ };
+
+ for (size_t i = 0; i < arraysize(object_type_tuples); i++) {
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ Register r0(0);
+ builder.set_locals_count(0);
+ builder.set_context_count(0);
+ builder.set_parameter_count(0);
+ LoadAny(&builder, factory, object_type_tuples[i].first);
+ builder.LogicalNot();
+ builder.Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->IsBoolean());
+ CHECK_EQ(return_value->BooleanValue(), object_type_tuples[i].second);
+ }
+}
+
+
+TEST(InterpreterTypeof) {
+ HandleAndZoneScope handles;
+
+ std::pair<const char*, const char*> typeof_vals[] = {
+ std::make_pair("return typeof undefined;", "undefined"),
+ std::make_pair("return typeof null;", "object"),
+ std::make_pair("return typeof true;", "boolean"),
+ std::make_pair("return typeof false;", "boolean"),
+ std::make_pair("return typeof 9.1;", "number"),
+ std::make_pair("return typeof 7771;", "number"),
+ std::make_pair("return typeof 'hello';", "string"),
+ std::make_pair("return typeof global_unallocated;", "undefined"),
+ };
+
+ for (size_t i = 0; i < arraysize(typeof_vals); i++) {
+ std::string source(InterpreterTester::SourceForBody(typeof_vals[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+
+ auto callable = tester.GetCallable<>();
+ Handle<v8::internal::String> return_value =
+ Handle<v8::internal::String>::cast(callable().ToHandleChecked());
+ auto actual = return_value->ToCString();
+ CHECK_EQ(strcmp(&actual[0], typeof_vals[i].second), 0);
+ }
+}
+
+
+TEST(InterpreterCallRuntime) {
+ HandleAndZoneScope handles;
+
+ BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone());
+ builder.set_locals_count(2);
+ builder.set_context_count(0);
+ builder.set_parameter_count(1);
+ builder.LoadLiteral(Smi::FromInt(15))
+ .StoreAccumulatorInRegister(Register(0))
+ .LoadLiteral(Smi::FromInt(40))
+ .StoreAccumulatorInRegister(Register(1))
+ .CallRuntime(Runtime::kAdd, Register(0), 2)
+ .Return();
+ Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
+
+ InterpreterTester tester(handles.main_isolate(), bytecode_array);
+ auto callable = tester.GetCallable<>();
+
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(55));
+}
+
+
+TEST(InterpreterFunctionLiteral) {
+ HandleAndZoneScope handles;
+
+ // Test calling a function literal.
+ std::string source(
+ "function " + InterpreterTester::function_name() + "(a) {\n"
+ " return (function(x){ return x + 2; })(a);\n"
+ "}");
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ Handle<i::Object> return_val = callable(
+ Handle<Smi>(Smi::FromInt(3), handles.main_isolate())).ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(5));
+}
+
+
+TEST(InterpreterRegExpLiterals) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> literals[] = {
+ std::make_pair("return /abd/.exec('cccabbdd');\n",
+ factory->null_value()),
+ std::make_pair("return /ab+d/.exec('cccabbdd')[0];\n",
+ factory->NewStringFromStaticChars("abbd")),
+ std::make_pair("return /AbC/i.exec('ssaBC')[0];\n",
+ factory->NewStringFromStaticChars("aBC")),
+ std::make_pair("return 'ssaBC'.match(/AbC/i)[0];\n",
+ factory->NewStringFromStaticChars("aBC")),
+ std::make_pair("return 'ssaBCtAbC'.match(/(AbC)/gi)[1];\n",
+ factory->NewStringFromStaticChars("AbC")),
+ };
+
+ for (size_t i = 0; i < arraysize(literals); i++) {
+ std::string source(InterpreterTester::SourceForBody(literals[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*literals[i].second));
+ }
+}
+
+
+TEST(InterpreterArrayLiterals) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> literals[] = {
+ std::make_pair("return [][0];\n",
+ factory->undefined_value()),
+ std::make_pair("return [1, 3, 2][1];\n",
+ handle(Smi::FromInt(3), isolate)),
+ std::make_pair("return ['a', 'b', 'c'][2];\n",
+ factory->NewStringFromStaticChars("c")),
+ std::make_pair("var a = 100; return [a, a + 1, a + 2, a + 3][2];\n",
+ handle(Smi::FromInt(102), isolate)),
+ std::make_pair("return [[1, 2, 3], ['a', 'b', 'c']][1][0];\n",
+ factory->NewStringFromStaticChars("a")),
+ std::make_pair("var t = 't'; return [[t, t + 'est'], [1 + t]][0][1];\n",
+ factory->NewStringFromStaticChars("test"))
+ };
+
+ for (size_t i = 0; i < arraysize(literals); i++) {
+ std::string source(InterpreterTester::SourceForBody(literals[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*literals[i].second));
+ }
+}
+
+
+TEST(InterpreterObjectLiterals) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> literals[] = {
+ std::make_pair("return { }.name;",
+ factory->undefined_value()),
+ std::make_pair("return { name: 'string', val: 9.2 }.name;",
+ factory->NewStringFromStaticChars("string")),
+ std::make_pair("var a = 15; return { name: 'string', val: a }.val;",
+ handle(Smi::FromInt(15), isolate)),
+ std::make_pair("var a = 5; return { val: a, val: a + 1 }.val;",
+ handle(Smi::FromInt(6), isolate)),
+ std::make_pair("return { func: function() { return 'test' } }.func();",
+ factory->NewStringFromStaticChars("test")),
+ std::make_pair("return { func(a) { return a + 'st'; } }.func('te');",
+ factory->NewStringFromStaticChars("test")),
+ std::make_pair("return { get a() { return 22; } }.a;",
+ handle(Smi::FromInt(22), isolate)),
+ std::make_pair("var a = { get b() { return this.x + 't'; },\n"
+ " set b(val) { this.x = val + 's' } };\n"
+ "a.b = 'te';\n"
+ "return a.b;",
+ factory->NewStringFromStaticChars("test")),
+ std::make_pair("var a = 123; return { 1: a }[1];",
+ handle(Smi::FromInt(123), isolate)),
+ std::make_pair("return Object.getPrototypeOf({ __proto__: null });",
+ factory->null_value()),
+ std::make_pair("var a = 'test'; return { [a]: 1 }.test;",
+ handle(Smi::FromInt(1), isolate)),
+ std::make_pair("var a = 'test'; return { b: a, [a]: a + 'ing' }['test']",
+ factory->NewStringFromStaticChars("testing")),
+ std::make_pair("var a = 'proto_str';\n"
+ "var b = { [a]: 1, __proto__: { var : a } };\n"
+ "return Object.getPrototypeOf(b).var",
+ factory->NewStringFromStaticChars("proto_str")),
+ std::make_pair("var n = 'name';\n"
+ "return { [n]: 'val', get a() { return 987 } }['a'];",
+ handle(Smi::FromInt(987), isolate)),
+ };
+
+ for (size_t i = 0; i < arraysize(literals); i++) {
+ std::string source(InterpreterTester::SourceForBody(literals[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*literals[i].second));
+ }
+}
+
+
+TEST(InterpreterConstruct) {
+ HandleAndZoneScope handles;
+
+ std::string source(
+ "function counter() { this.count = 0; }\n"
+ "function " +
+ InterpreterTester::function_name() +
+ "() {\n"
+ " var c = new counter();\n"
+ " return c.count;\n"
+ "}");
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(0));
+}
+
+
+TEST(InterpreterConstructWithArgument) {
+ HandleAndZoneScope handles;
+
+ std::string source(
+ "function counter(arg0) { this.count = 17; this.x = arg0; }\n"
+ "function " +
+ InterpreterTester::function_name() +
+ "() {\n"
+ " var c = new counter(3);\n"
+ " return c.x;\n"
+ "}");
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(3));
+}
+
+
+TEST(InterpreterConstructWithArguments) {
+ HandleAndZoneScope handles;
+
+ std::string source(
+ "function counter(arg0, arg1) {\n"
+ " this.count = 7; this.x = arg0; this.y = arg1;\n"
+ "}\n"
+ "function " +
+ InterpreterTester::function_name() +
+ "() {\n"
+ " var c = new counter(3, 5);\n"
+ " return c.count + c.x + c.y;\n"
+ "}");
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(15));
+}
+
+
+TEST(InterpreterContextVariables) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+
+ std::ostringstream unique_vars;
+ for (int i = 0; i < 250; i++) {
+ unique_vars << "var a" << i << " = 0;";
+ }
+ std::pair<std::string, Handle<Object>> context_vars[] = {
+ std::make_pair("var a; (function() { a = 1; })(); return a;",
+ handle(Smi::FromInt(1), isolate)),
+ std::make_pair("var a = 10; (function() { a; })(); return a;",
+ handle(Smi::FromInt(10), isolate)),
+ std::make_pair("var a = 20; var b = 30;\n"
+ "return (function() { return a + b; })();",
+ handle(Smi::FromInt(50), isolate)),
+ std::make_pair("'use strict'; let a = 1;\n"
+ "{ let b = 2; return (function() { return a + b; })(); }",
+ handle(Smi::FromInt(3), isolate)),
+ std::make_pair("'use strict'; let a = 10;\n"
+ "{ let b = 20; var c = function() { [a, b] };\n"
+ " return a + b; }",
+ handle(Smi::FromInt(30), isolate)),
+ std::make_pair("'use strict';" + unique_vars.str() +
+ "eval(); var b = 100; return b;",
+ handle(Smi::FromInt(100), isolate)),
+ };
+
+ for (size_t i = 0; i < arraysize(context_vars); i++) {
+ std::string source(
+ InterpreterTester::SourceForBody(context_vars[i].first.c_str()));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*context_vars[i].second));
+ }
+}
+
+
+TEST(InterpreterContextParameters) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+
+ std::pair<const char*, Handle<Object>> context_params[] = {
+ std::make_pair("return (function() { return arg1; })();",
+ handle(Smi::FromInt(1), isolate)),
+ std::make_pair("(function() { arg1 = 4; })(); return arg1;",
+ handle(Smi::FromInt(4), isolate)),
+ std::make_pair("(function() { arg3 = arg2 - arg1; })(); return arg3;",
+ handle(Smi::FromInt(1), isolate)),
+ };
+
+ for (size_t i = 0; i < arraysize(context_params); i++) {
+ std::string source = "function " + InterpreterTester::function_name() +
+ "(arg1, arg2, arg3) {" + context_params[i].first + "}";
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable =
+ tester.GetCallable<Handle<Object>, Handle<Object>, Handle<Object>>();
+
+ Handle<Object> a1 = handle(Smi::FromInt(1), isolate);
+ Handle<Object> a2 = handle(Smi::FromInt(2), isolate);
+ Handle<Object> a3 = handle(Smi::FromInt(3), isolate);
+ Handle<i::Object> return_value = callable(a1, a2, a3).ToHandleChecked();
+ CHECK(return_value->SameValue(*context_params[i].second));
+ }
+}
+
+
+TEST(InterpreterOuterContextVariables) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+
+ std::pair<const char*, Handle<Object>> context_vars[] = {
+ std::make_pair("return outerVar * innerArg;",
+ handle(Smi::FromInt(200), isolate)),
+ std::make_pair("outerVar = innerArg; return outerVar",
+ handle(Smi::FromInt(20), isolate)),
+ };
+
+ std::string header(
+ "function Outer() {"
+ " var outerVar = 10;"
+ " function Inner(innerArg) {"
+ " this.innerFunc = function() { ");
+ std::string footer(
+ " }}"
+ " this.getInnerFunc = function() { return new Inner(20).innerFunc; }"
+ "}"
+ "var f = new Outer().getInnerFunc();");
+
+ for (size_t i = 0; i < arraysize(context_vars); i++) {
+ std::string source = header + context_vars[i].first + footer;
+ InterpreterTester tester(handles.main_isolate(), source.c_str(), "*");
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*context_vars[i].second));
+ }
+}
+
+
+TEST(InterpreterComma) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> literals[] = {
+ std::make_pair("var a; return 0, a;\n", factory->undefined_value()),
+ std::make_pair("return 'a', 2.2, 3;\n",
+ handle(Smi::FromInt(3), isolate)),
+ std::make_pair("return 'a', 'b', 'c';\n",
+ factory->NewStringFromStaticChars("c")),
+ std::make_pair("return 3.2, 2.3, 4.5;\n", factory->NewNumber(4.5)),
+ std::make_pair("var a = 10; return b = a, b = b+1;\n",
+ handle(Smi::FromInt(11), isolate)),
+ std::make_pair("var a = 10; return b = a, b = b+1, b + 10;\n",
+ handle(Smi::FromInt(21), isolate))};
+
+ for (size_t i = 0; i < arraysize(literals); i++) {
+ std::string source(InterpreterTester::SourceForBody(literals[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*literals[i].second));
+ }
+}
+
+
+TEST(InterpreterLogicalOr) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> literals[] = {
+ std::make_pair("var a, b; return a || b;\n", factory->undefined_value()),
+ std::make_pair("var a, b = 10; return a || b;\n",
+ handle(Smi::FromInt(10), isolate)),
+ std::make_pair("var a = '0', b = 10; return a || b;\n",
+ factory->NewStringFromStaticChars("0")),
+ std::make_pair("return 0 || 3.2;\n", factory->NewNumber(3.2)),
+ std::make_pair("return 'a' || 0;\n",
+ factory->NewStringFromStaticChars("a")),
+ std::make_pair("var a = '0', b = 10; return (a == 0) || b;\n",
+ factory->true_value())};
+
+ for (size_t i = 0; i < arraysize(literals); i++) {
+ std::string source(InterpreterTester::SourceForBody(literals[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*literals[i].second));
+ }
+}
+
+
+TEST(InterpreterLogicalAnd) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> literals[] = {
+ std::make_pair("var a, b = 10; return a && b;\n",
+ factory->undefined_value()),
+ std::make_pair("var a = 0, b = 10; return a && b / a;\n",
+ handle(Smi::FromInt(0), isolate)),
+ std::make_pair("var a = '0', b = 10; return a && b;\n",
+ handle(Smi::FromInt(10), isolate)),
+ std::make_pair("return 0.0 && 3.2;\n", handle(Smi::FromInt(0), isolate)),
+ std::make_pair("return 'a' && 'b';\n",
+ factory->NewStringFromStaticChars("b")),
+ std::make_pair("return 'a' && 0 || 'b', 'c';\n",
+ factory->NewStringFromStaticChars("c")),
+ std::make_pair("var x = 1, y = 3; return x && 0 + 1 || y;\n",
+ handle(Smi::FromInt(1), isolate)),
+ std::make_pair("var x = 1, y = 3; return (x == 1) && (3 == 3) || y;\n",
+ factory->true_value())};
+
+ for (size_t i = 0; i < arraysize(literals); i++) {
+ std::string source(InterpreterTester::SourceForBody(literals[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*literals[i].second));
+ }
+}
+
+
+TEST(InterpreterTryCatch) {
+ HandleAndZoneScope handles;
+
+ // TODO(rmcilroy): modify tests when we have real try catch support.
+ std::string source(InterpreterTester::SourceForBody(
+ "var a = 1; try { a = a + 1; } catch(e) { a = a + 2; }; return a;"));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(2));
+}
+
+
+TEST(InterpreterTryFinally) {
+ HandleAndZoneScope handles;
+
+ // TODO(rmcilroy): modify tests when we have real try finally support.
+ std::string source(InterpreterTester::SourceForBody(
+ "var a = 1; try { a = a + 1; } finally { a = a + 2; }; return a;"));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(4));
+}
+
+
+TEST(InterpreterThrow) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ // TODO(rmcilroy): modify tests when we have real try catch support.
+ std::pair<const char*, Handle<Object>> throws[] = {
+ std::make_pair("throw undefined;\n",
+ factory->undefined_value()),
+ std::make_pair("throw 1;\n",
+ handle(Smi::FromInt(1), isolate)),
+ std::make_pair("throw 'Error';\n",
+ factory->NewStringFromStaticChars("Error")),
+ std::make_pair("var a = true; if (a) { throw 'Error'; }\n",
+ factory->NewStringFromStaticChars("Error")),
+ std::make_pair("var a = false; if (a) { throw 'Error'; }\n",
+ factory->undefined_value()),
+ std::make_pair("throw 'Error1'; throw 'Error2'\n",
+ factory->NewStringFromStaticChars("Error1")),
+ };
+
+ const char* try_wrapper =
+ "(function() { try { f(); } catch(e) { return e; }})()";
+
+ for (size_t i = 0; i < arraysize(throws); i++) {
+ std::string source(InterpreterTester::SourceForBody(throws[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ tester.GetCallable<>();
+ Handle<Object> thrown_obj = v8::Utils::OpenHandle(*CompileRun(try_wrapper));
+ CHECK(thrown_obj->SameValue(*throws[i].second));
+ }
+}
+
+
+TEST(InterpreterCountOperators) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> count_ops[] = {
+ std::make_pair("var a = 1; return ++a;",
+ handle(Smi::FromInt(2), isolate)),
+ std::make_pair("var a = 1; return a++;",
+ handle(Smi::FromInt(1), isolate)),
+ std::make_pair("var a = 5; return --a;",
+ handle(Smi::FromInt(4), isolate)),
+ std::make_pair("var a = 5; return a--;",
+ handle(Smi::FromInt(5), isolate)),
+ std::make_pair("var a = 5.2; return --a;",
+ factory->NewHeapNumber(4.2)),
+ std::make_pair("var a = 'string'; return ++a;",
+ factory->nan_value()),
+ std::make_pair("var a = 'string'; return a--;",
+ factory->nan_value()),
+ std::make_pair("var a = true; return ++a;",
+ handle(Smi::FromInt(2), isolate)),
+ std::make_pair("var a = false; return a--;",
+ handle(Smi::FromInt(0), isolate)),
+ std::make_pair("var a = { val: 11 }; return ++a.val;",
+ handle(Smi::FromInt(12), isolate)),
+ std::make_pair("var a = { val: 11 }; return a.val--;",
+ handle(Smi::FromInt(11), isolate)),
+ std::make_pair("var a = { val: 11 }; return ++a.val;",
+ handle(Smi::FromInt(12), isolate)),
+ std::make_pair("var name = 'val'; var a = { val: 22 }; return --a[name];",
+ handle(Smi::FromInt(21), isolate)),
+ std::make_pair("var name = 'val'; var a = { val: 22 }; return a[name]++;",
+ handle(Smi::FromInt(22), isolate)),
+ std::make_pair("var a = 1; (function() { a = 2 })(); return ++a;",
+ handle(Smi::FromInt(3), isolate)),
+ std::make_pair("var a = 1; (function() { a = 2 })(); return a--;",
+ handle(Smi::FromInt(2), isolate)),
+ std::make_pair("var i = 5; while(i--) {}; return i;",
+ handle(Smi::FromInt(-1), isolate)),
+ std::make_pair("var i = 1; if(i--) { return 1; } else { return 2; };",
+ handle(Smi::FromInt(1), isolate)),
+ std::make_pair("var i = -2; do {} while(i++) {}; return i;",
+ handle(Smi::FromInt(1), isolate)),
+ std::make_pair("var i = -1; for(; i++; ) {}; return i",
+ handle(Smi::FromInt(1), isolate)),
+ std::make_pair("var i = 20; switch(i++) {\n"
+ " case 20: return 1;\n"
+ " default: return 2;\n"
+ "}",
+ handle(Smi::FromInt(1), isolate)),
+ };
+
+ for (size_t i = 0; i < arraysize(count_ops); i++) {
+ std::string source(InterpreterTester::SourceForBody(count_ops[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*count_ops[i].second));
+ }
+}
+
+
+TEST(InterpreterGlobalCountOperators) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+
+ std::pair<const char*, Handle<Object>> count_ops[] = {
+ std::make_pair("var global = 100;function f(){ return ++global; }",
+ handle(Smi::FromInt(101), isolate)),
+ std::make_pair("var global = 100; function f(){ return --global; }",
+ handle(Smi::FromInt(99), isolate)),
+ std::make_pair("var global = 100; function f(){ return global++; }",
+ handle(Smi::FromInt(100), isolate)),
+ std::make_pair("unallocated = 200; function f(){ return ++unallocated; }",
+ handle(Smi::FromInt(201), isolate)),
+ std::make_pair("unallocated = 200; function f(){ return --unallocated; }",
+ handle(Smi::FromInt(199), isolate)),
+ std::make_pair("unallocated = 200; function f(){ return unallocated++; }",
+ handle(Smi::FromInt(200), isolate)),
+ };
+
+ for (size_t i = 0; i < arraysize(count_ops); i++) {
+ InterpreterTester tester(handles.main_isolate(), count_ops[i].first);
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*count_ops[i].second));
+ }
+}
+
+
+TEST(InterpreterCompoundExpressions) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> compound_expr[] = {
+ std::make_pair("var a = 1; a += 2; return a;",
+ Handle<Object>(Smi::FromInt(3), isolate)),
+ std::make_pair("var a = 10; a /= 2; return a;",
+ Handle<Object>(Smi::FromInt(5), isolate)),
+ std::make_pair("var a = 'test'; a += 'ing'; return a;",
+ factory->NewStringFromStaticChars("testing")),
+ std::make_pair("var a = { val: 2 }; a.val *= 2; return a.val;",
+ Handle<Object>(Smi::FromInt(4), isolate)),
+ std::make_pair("var a = 1; (function f() { a = 2; })(); a += 24;"
+ "return a;",
+ Handle<Object>(Smi::FromInt(26), isolate)),
+ };
+
+ for (size_t i = 0; i < arraysize(compound_expr); i++) {
+ std::string source(
+ InterpreterTester::SourceForBody(compound_expr[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*compound_expr[i].second));
+ }
+}
+
+
+TEST(InterpreterGlobalCompoundExpressions) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+
+ std::pair<const char*, Handle<Object>> compound_expr[2] = {
+ std::make_pair("var global = 100;"
+ "function f() { global += 20; return global; }",
+ Handle<Object>(Smi::FromInt(120), isolate)),
+ std::make_pair("unallocated = 100;"
+ "function f() { unallocated -= 20; return unallocated; }",
+ Handle<Object>(Smi::FromInt(80), isolate)),
+ };
+
+ for (size_t i = 0; i < arraysize(compound_expr); i++) {
+ InterpreterTester tester(handles.main_isolate(), compound_expr[i].first);
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*compound_expr[i].second));
+ }
+}
+
+
+TEST(InterpreterCreateArguments) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, int> create_args[] = {
+ std::make_pair("function f() { return arguments[0]; }", 0),
+ std::make_pair("function f(a) { return arguments[0]; }", 0),
+ std::make_pair("function f() { return arguments[2]; }", 2),
+ std::make_pair("function f(a) { return arguments[2]; }", 2),
+ std::make_pair("function f(a, b, c, d) { return arguments[2]; }", 2),
+ std::make_pair("function f(a) {"
+ "'use strict'; return arguments[0]; }",
+ 0),
+ std::make_pair("function f(a, b, c, d) {"
+ "'use strict'; return arguments[2]; }",
+ 2),
+ // Check arguments are mapped in sloppy mode and unmapped in strict.
+ std::make_pair("function f(a, b, c, d) {"
+ " c = b; return arguments[2]; }",
+ 1),
+ std::make_pair("function f(a, b, c, d) {"
+ " 'use strict'; c = b; return arguments[2]; }",
+ 2),
+ };
+
+ // Test passing no arguments.
+ for (size_t i = 0; i < arraysize(create_args); i++) {
+ InterpreterTester tester(handles.main_isolate(), create_args[i].first);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK(return_val.is_identical_to(factory->undefined_value()));
+ }
+
+ // Test passing one argument.
+ for (size_t i = 0; i < arraysize(create_args); i++) {
+ InterpreterTester tester(handles.main_isolate(), create_args[i].first);
+ auto callable = tester.GetCallable<Handle<Object>>();
+ Handle<Object> return_val =
+ callable(handle(Smi::FromInt(40), isolate)).ToHandleChecked();
+ if (create_args[i].second == 0) {
+ CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(40));
+ } else {
+ CHECK(return_val.is_identical_to(factory->undefined_value()));
+ }
+ }
+
+ // Test passing three argument.
+ for (size_t i = 0; i < arraysize(create_args); i++) {
+ Handle<Object> args[3] = {
+ handle(Smi::FromInt(40), isolate),
+ handle(Smi::FromInt(60), isolate),
+ handle(Smi::FromInt(80), isolate),
+ };
+
+ InterpreterTester tester(handles.main_isolate(), create_args[i].first);
+ auto callable =
+ tester.GetCallable<Handle<Object>, Handle<Object>, Handle<Object>>();
+ Handle<Object> return_val =
+ callable(args[0], args[1], args[2]).ToHandleChecked();
+ CHECK(return_val->SameValue(*args[create_args[i].second]));
+ }
+}
+
+
+TEST(InterpreterConditional) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+
+ std::pair<const char*, Handle<Object>> conditional[] = {
+ std::make_pair("return true ? 2 : 3;",
+ handle(Smi::FromInt(2), isolate)),
+ std::make_pair("return false ? 2 : 3;",
+ handle(Smi::FromInt(3), isolate)),
+ std::make_pair("var a = 1; return a ? 20 : 30;",
+ handle(Smi::FromInt(20), isolate)),
+ std::make_pair("var a = 1; return a ? 20 : 30;",
+ handle(Smi::FromInt(20), isolate)),
+ std::make_pair("var a = 'string'; return a ? 20 : 30;",
+ handle(Smi::FromInt(20), isolate)),
+ std::make_pair("var a = undefined; return a ? 20 : 30;",
+ handle(Smi::FromInt(30), isolate)),
+ std::make_pair("return 1 ? 2 ? 3 : 4 : 5;",
+ handle(Smi::FromInt(3), isolate)),
+ std::make_pair("return 0 ? 2 ? 3 : 4 : 5;",
+ handle(Smi::FromInt(5), isolate)),
+ };
+
+ for (size_t i = 0; i < arraysize(conditional); i++) {
+ std::string source(InterpreterTester::SourceForBody(conditional[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*conditional[i].second));
+ }
+}
+
+
+TEST(InterpreterDelete) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ // Tests for delete for local variables that work both in strict
+ // and sloppy modes
+ std::pair<const char*, Handle<Object>> test_delete[] = {
+ std::make_pair(
+ "var a = { x:10, y:'abc', z:30.2}; delete a.x; return a.x;\n",
+ factory->undefined_value()),
+ std::make_pair(
+ "var b = { x:10, y:'abc', z:30.2}; delete b.x; return b.y;\n",
+ factory->NewStringFromStaticChars("abc")),
+ std::make_pair("var c = { x:10, y:'abc', z:30.2}; var d = c; delete d.x; "
+ "return c.x;\n",
+ factory->undefined_value()),
+ std::make_pair("var e = { x:10, y:'abc', z:30.2}; var g = e; delete g.x; "
+ "return e.y;\n",
+ factory->NewStringFromStaticChars("abc")),
+ std::make_pair("var a = { x:10, y:'abc', z:30.2};\n"
+ "var b = a;"
+ "delete b.x;"
+ "return b.x;\n",
+ factory->undefined_value()),
+ std::make_pair("var a = {1:10};\n"
+ "(function f1() {return a;});"
+ "return delete a[1];",
+ factory->ToBoolean(true)),
+ std::make_pair("return delete this;", factory->ToBoolean(true)),
+ std::make_pair("return delete 'test';", factory->ToBoolean(true))};
+
+ // Test delete in sloppy mode
+ for (size_t i = 0; i < arraysize(test_delete); i++) {
+ std::string source(InterpreterTester::SourceForBody(test_delete[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*test_delete[i].second));
+ }
+
+ // Test delete in strict mode
+ for (size_t i = 0; i < arraysize(test_delete); i++) {
+ std::string strict_test =
+ "'use strict'; " + std::string(test_delete[i].first);
+ std::string source(InterpreterTester::SourceForBody(strict_test.c_str()));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*test_delete[i].second));
+ }
+}
+
+
+TEST(InterpreterDeleteSloppyUnqualifiedIdentifier) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ // These tests generate a syntax error for strict mode. We don't
+ // test for it here.
+ std::pair<const char*, Handle<Object>> test_delete[] = {
+ std::make_pair("var sloppy_a = { x:10, y:'abc'};\n"
+ "var sloppy_b = delete sloppy_a;\n"
+ "if (delete sloppy_a) {\n"
+ " return undefined;\n"
+ "} else {\n"
+ " return sloppy_a.x;\n"
+ "}\n",
+ Handle<Object>(Smi::FromInt(10), isolate)),
+ // TODO(mythria) When try-catch is implemented change the tests to check
+ // if delete actually deletes
+ std::make_pair("sloppy_a = { x:10, y:'abc'};\n"
+ "var sloppy_b = delete sloppy_a;\n"
+ // "try{return a.x;} catch(e) {return b;}\n"
+ "return sloppy_b;",
+ factory->ToBoolean(true)),
+ std::make_pair("sloppy_a = { x:10, y:'abc'};\n"
+ "var sloppy_b = delete sloppy_c;\n"
+ "return sloppy_b;",
+ factory->ToBoolean(true))};
+
+ for (size_t i = 0; i < arraysize(test_delete); i++) {
+ std::string source(InterpreterTester::SourceForBody(test_delete[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*test_delete[i].second));
+ }
+}
+
+
+TEST(InterpreterGlobalDelete) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> test_global_delete[] = {
+ std::make_pair("var a = { x:10, y:'abc', z:30.2 };\n"
+ "function f() {\n"
+ " delete a.x;\n"
+ " return a.x;\n"
+ "}\n"
+ "f();\n",
+ factory->undefined_value()),
+ std::make_pair("var b = {1:10, 2:'abc', 3:30.2 };\n"
+ "function f() {\n"
+ " delete b[2];\n"
+ " return b[1];\n"
+ " }\n"
+ "f();\n",
+ Handle<Object>(Smi::FromInt(10), isolate)),
+ std::make_pair("var c = { x:10, y:'abc', z:30.2 };\n"
+ "function f() {\n"
+ " var d = c;\n"
+ " delete d.y;\n"
+ " return d.x;\n"
+ "}\n"
+ "f();\n",
+ Handle<Object>(Smi::FromInt(10), isolate)),
+ std::make_pair("e = { x:10, y:'abc' };\n"
+ "function f() {\n"
+ " return delete e;\n"
+ "}\n"
+ "f();\n",
+ factory->ToBoolean(true)),
+ std::make_pair("var g = { x:10, y:'abc' };\n"
+ "function f() {\n"
+ " return delete g;\n"
+ "}\n"
+ "f();\n",
+ factory->ToBoolean(false)),
+ std::make_pair("function f() {\n"
+ " var obj = {h:10, f1() {return delete this;}};\n"
+ " return obj.f1();\n"
+ "}\n"
+ "f();",
+ factory->ToBoolean(true)),
+ std::make_pair("function f() {\n"
+ " var obj = {h:10,\n"
+ " f1() {\n"
+ " 'use strict';\n"
+ " return delete this.h;}};\n"
+ " return obj.f1();\n"
+ "}\n"
+ "f();",
+ factory->ToBoolean(true))};
+
+ for (size_t i = 0; i < arraysize(test_global_delete); i++) {
+ InterpreterTester tester(handles.main_isolate(),
+ test_global_delete[i].first);
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*test_global_delete[i].second));
+ }
+}
+
+
+TEST(InterpreterBasicLoops) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> loops[] = {
+ std::make_pair("var a = 10; var b = 1;\n"
+ "while (a) {\n"
+ " b = b * 2;\n"
+ " a = a - 1;\n"
+ "};\n"
+ "return b;\n",
+ factory->NewHeapNumber(1024)),
+ std::make_pair("var a = 1; var b = 1;\n"
+ "do {\n"
+ " b = b * 2;\n"
+ " --a;\n"
+ "} while(a);\n"
+ "return b;\n",
+ handle(Smi::FromInt(2), isolate)),
+ std::make_pair("var b = 1;\n"
+ "for ( var a = 10; a; a--) {\n"
+ " b *= 2;\n"
+ "}\n"
+ "return b;",
+ factory->NewHeapNumber(1024)),
+ std::make_pair("var a = 10; var b = 1;\n"
+ "while (a > 0) {\n"
+ " b = b * 2;\n"
+ " a = a - 1;\n"
+ "};\n"
+ "return b;\n",
+ factory->NewHeapNumber(1024)),
+ std::make_pair("var a = 1; var b = 1;\n"
+ "do {\n"
+ " b = b * 2;\n"
+ " --a;\n"
+ "} while(a);\n"
+ "return b;\n",
+ handle(Smi::FromInt(2), isolate)),
+ std::make_pair("var b = 1;\n"
+ "for ( var a = 10; a > 0; a--) {\n"
+ " b *= 2;\n"
+ "}\n"
+ "return b;",
+ factory->NewHeapNumber(1024)),
+ std::make_pair("var a = 10; var b = 1;\n"
+ "while (false) {\n"
+ " b = b * 2;\n"
+ " a = a - 1;\n"
+ "}\n"
+ "return b;\n",
+ Handle<Object>(Smi::FromInt(1), isolate)),
+ std::make_pair("var a = 10; var b = 1;\n"
+ "while (true) {\n"
+ " b = b * 2;\n"
+ " a = a - 1;\n"
+ " if (a == 0) break;"
+ " continue;"
+ "}\n"
+ "return b;\n",
+ factory->NewHeapNumber(1024)),
+ std::make_pair("var a = 10; var b = 1;\n"
+ "do {\n"
+ " b = b * 2;\n"
+ " a = a - 1;\n"
+ " if (a == 0) break;"
+ "} while(true);\n"
+ "return b;\n",
+ factory->NewHeapNumber(1024)),
+ std::make_pair("var a = 10; var b = 1;\n"
+ "do {\n"
+ " b = b * 2;\n"
+ " a = a - 1;\n"
+ " if (a == 0) break;"
+ "} while(false);\n"
+ "return b;\n",
+ Handle<Object>(Smi::FromInt(2), isolate)),
+ std::make_pair("var a = 10; var b = 1;\n"
+ "for ( a = 1, b = 30; false; ) {\n"
+ " b = b * 2;\n"
+ "}\n"
+ "return b;\n",
+ Handle<Object>(Smi::FromInt(30), isolate))};
+
+ for (size_t i = 0; i < arraysize(loops); i++) {
+ std::string source(InterpreterTester::SourceForBody(loops[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*loops[i].second));
+ }
+}
+
+
+TEST(InterpreterForIn) {
+ HandleAndZoneScope handles;
+
+ std::pair<const char*, int> for_in_samples[] = {
+ {"function f() {\n"
+ " var r = -1;\n"
+ " for (var a in null) { r = a; }\n"
+ " return r;\n"
+ "}",
+ -1},
+ {"function f() {\n"
+ " var r = -1;\n"
+ " for (var a in undefined) { r = a; }\n"
+ " return r;\n"
+ "}",
+ -1},
+ {"function f() {\n"
+ " var r = 0;\n"
+ " for (var a in [0,6,7,9]) { r = r + (1 << a); }\n"
+ " return r;\n"
+ "}",
+ 0xf},
+ {"function f() {\n"
+ " var r = 0;\n"
+ " for (var a in [0,6,7,9]) { r = r + (1 << a); }\n"
+ " var r = 0;\n"
+ " for (var a in [0,6,7,9]) { r = r + (1 << a); }\n"
+ " return r;\n"
+ "}",
+ 0xf},
+ {"function f() {\n"
+ " var r = 0;\n"
+ " for (var a in 'foobar') { r = r + (1 << a); }\n"
+ " return r;\n"
+ "}",
+ 0x3f},
+ {"function f() {\n"
+ " var r = 0;\n"
+ " for (var a in {1:0, 10:1, 100:2, 1000:3}) {\n"
+ " r = r + Number(a);\n"
+ " }\n"
+ " return r;\n"
+ "}",
+ 1111},
+ {"function f() {\n"
+ " var r = 0;\n"
+ " var data = {1:0, 10:1, 100:2, 1000:3};\n"
+ " for (var a in data) {\n"
+ " if (a == 1) delete data[1];\n"
+ " r = r + Number(a);\n"
+ " }\n"
+ " return r;\n"
+ "}",
+ 1111},
+ {"function f() {\n"
+ " var r = 0;\n"
+ " var data = {1:0, 10:1, 100:2, 1000:3};\n"
+ " for (var a in data) {\n"
+ " if (a == 10) delete data[100];\n"
+ " r = r + Number(a);\n"
+ " }\n"
+ " return r;\n"
+ "}",
+ 1011},
+ {"function f() {\n"
+ " var r = 0;\n"
+ " var data = {1:0, 10:1, 100:2, 1000:3};\n"
+ " for (var a in data) {\n"
+ " if (a == 10) data[10000] = 4;\n"
+ " r = r + Number(a);\n"
+ " }\n"
+ " return r;\n"
+ "}",
+ 1111},
+ {"function f() {\n"
+ " var r = 0;\n"
+ " var input = 'foobar';\n"
+ " for (var a in input) {\n"
+ " if (input[a] == 'b') break;\n"
+ " r = r + (1 << a);\n"
+ " }\n"
+ " return r;\n"
+ "}",
+ 0x7},
+ {"function f() {\n"
+ "var r = 0;\n"
+ "var input = 'foobar';\n"
+ "for (var a in input) {\n"
+ " if (input[a] == 'b') continue;\n"
+ " r = r + (1 << a);\n"
+ "}\n"
+ "return r;\n"
+ "}",
+ 0x37},
+ {"function f() {\n"
+ " var r = 0;\n"
+ " var data = {1:0, 10:1, 100:2, 1000:3};\n"
+ " for (var a in data) {\n"
+ " if (a == 10) {\n"
+ " data[10000] = 4;\n"
+ " }\n"
+ " r = r + Number(a);\n"
+ " }\n"
+ " return r;\n"
+ "}",
+ 1111},
+ {"function f() {\n"
+ " var r = [ 3 ];\n"
+ " var data = {1:0, 10:1, 100:2, 1000:3};\n"
+ " for (r[10] in data) {\n"
+ " }\n"
+ " return Number(r[10]);\n"
+ "}",
+ 1000},
+ {"function f() {\n"
+ " var r = [ 3 ];\n"
+ " var data = {1:0, 10:1, 100:2, 1000:3};\n"
+ " for (r['100'] in data) {\n"
+ " }\n"
+ " return Number(r['100']);\n"
+ "}",
+ 1000},
+ {"function f() {\n"
+ " var obj = {}\n"
+ " var descObj = new Boolean(false);\n"
+ " var accessed = 0;\n"
+ " descObj.enumerable = true;\n"
+ " Object.defineProperties(obj, { prop:descObj });\n"
+ " for (var p in obj) {\n"
+ " if (p === 'prop') { accessed = 1; }\n"
+ " }\n"
+ " return accessed;"
+ "}",
+ 1},
+ {"function f() {\n"
+ " var appointment = {};\n"
+ " Object.defineProperty(appointment, 'startTime', {\n"
+ " value: 1001,\n"
+ " writable: false,\n"
+ " enumerable: false,\n"
+ " configurable: true\n"
+ " });\n"
+ " Object.defineProperty(appointment, 'name', {\n"
+ " value: 'NAME',\n"
+ " writable: false,\n"
+ " enumerable: false,\n"
+ " configurable: true\n"
+ " });\n"
+ " var meeting = Object.create(appointment);\n"
+ " Object.defineProperty(meeting, 'conferenceCall', {\n"
+ " value: 'In-person meeting',\n"
+ " writable: false,\n"
+ " enumerable: false,\n"
+ " configurable: true\n"
+ " });\n"
+ "\n"
+ " var teamMeeting = Object.create(meeting);\n"
+ "\n"
+ " var flags = 0;\n"
+ " for (var p in teamMeeting) {\n"
+ " if (p === 'startTime') {\n"
+ " flags |= 1;\n"
+ " }\n"
+ " if (p === 'name') {\n"
+ " flags |= 2;\n"
+ " }\n"
+ " if (p === 'conferenceCall') {\n"
+ " flags |= 4;\n"
+ " }\n"
+ " }\n"
+ "\n"
+ " var hasOwnProperty = !teamMeeting.hasOwnProperty('name') &&\n"
+ " !teamMeeting.hasOwnProperty('startTime') &&\n"
+ " !teamMeeting.hasOwnProperty('conferenceCall');\n"
+ " if (!hasOwnProperty) {\n"
+ " flags |= 8;\n"
+ " }\n"
+ " return flags;\n"
+ " }",
+ 0},
+ {"function f() {\n"
+ " var data = {x:23, y:34};\n"
+ " var result = 0;\n"
+ " var o = {};\n"
+ " var arr = [o];\n"
+ " for (arr[0].p in data)\n" // This is to test if value is loaded
+ " result += data[arr[0].p];\n" // back from accumulator before storing
+ " return result;\n" // named properties.
+ "}",
+ 57},
+ {"function f() {\n"
+ " var data = {x:23, y:34};\n"
+ " var result = 0;\n"
+ " var o = {};\n"
+ " var i = 0;\n"
+ " for (o[i++] in data)\n" // This is to test if value is loaded
+ " result += data[o[i-1]];\n" // back from accumulator before
+ " return result;\n" // storing keyed properties.
+ "}",
+ 57}};
+
+ for (size_t i = 0; i < arraysize(for_in_samples); i++) {
+ InterpreterTester tester(handles.main_isolate(), for_in_samples[i].first);
+ auto callable = tester.GetCallable<>();
+ Handle<Object> return_val = callable().ToHandleChecked();
+ CHECK_EQ(Handle<Smi>::cast(return_val)->value(), for_in_samples[i].second);
+ }
+}
+
+
+TEST(InterpreterSwitch) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> switch_ops[] = {
+ std::make_pair("var a = 1;\n"
+ "switch(a) {\n"
+ " case 1: return 2;\n"
+ " case 2: return 3;\n"
+ "}\n",
+ handle(Smi::FromInt(2), isolate)),
+ std::make_pair("var a = 1;\n"
+ "switch(a) {\n"
+ " case 2: a = 2; break;\n"
+ " case 1: a = 3; break;\n"
+ "}\n"
+ "return a;",
+ handle(Smi::FromInt(3), isolate)),
+ std::make_pair("var a = 1;\n"
+ "switch(a) {\n"
+ " case 1: a = 2; // fall-through\n"
+ " case 2: a = 3; break;\n"
+ "}\n"
+ "return a;",
+ handle(Smi::FromInt(3), isolate)),
+ std::make_pair("var a = 100;\n"
+ "switch(a) {\n"
+ " case 1: return 100;\n"
+ " case 2: return 200;\n"
+ "}\n"
+ "return undefined;",
+ factory->undefined_value()),
+ std::make_pair("var a = 100;\n"
+ "switch(a) {\n"
+ " case 1: return 100;\n"
+ " case 2: return 200;\n"
+ " default: return 300;\n"
+ "}\n"
+ "return undefined;",
+ handle(Smi::FromInt(300), isolate)),
+ std::make_pair("var a = 100;\n"
+ "switch(typeof(a)) {\n"
+ " case 'string': return 1;\n"
+ " case 'number': return 2;\n"
+ " default: return 3;\n"
+ "}\n",
+ handle(Smi::FromInt(2), isolate)),
+ std::make_pair("var a = 100;\n"
+ "switch(a) {\n"
+ " case a += 20: return 1;\n"
+ " case a -= 10: return 2;\n"
+ " case a -= 10: return 3;\n"
+ " default: return 3;\n"
+ "}\n",
+ handle(Smi::FromInt(3), isolate)),
+ std::make_pair("var a = 1;\n"
+ "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"
+ "return a;",
+ handle(Smi::FromInt(5), isolate)),
+ };
+
+ for (size_t i = 0; i < arraysize(switch_ops); i++) {
+ std::string source(InterpreterTester::SourceForBody(switch_ops[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*switch_ops[i].second));
+ }
+}
+
+
+TEST(InterpreterSloppyThis) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> sloppy_this[] = {
+ std::make_pair("var global_val = 100;\n"
+ "function f() { return this.global_val; }\n",
+ handle(Smi::FromInt(100), isolate)),
+ std::make_pair("var global_val = 110;\n"
+ "function g() { return this.global_val; };"
+ "function f() { return g(); }\n",
+ handle(Smi::FromInt(110), isolate)),
+ std::make_pair("var global_val = 110;\n"
+ "function g() { return this.global_val };"
+ "function f() { 'use strict'; return g(); }\n",
+ handle(Smi::FromInt(110), isolate)),
+ std::make_pair("function f() { 'use strict'; return this; }\n",
+ factory->undefined_value()),
+ std::make_pair("function g() { 'use strict'; return this; };"
+ "function f() { return g(); }\n",
+ factory->undefined_value()),
+ };
+
+ for (size_t i = 0; i < arraysize(sloppy_this); i++) {
+ InterpreterTester tester(handles.main_isolate(), sloppy_this[i].first);
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*sloppy_this[i].second));
+ }
+}
+
+
+TEST(InterpreterThisFunction) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ InterpreterTester tester(handles.main_isolate(),
+ "var f;\n f = function f() { return f.name; }");
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*factory->NewStringFromStaticChars("f")));
+}
+
+
+TEST(InterpreterNewTarget) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ // TODO(rmcilroy): Add tests that we get the original constructor for
+ // superclass constructors once we have class support.
+ InterpreterTester tester(handles.main_isolate(),
+ "function f() { this.a = new.target; }");
+ auto callable = tester.GetCallable<>();
+ callable().ToHandleChecked();
+
+ Handle<Object> new_target_name = v8::Utils::OpenHandle(
+ *CompileRun("(function() { return (new f()).a.name; })();"));
+ CHECK(new_target_name->SameValue(*factory->NewStringFromStaticChars("f")));
+}
+
+
+TEST(InterpreterAssignmentInExpressions) {
+ HandleAndZoneScope handles;
+
+ std::pair<const char*, int> samples[] = {
+ {"function f() {\n"
+ " var x = 7;\n"
+ " var y = x + (x = 1) + (x = 2);\n"
+ " return y;\n"
+ "}",
+ 10},
+ {"function f() {\n"
+ " var x = 7;\n"
+ " var y = x + (x = 1) + (x = 2);\n"
+ " return x;\n"
+ "}",
+ 2},
+ {"function f() {\n"
+ " var x = 55;\n"
+ " x = x + (x = 100) + (x = 101);\n"
+ " return x;\n"
+ "}",
+ 256},
+ {"function f() {\n"
+ " var x = 7;\n"
+ " return ++x + x + x++;\n"
+ "}",
+ 24},
+ {"function f() {\n"
+ " var x = 7;\n"
+ " var y = 1 + ++x + x + x++;\n"
+ " return x;\n"
+ "}",
+ 9},
+ {"function f() {\n"
+ " var x = 7;\n"
+ " var y = ++x + x + x++;\n"
+ " return x;\n"
+ "}",
+ 9},
+ {"function f() {\n"
+ " var x = 7, y = 100, z = 1000;\n"
+ " return x + (x += 3) + y + (y *= 10) + (z *= 7) + z;\n"
+ "}",
+ 15117},
+ {"function f() {\n"
+ " var inner = function (x) { return x + (x = 2) + (x = 4) + x; };\n"
+ " return inner(1);\n"
+ "}",
+ 11},
+ {"function f() {\n"
+ " var x = 1, y = 2;\n"
+ " x = x + (x = 3) + y + (y = 4), y = y + (y = 5) + y + x;\n"
+ " return x + y;\n"
+ "}",
+ 10 + 24},
+ {"function f() {\n"
+ " var x = 0;\n"
+ " var y = x | (x = 1) | (x = 2);\n"
+ " return x;\n"
+ "}",
+ 2},
+ {"function f() {\n"
+ " var x = 0;\n"
+ " var y = x || (x = 1);\n"
+ " return x;\n"
+ "}",
+ 1},
+ {"function f() {\n"
+ " var x = 1;\n"
+ " var y = x && (x = 2) && (x = 3);\n"
+ " return x;\n"
+ "}",
+ 3},
+ {"function f() {\n"
+ " var x = 1;\n"
+ " var y = x || (x = 2);\n"
+ " return x;\n"
+ "}",
+ 1},
+ {"function f() {\n"
+ " var x = 1;\n"
+ " x = (x << (x = 3)) | (x = 16);\n"
+ " return x;\n"
+ "}",
+ 24},
+ {"function f() {\n"
+ " var r = 7;\n"
+ " var s = 11;\n"
+ " var t = 13;\n"
+ " var u = r + s + t + (r = 10) + (s = 20) +"
+ " (t = (r + s)) + r + s + t;\n"
+ " return r + s + t + u;\n"
+ "}",
+ 211},
+ {"function f() {\n"
+ " var r = 7;\n"
+ " var s = 11;\n"
+ " var t = 13;\n"
+ " return r > (3 * s * (s = 1)) ? (t + (t += 1)) : (r + (r = 4));\n"
+ "}",
+ 11},
+ {"function f() {\n"
+ " var r = 7;\n"
+ " var s = 11;\n"
+ " var t = 13;\n"
+ " return r > (3 * s * (s = 0)) ? (t + (t += 1)) : (r + (r = 4));\n"
+ "}",
+ 27},
+ {"function f() {\n"
+ " var r = 7;\n"
+ " var s = 11;\n"
+ " var t = 13;\n"
+ " return (r + (r = 5)) > s ? r : t;\n"
+ "}",
+ 5},
+ {"function f(a) {\n"
+ " return a + (arguments[0] = 10);\n"
+ "}",
+ 50},
+ {"function f(a) {\n"
+ " return a + (arguments[0] = 10) + a;\n"
+ "}",
+ 60},
+ {"function f(a) {\n"
+ " return a + (arguments[0] = 10) + arguments[0];\n"
+ "}",
+ 60},
+ };
+
+ const int arg_value = 40;
+ for (size_t i = 0; i < arraysize(samples); i++) {
+ InterpreterTester tester(handles.main_isolate(), samples[i].first);
+ auto callable = tester.GetCallable<Handle<Object>>();
+ Handle<Object> return_val =
+ callable(handle(Smi::FromInt(arg_value), handles.main_isolate()))
+ .ToHandleChecked();
+ CHECK_EQ(Handle<Smi>::cast(return_val)->value(), samples[i].second);
+ }
+}
+
+
+TEST(InterpreterToName) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> to_name_tests[] = {
+ {"var a = 'val'; var obj = {[a] : 10}; return obj.val;",
+ factory->NewNumberFromInt(10)},
+ {"var a = 20; var obj = {[a] : 10}; return obj['20'];",
+ factory->NewNumberFromInt(10)},
+ {"var a = 20; var obj = {[a] : 10}; return obj[20];",
+ factory->NewNumberFromInt(10)},
+ {"var a = {val:23}; var obj = {[a] : 10}; return obj[a];",
+ factory->NewNumberFromInt(10)},
+ {"var a = {val:23}; var obj = {[a] : 10};\n"
+ "return obj['[object Object]'];",
+ factory->NewNumberFromInt(10)},
+ {"var a = {toString : function() { return 'x'}};\n"
+ "var obj = {[a] : 10};\n"
+ "return obj.x;",
+ factory->NewNumberFromInt(10)},
+ {"var a = {valueOf : function() { return 'x'}};\n"
+ "var obj = {[a] : 10};\n"
+ "return obj.x;",
+ factory->undefined_value()},
+ {"var a = {[Symbol.toPrimitive] : function() { return 'x'}};\n"
+ "var obj = {[a] : 10};\n"
+ "return obj.x;",
+ factory->NewNumberFromInt(10)},
+ };
+
+ for (size_t i = 0; i < arraysize(to_name_tests); i++) {
+ std::string source(
+ InterpreterTester::SourceForBody(to_name_tests[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*to_name_tests[i].second));
+ }
+}
+
+
+TEST(TemporaryRegisterAllocation) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> reg_tests[] = {
+ {"function add(a, b, c) {"
+ " return a + b + c;"
+ "}"
+ "function f() {"
+ " var a = 10, b = 10;"
+ " return add(a, b++, b);"
+ "}",
+ factory->NewNumberFromInt(31)},
+ {"function add(a, b, c, d) {"
+ " return a + b + c + d;"
+ "}"
+ "function f() {"
+ " var x = 10, y = 20, z = 30;"
+ " return x + add(x, (y= x++), x, z);"
+ "}",
+ factory->NewNumberFromInt(71)},
+ };
+
+ for (size_t i = 0; i < arraysize(reg_tests); i++) {
+ InterpreterTester tester(handles.main_isolate(), reg_tests[i].first);
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*reg_tests[i].second));
+ }
+}
+
+
+TEST(InterpreterLookupSlot) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ // TODO(mythria): Add more tests when we have support for eval/with.
+ const char* function_prologue = "var f;"
+ "var x = 1;"
+ "function f1() {"
+ " eval(\"function t() {";
+ const char* function_epilogue = " }; f = t;\");"
+ "}"
+ "f1();";
+
+
+ std::pair<const char*, Handle<Object>> lookup_slot[] = {
+ {"return x;", handle(Smi::FromInt(1), isolate)},
+ {"return typeof x;", factory->NewStringFromStaticChars("number")},
+ {"return typeof dummy;", factory->NewStringFromStaticChars("undefined")},
+ {"x = 10; return x;", handle(Smi::FromInt(10), isolate)},
+ {"'use strict'; x = 20; return x;", handle(Smi::FromInt(20), isolate)},
+ };
+
+ for (size_t i = 0; i < arraysize(lookup_slot); i++) {
+ std::string script = std::string(function_prologue) +
+ std::string(lookup_slot[i].first) +
+ std::string(function_epilogue);
+
+ InterpreterTester tester(handles.main_isolate(), script.c_str(), "t");
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*lookup_slot[i].second));
+ }
+}
+
+
+TEST(InterpreterCallLookupSlot) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+
+ std::pair<const char*, Handle<Object>> call_lookup[] = {
+ {"g = function(){ return 2 }; eval(''); return g();",
+ handle(Smi::FromInt(2), isolate)},
+ {"g = function(){ return 2 }; eval('g = function() {return 3}');\n"
+ "return g();",
+ handle(Smi::FromInt(3), isolate)},
+ {"g = { x: function(){ return this.y }, y: 20 };\n"
+ "eval('g = { x: g.x, y: 30 }');\n"
+ "return g.x();",
+ handle(Smi::FromInt(30), isolate)},
+ };
+
+ for (size_t i = 0; i < arraysize(call_lookup); i++) {
+ std::string source(InterpreterTester::SourceForBody(call_lookup[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*call_lookup[i].second));
+ }
+}
+
+
+TEST(InterpreterLookupSlotWide) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ const char* function_prologue =
+ "var f;"
+ "var x = 1;"
+ "function f1() {"
+ " eval(\"function t() {";
+ const char* function_epilogue =
+ " }; f = t;\");"
+ "}"
+ "f1();";
+ std::ostringstream str;
+ str << "var y = 2.3;";
+ for (int i = 1; i < 256; i++) {
+ str << "y = " << 2.3 + i << ";";
+ }
+ std::string init_function_body = str.str();
+
+ std::pair<std::string, Handle<Object>> lookup_slot[] = {
+ {init_function_body + "return x;", handle(Smi::FromInt(1), isolate)},
+ {init_function_body + "return typeof x;",
+ factory->NewStringFromStaticChars("number")},
+ {init_function_body + "return x = 10;",
+ handle(Smi::FromInt(10), isolate)},
+ {"'use strict';" + init_function_body + "x = 20; return x;",
+ handle(Smi::FromInt(20), isolate)},
+ };
+
+ for (size_t i = 0; i < arraysize(lookup_slot); i++) {
+ std::string script = std::string(function_prologue) + lookup_slot[i].first +
+ std::string(function_epilogue);
+
+ InterpreterTester tester(handles.main_isolate(), script.c_str(), "t");
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*lookup_slot[i].second));
+ }
+}
+
+
+TEST(InterpreterDeleteLookupSlot) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ // TODO(mythria): Add more tests when we have support for eval/with.
+ const char* function_prologue = "var f;"
+ "var x = 1;"
+ "y = 10;"
+ "var obj = {val:10};"
+ "var z = 30;"
+ "function f1() {"
+ " var z = 20;"
+ " eval(\"function t() {";
+ const char* function_epilogue = " }; f = t;\");"
+ "}"
+ "f1();";
+
+
+ std::pair<const char*, Handle<Object>> delete_lookup_slot[] = {
+ {"return delete x;", factory->false_value()},
+ {"return delete y;", factory->true_value()},
+ {"return delete z;", factory->false_value()},
+ {"return delete obj.val;", factory->true_value()},
+ {"'use strict'; return delete obj.val;", factory->true_value()},
+ };
+
+ for (size_t i = 0; i < arraysize(delete_lookup_slot); i++) {
+ std::string script = std::string(function_prologue) +
+ std::string(delete_lookup_slot[i].first) +
+ std::string(function_epilogue);
+
+ InterpreterTester tester(handles.main_isolate(), script.c_str(), "t");
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*delete_lookup_slot[i].second));
+ }
+}
+
+
+TEST(JumpWithConstantsAndWideConstants) {
+ HandleAndZoneScope handles;
+ auto isolate = handles.main_isolate();
+ auto factory = isolate->factory();
+ const int kStep = 13;
+ for (int constants = 3; constants < 256 + 3 * kStep; constants += kStep) {
+ std::ostringstream filler_os;
+ // Generate a string that consumes constant pool entries and
+ // spread out branch distances in script below.
+ for (int i = 0; i < constants; i++) {
+ filler_os << "var x_ = 'x_" << i << "';\n";
+ }
+ std::string filler(filler_os.str());
+ std::ostringstream script_os;
+ script_os << "function " << InterpreterTester::function_name() << "(a) {\n";
+ script_os << " " << filler;
+ script_os << " for (var i = a; i < 2; i++) {\n";
+ script_os << " " << filler;
+ script_os << " if (i == 0) { " << filler << "i = 10; continue; }\n";
+ script_os << " else if (i == a) { " << filler << "i = 12; break; }\n";
+ script_os << " else { " << filler << " }\n";
+ script_os << " }\n";
+ script_os << " return i;\n";
+ script_os << "}\n";
+ std::string script(script_os.str());
+ for (int a = 0; a < 3; a++) {
+ InterpreterTester tester(handles.main_isolate(), script.c_str());
+ auto callable = tester.GetCallable<Handle<Object>>();
+ Handle<Object> return_val =
+ callable(factory->NewNumberFromInt(a)).ToHandleChecked();
+ static const int results[] = {11, 12, 2};
+ CHECK_EQ(Handle<Smi>::cast(return_val)->value(), results[a]);
+ }
+ }
+}
+
+
+TEST(InterpreterEval) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> eval[] = {
+ {"return eval('1;');", handle(Smi::FromInt(1), isolate)},
+ {"return eval('100 * 20;');", handle(Smi::FromInt(2000), isolate)},
+ {"var x = 10; return eval('x + 20;');",
+ handle(Smi::FromInt(30), isolate)},
+ {"var x = 10; eval('x = 33;'); return x;",
+ handle(Smi::FromInt(33), isolate)},
+ {"'use strict'; var x = 20; var z = 0;\n"
+ "eval('var x = 33; z = x;'); return x + z;",
+ handle(Smi::FromInt(53), isolate)},
+ {"eval('var x = 33;'); eval('var y = x + 20'); return x + y;",
+ handle(Smi::FromInt(86), isolate)},
+ {"var x = 1; eval('for(i = 0; i < 10; i++) x = x + 1;'); return x",
+ handle(Smi::FromInt(11), isolate)},
+ {"var x = 10; eval('var x = 20;'); return x;",
+ handle(Smi::FromInt(20), isolate)},
+ {"var x = 1; eval('\"use strict\"; var x = 2;'); return x;",
+ handle(Smi::FromInt(1), isolate)},
+ {"'use strict'; var x = 1; eval('var x = 2;'); return x;",
+ handle(Smi::FromInt(1), isolate)},
+ {"var x = 10; eval('x + 20;'); return typeof x;",
+ factory->NewStringFromStaticChars("number")},
+ {"eval('var y = 10;'); return typeof unallocated;",
+ factory->NewStringFromStaticChars("undefined")},
+ {"'use strict'; eval('var y = 10;'); return typeof unallocated;",
+ factory->NewStringFromStaticChars("undefined")},
+ {"eval('var x = 10;'); return typeof x;",
+ factory->NewStringFromStaticChars("number")},
+ {"var x = {}; eval('var x = 10;'); return typeof x;",
+ factory->NewStringFromStaticChars("number")},
+ {"'use strict'; var x = {}; eval('var x = 10;'); return typeof x;",
+ factory->NewStringFromStaticChars("object")},
+ };
+
+ for (size_t i = 0; i < arraysize(eval); i++) {
+ std::string source(InterpreterTester::SourceForBody(eval[i].first));
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*eval[i].second));
+ }
+}
+
+
+TEST(InterpreterEvalParams) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+
+ std::pair<const char*, Handle<Object>> eval_params[] = {
+ {"var x = 10; return eval('x + p1;');",
+ handle(Smi::FromInt(30), isolate)},
+ {"var x = 10; eval('p1 = x;'); return p1;",
+ handle(Smi::FromInt(10), isolate)},
+ {"var a = 10;"
+ "function inner() { return eval('a + p1;');}"
+ "return inner();",
+ handle(Smi::FromInt(30), isolate)},
+ };
+
+ for (size_t i = 0; i < arraysize(eval_params); i++) {
+ std::string source = "function " + InterpreterTester::function_name() +
+ "(p1) {" + eval_params[i].first + "}";
+ InterpreterTester tester(handles.main_isolate(), source.c_str());
+ auto callable = tester.GetCallable<Handle<Object>>();
+
+ Handle<i::Object> return_value =
+ callable(handle(Smi::FromInt(20), isolate)).ToHandleChecked();
+ CHECK(return_value->SameValue(*eval_params[i].second));
+ }
+}
+
+
+TEST(InterpreterEvalGlobal) {
+ HandleAndZoneScope handles;
+ i::Isolate* isolate = handles.main_isolate();
+ i::Factory* factory = isolate->factory();
+
+ std::pair<const char*, Handle<Object>> eval_global[] = {
+ {"function add_global() { eval('function test() { z = 33; }; test()'); };"
+ "function f() { add_global(); return z; }; f();",
+ handle(Smi::FromInt(33), isolate)},
+ {"function add_global() {\n"
+ " eval('\"use strict\"; function test() { y = 33; };"
+ " try { test() } catch(e) {}');\n"
+ "}\n"
+ "function f() { add_global(); return typeof y; } f();",
+ factory->NewStringFromStaticChars("undefined")},
+ };
+
+ for (size_t i = 0; i < arraysize(eval_global); i++) {
+ InterpreterTester tester(handles.main_isolate(), eval_global[i].first,
+ "test");
+ auto callable = tester.GetCallable<>();
+
+ Handle<i::Object> return_value = callable().ToHandleChecked();
+ CHECK(return_value->SameValue(*eval_global[i].second));
+ }
+}
+
+} // namespace interpreter
+} // namespace internal
+} // namespace v8