| // Copyright 2014 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/interpreter/bytecode-array-builder.h" |
| #include "src/interpreter/bytecode-array-iterator.h" |
| #include "test/unittests/test-utils.h" |
| |
| namespace v8 { |
| namespace internal { |
| namespace interpreter { |
| |
| class BytecodeArrayBuilderTest : public TestWithIsolateAndZone { |
| public: |
| BytecodeArrayBuilderTest() {} |
| ~BytecodeArrayBuilderTest() override {} |
| }; |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) { |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| |
| builder.set_locals_count(2); |
| builder.set_context_count(1); |
| builder.set_parameter_count(0); |
| CHECK_EQ(builder.locals_count(), 2); |
| CHECK_EQ(builder.context_count(), 1); |
| CHECK_EQ(builder.fixed_register_count(), 3); |
| |
| // Emit constant loads. |
| builder.LoadLiteral(Smi::FromInt(0)) |
| .LoadLiteral(Smi::FromInt(8)) |
| .LoadLiteral(Smi::FromInt(10000000)) |
| .LoadUndefined() |
| .LoadNull() |
| .LoadTheHole() |
| .LoadTrue() |
| .LoadFalse(); |
| |
| // Emit accumulator transfers. Stores followed by loads to the same register |
| // are not generated. Hence, a dummy instruction in between. |
| Register reg(0); |
| builder.LoadAccumulatorWithRegister(reg) |
| .LoadNull() |
| .StoreAccumulatorInRegister(reg); |
| |
| // Emit register-register transfer. |
| Register other(1); |
| builder.MoveRegister(reg, other); |
| |
| // Emit global load / store operations. |
| builder.LoadGlobal(0, 1, LanguageMode::SLOPPY, TypeofMode::NOT_INSIDE_TYPEOF) |
| .LoadGlobal(0, 1, LanguageMode::STRICT, TypeofMode::NOT_INSIDE_TYPEOF) |
| .LoadGlobal(0, 1, LanguageMode::SLOPPY, TypeofMode::INSIDE_TYPEOF) |
| .LoadGlobal(0, 1, LanguageMode::STRICT, TypeofMode::INSIDE_TYPEOF) |
| .StoreGlobal(0, 1, LanguageMode::SLOPPY) |
| .StoreGlobal(0, 1, LanguageMode::STRICT); |
| |
| // Emit wide global load / store operations. |
| builder.LoadGlobal(0, 1024, LanguageMode::SLOPPY, |
| TypeofMode::NOT_INSIDE_TYPEOF) |
| .LoadGlobal(1024, 1, LanguageMode::STRICT, TypeofMode::NOT_INSIDE_TYPEOF) |
| .LoadGlobal(0, 1024, LanguageMode::SLOPPY, TypeofMode::INSIDE_TYPEOF) |
| .LoadGlobal(1024, 1, LanguageMode::STRICT, TypeofMode::INSIDE_TYPEOF) |
| .StoreGlobal(0, 1024, LanguageMode::SLOPPY) |
| .StoreGlobal(1024, 1, LanguageMode::STRICT); |
| |
| // Emit context operations. |
| builder.PushContext(reg); |
| builder.PopContext(reg); |
| builder.LoadContextSlot(reg, 1); |
| builder.StoreContextSlot(reg, 1); |
| |
| // Emit load / store property operations. |
| builder.LoadNamedProperty(reg, 0, 0, LanguageMode::SLOPPY) |
| .LoadKeyedProperty(reg, 0, LanguageMode::SLOPPY) |
| .StoreNamedProperty(reg, 0, 0, LanguageMode::SLOPPY) |
| .StoreKeyedProperty(reg, reg, 0, LanguageMode::SLOPPY) |
| .LoadNamedProperty(reg, 0, 0, LanguageMode::STRICT) |
| .LoadKeyedProperty(reg, 0, LanguageMode::STRICT) |
| .StoreNamedProperty(reg, 0, 0, LanguageMode::STRICT) |
| .StoreKeyedProperty(reg, reg, 0, LanguageMode::STRICT); |
| |
| // Emit wide load / store property operations. |
| builder.LoadNamedProperty(reg, 2056, 0, LanguageMode::SLOPPY) |
| .LoadKeyedProperty(reg, 2056, LanguageMode::SLOPPY) |
| .StoreNamedProperty(reg, 0, 2056, LanguageMode::SLOPPY) |
| .StoreKeyedProperty(reg, reg, 2056, LanguageMode::SLOPPY) |
| .LoadNamedProperty(reg, 2056, 0, LanguageMode::STRICT) |
| .LoadKeyedProperty(reg, 2056, LanguageMode::STRICT) |
| .StoreNamedProperty(reg, 0, 2056, LanguageMode::STRICT) |
| .StoreKeyedProperty(reg, reg, 2056, LanguageMode::STRICT); |
| |
| // Emit closure operations. |
| Factory* factory = isolate()->factory(); |
| Handle<SharedFunctionInfo> shared_info = factory->NewSharedFunctionInfo( |
| factory->NewStringFromStaticChars("function_a"), MaybeHandle<Code>()); |
| builder.CreateClosure(shared_info, NOT_TENURED); |
| |
| // Emit argument creation operations. |
| builder.CreateArguments(CreateArgumentsType::kMappedArguments) |
| .CreateArguments(CreateArgumentsType::kUnmappedArguments); |
| |
| // Emit literal creation operations |
| builder.CreateRegExpLiteral(0, reg) |
| .CreateArrayLiteral(0, 0) |
| .CreateObjectLiteral(0, 0); |
| |
| // Call operations. |
| builder.Call(reg, reg, 0, 0) |
| .Call(reg, reg, 0, 1024) |
| .CallRuntime(Runtime::kIsArray, reg, 1) |
| .CallJSRuntime(Context::SPREAD_ITERABLE_INDEX, reg, 1); |
| |
| // Emit binary operator invocations. |
| builder.BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .BinaryOperation(Token::Value::SUB, reg, Strength::WEAK) |
| .BinaryOperation(Token::Value::MUL, reg, Strength::WEAK) |
| .BinaryOperation(Token::Value::DIV, reg, Strength::WEAK) |
| .BinaryOperation(Token::Value::MOD, reg, Strength::WEAK); |
| |
| // Emit bitwise operator invocations |
| builder.BinaryOperation(Token::Value::BIT_OR, reg, Strength::WEAK) |
| .BinaryOperation(Token::Value::BIT_XOR, reg, Strength::WEAK) |
| .BinaryOperation(Token::Value::BIT_AND, reg, Strength::WEAK); |
| |
| // Emit shift operator invocations |
| builder.BinaryOperation(Token::Value::SHL, reg, Strength::WEAK) |
| .BinaryOperation(Token::Value::SAR, reg, Strength::WEAK) |
| .BinaryOperation(Token::Value::SHR, reg, Strength::WEAK); |
| |
| // Emit count operatior invocations |
| builder.CountOperation(Token::Value::ADD, Strength::WEAK) |
| .CountOperation(Token::Value::SUB, Strength::WEAK); |
| |
| // Emit unary operator invocations. |
| builder.LogicalNot().TypeOf(); |
| |
| // Emit delete |
| builder.Delete(reg, LanguageMode::SLOPPY).Delete(reg, LanguageMode::STRICT); |
| |
| // Emit new. |
| builder.New(reg, reg, 0); |
| |
| // Emit test operator invocations. |
| builder.CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .CompareOperation(Token::Value::NE, reg, Strength::WEAK) |
| .CompareOperation(Token::Value::EQ_STRICT, reg, Strength::WEAK) |
| .CompareOperation(Token::Value::NE_STRICT, reg, Strength::WEAK) |
| .CompareOperation(Token::Value::LT, reg, Strength::WEAK) |
| .CompareOperation(Token::Value::GT, reg, Strength::WEAK) |
| .CompareOperation(Token::Value::LTE, reg, Strength::WEAK) |
| .CompareOperation(Token::Value::GTE, reg, Strength::WEAK) |
| .CompareOperation(Token::Value::INSTANCEOF, reg, Strength::WEAK) |
| .CompareOperation(Token::Value::IN, reg, Strength::WEAK); |
| |
| // Emit cast operator invocations. |
| builder.CastAccumulatorToNumber() |
| .CastAccumulatorToBoolean() |
| .CastAccumulatorToJSObject() |
| .CastAccumulatorToName(); |
| |
| // Emit control flow. Return must be the last instruction. |
| BytecodeLabel start; |
| builder.Bind(&start); |
| // Short jumps with Imm8 operands |
| builder.Jump(&start) |
| .JumpIfNull(&start) |
| .JumpIfUndefined(&start); |
| // Perform an operation that returns boolean value to |
| // generate JumpIfTrue/False |
| builder.CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfTrue(&start) |
| .CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfFalse(&start); |
| // Perform an operation that returns a non-boolean operation to |
| // generate JumpIfToBooleanTrue/False. |
| builder.BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfTrue(&start) |
| .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfFalse(&start); |
| // Insert dummy ops to force longer jumps |
| for (int i = 0; i < 128; i++) { |
| builder.LoadTrue(); |
| } |
| // Longer jumps requiring Constant operand |
| builder.Jump(&start) |
| .JumpIfNull(&start) |
| .JumpIfUndefined(&start); |
| // Perform an operation that returns boolean value to |
| // generate JumpIfTrue/False |
| builder.CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfTrue(&start) |
| .CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfFalse(&start); |
| // Perform an operation that returns a non-boolean operation to |
| // generate JumpIfToBooleanTrue/False. |
| builder.BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfTrue(&start) |
| .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfFalse(&start); |
| |
| // Emit throw in it's own basic block so that the rest of the code isn't |
| // omitted due to being dead. |
| BytecodeLabel after_throw; |
| builder.Jump(&after_throw) |
| .Throw() |
| .Bind(&after_throw); |
| |
| builder.ForInPrepare(reg).ForInDone(reg).ForInNext(reg, reg); |
| |
| // Wide constant pool loads |
| for (int i = 0; i < 256; i++) { |
| // Emit junk in constant pool to force wide constant pool index. |
| builder.GetConstantPoolEntry(handle(Smi::FromInt(i), isolate())); |
| } |
| builder.LoadLiteral(Smi::FromInt(20000000)); |
| |
| // CreateClosureWide |
| Handle<SharedFunctionInfo> shared_info2 = factory->NewSharedFunctionInfo( |
| factory->NewStringFromStaticChars("function_b"), MaybeHandle<Code>()); |
| builder.CreateClosure(shared_info2, NOT_TENURED); |
| |
| builder.Return(); |
| |
| // Generate BytecodeArray. |
| Handle<BytecodeArray> the_array = builder.ToBytecodeArray(); |
| CHECK_EQ(the_array->frame_size(), |
| builder.fixed_register_count() * kPointerSize); |
| |
| // Build scorecard of bytecodes encountered in the BytecodeArray. |
| std::vector<int> scorecard(Bytecodes::ToByte(Bytecode::kLast) + 1); |
| Bytecode final_bytecode = Bytecode::kLdaZero; |
| int i = 0; |
| while (i < the_array->length()) { |
| uint8_t code = the_array->get(i); |
| scorecard[code] += 1; |
| final_bytecode = Bytecodes::FromByte(code); |
| i += Bytecodes::Size(Bytecodes::FromByte(code)); |
| } |
| |
| // Check return occurs at the end and only once in the BytecodeArray. |
| CHECK_EQ(final_bytecode, Bytecode::kReturn); |
| CHECK_EQ(scorecard[Bytecodes::ToByte(final_bytecode)], 1); |
| |
| #define CHECK_BYTECODE_PRESENT(Name, ...) \ |
| /* Check Bytecode is marked in scorecard */ \ |
| CHECK_GE(scorecard[Bytecodes::ToByte(Bytecode::k##Name)], 1); |
| BYTECODE_LIST(CHECK_BYTECODE_PRESENT) |
| #undef CHECK_BYTECODE_PRESENT |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, FrameSizesLookGood) { |
| for (int locals = 0; locals < 5; locals++) { |
| for (int contexts = 0; contexts < 4; contexts++) { |
| for (int temps = 0; temps < 3; temps++) { |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(0); |
| builder.set_locals_count(locals); |
| builder.set_context_count(contexts); |
| |
| TemporaryRegisterScope temporaries(&builder); |
| for (int i = 0; i < temps; i++) { |
| builder.StoreAccumulatorInRegister(temporaries.NewRegister()); |
| } |
| builder.Return(); |
| |
| Handle<BytecodeArray> the_array = builder.ToBytecodeArray(); |
| int total_registers = locals + contexts + temps; |
| CHECK_EQ(the_array->frame_size(), total_registers * kPointerSize); |
| } |
| } |
| } |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, TemporariesRecycled) { |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(0); |
| builder.set_locals_count(0); |
| builder.set_context_count(0); |
| builder.Return(); |
| |
| int first; |
| { |
| TemporaryRegisterScope temporaries(&builder); |
| first = temporaries.NewRegister().index(); |
| temporaries.NewRegister(); |
| temporaries.NewRegister(); |
| temporaries.NewRegister(); |
| } |
| |
| int second; |
| { |
| TemporaryRegisterScope temporaries(&builder); |
| second = temporaries.NewRegister().index(); |
| } |
| |
| CHECK_EQ(first, second); |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, RegisterValues) { |
| int index = 1; |
| uint8_t operand = static_cast<uint8_t>(-index); |
| |
| Register the_register(index); |
| CHECK_EQ(the_register.index(), index); |
| |
| int actual_operand = the_register.ToOperand(); |
| CHECK_EQ(actual_operand, operand); |
| |
| int actual_index = Register::FromOperand(actual_operand).index(); |
| CHECK_EQ(actual_index, index); |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, Parameters) { |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(10); |
| builder.set_locals_count(0); |
| builder.set_context_count(0); |
| |
| Register param0(builder.Parameter(0)); |
| Register param9(builder.Parameter(9)); |
| CHECK_EQ(param9.index() - param0.index(), 9); |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, RegisterType) { |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(10); |
| builder.set_locals_count(3); |
| builder.set_context_count(0); |
| |
| TemporaryRegisterScope temporary_register_scope(&builder); |
| Register temp0 = temporary_register_scope.NewRegister(); |
| Register param0(builder.Parameter(0)); |
| Register param9(builder.Parameter(9)); |
| Register temp1 = temporary_register_scope.NewRegister(); |
| Register reg0(0); |
| Register reg1(1); |
| Register reg2(2); |
| Register temp2 = temporary_register_scope.NewRegister(); |
| CHECK_EQ(builder.RegisterIsParameterOrLocal(temp0), false); |
| CHECK_EQ(builder.RegisterIsParameterOrLocal(temp1), false); |
| CHECK_EQ(builder.RegisterIsParameterOrLocal(temp2), false); |
| CHECK_EQ(builder.RegisterIsParameterOrLocal(param0), true); |
| CHECK_EQ(builder.RegisterIsParameterOrLocal(param9), true); |
| CHECK_EQ(builder.RegisterIsParameterOrLocal(reg0), true); |
| CHECK_EQ(builder.RegisterIsParameterOrLocal(reg1), true); |
| CHECK_EQ(builder.RegisterIsParameterOrLocal(reg2), true); |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, Constants) { |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(0); |
| builder.set_locals_count(0); |
| builder.set_context_count(0); |
| |
| Factory* factory = isolate()->factory(); |
| Handle<HeapObject> heap_num_1 = factory->NewHeapNumber(3.14); |
| Handle<HeapObject> heap_num_2 = factory->NewHeapNumber(5.2); |
| Handle<Object> large_smi(Smi::FromInt(0x12345678), isolate()); |
| Handle<HeapObject> heap_num_2_copy(*heap_num_2); |
| builder.LoadLiteral(heap_num_1) |
| .LoadLiteral(heap_num_2) |
| .LoadLiteral(large_smi) |
| .LoadLiteral(heap_num_1) |
| .LoadLiteral(heap_num_1) |
| .LoadLiteral(heap_num_2_copy); |
| |
| Handle<BytecodeArray> array = builder.ToBytecodeArray(); |
| // Should only have one entry for each identical constant. |
| CHECK_EQ(array->constant_pool()->length(), 3); |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, ForwardJumps) { |
| static const int kFarJumpDistance = 256; |
| |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(0); |
| builder.set_locals_count(1); |
| builder.set_context_count(0); |
| |
| Register reg(0); |
| BytecodeLabel far0, far1, far2, far3, far4; |
| BytecodeLabel near0, near1, near2, near3, near4; |
| |
| builder.Jump(&near0) |
| .CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfTrue(&near1) |
| .CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfFalse(&near2) |
| .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfTrue(&near3) |
| .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfFalse(&near4) |
| .Bind(&near0) |
| .Bind(&near1) |
| .Bind(&near2) |
| .Bind(&near3) |
| .Bind(&near4) |
| .Jump(&far0) |
| .CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfTrue(&far1) |
| .CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfFalse(&far2) |
| .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfTrue(&far3) |
| .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfFalse(&far4); |
| for (int i = 0; i < kFarJumpDistance - 18; i++) { |
| builder.LoadUndefined(); |
| } |
| builder.Bind(&far0).Bind(&far1).Bind(&far2).Bind(&far3).Bind(&far4); |
| builder.Return(); |
| |
| Handle<BytecodeArray> array = builder.ToBytecodeArray(); |
| DCHECK_EQ(array->length(), 36 + kFarJumpDistance - 18 + 1); |
| |
| BytecodeArrayIterator iterator(array); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 18); |
| iterator.Advance(); |
| |
| // Ignore compare operation. |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrue); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 14); |
| iterator.Advance(); |
| |
| // Ignore compare operation. |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalse); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 10); |
| iterator.Advance(); |
| |
| // Ignore add operation. |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfToBooleanTrue); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 6); |
| iterator.Advance(); |
| |
| // Ignore add operation. |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfToBooleanFalse); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 2); |
| iterator.Advance(); |
| |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpConstant); |
| CHECK_EQ(*iterator.GetConstantForIndexOperand(0), |
| Smi::FromInt(kFarJumpDistance)); |
| iterator.Advance(); |
| |
| // Ignore compare operation. |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrueConstant); |
| CHECK_EQ(*iterator.GetConstantForIndexOperand(0), |
| Smi::FromInt(kFarJumpDistance - 4)); |
| iterator.Advance(); |
| |
| // Ignore compare operation. |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalseConstant); |
| CHECK_EQ(*iterator.GetConstantForIndexOperand(0), |
| Smi::FromInt(kFarJumpDistance - 8)); |
| iterator.Advance(); |
| |
| // Ignore add operation. |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfToBooleanTrueConstant); |
| CHECK_EQ(*iterator.GetConstantForIndexOperand(0), |
| Smi::FromInt(kFarJumpDistance - 12)); |
| iterator.Advance(); |
| |
| // Ignore add operation. |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), |
| Bytecode::kJumpIfToBooleanFalseConstant); |
| CHECK_EQ(*iterator.GetConstantForIndexOperand(0), |
| Smi::FromInt(kFarJumpDistance - 16)); |
| iterator.Advance(); |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, BackwardJumps) { |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(0); |
| builder.set_locals_count(1); |
| builder.set_context_count(0); |
| Register reg(0); |
| |
| BytecodeLabel label0, label1, label2, label3, label4; |
| builder.Bind(&label0) |
| .Jump(&label0) |
| .Bind(&label1) |
| .CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfTrue(&label1) |
| .Bind(&label2) |
| .CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfFalse(&label2) |
| .Bind(&label3) |
| .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfTrue(&label3) |
| .Bind(&label4) |
| .BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfFalse(&label4); |
| for (int i = 0; i < 63; i++) { |
| builder.Jump(&label4); |
| } |
| builder.BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfFalse(&label4); |
| builder.BinaryOperation(Token::Value::ADD, reg, Strength::WEAK) |
| .JumpIfTrue(&label3); |
| builder.CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfFalse(&label2); |
| builder.CompareOperation(Token::Value::EQ, reg, Strength::WEAK) |
| .JumpIfTrue(&label1); |
| builder.Jump(&label0); |
| builder.Return(); |
| |
| Handle<BytecodeArray> array = builder.ToBytecodeArray(); |
| BytecodeArrayIterator iterator(array); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 0); |
| iterator.Advance(); |
| // Ignore compare operation. |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrue); |
| CHECK_EQ(iterator.GetImmediateOperand(0), -2); |
| iterator.Advance(); |
| // Ignore compare operation. |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalse); |
| CHECK_EQ(iterator.GetImmediateOperand(0), -2); |
| iterator.Advance(); |
| // Ignore binary operation. |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfToBooleanTrue); |
| CHECK_EQ(iterator.GetImmediateOperand(0), -2); |
| iterator.Advance(); |
| // Ignore binary operation. |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfToBooleanFalse); |
| CHECK_EQ(iterator.GetImmediateOperand(0), -2); |
| iterator.Advance(); |
| for (int i = 0; i < 63; i++) { |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump); |
| CHECK_EQ(iterator.GetImmediateOperand(0), -i * 2 - 4); |
| iterator.Advance(); |
| } |
| // Ignore binary operation. |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), |
| Bytecode::kJumpIfToBooleanFalseConstant); |
| CHECK_EQ(Smi::cast(*iterator.GetConstantForIndexOperand(0))->value(), -132); |
| iterator.Advance(); |
| // Ignore binary operation. |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfToBooleanTrueConstant); |
| CHECK_EQ(Smi::cast(*iterator.GetConstantForIndexOperand(0))->value(), -140); |
| iterator.Advance(); |
| // Ignore compare operation. |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfFalseConstant); |
| CHECK_EQ(Smi::cast(*iterator.GetConstantForIndexOperand(0))->value(), -148); |
| iterator.Advance(); |
| // Ignore compare operation. |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrueConstant); |
| CHECK_EQ(Smi::cast(*iterator.GetConstantForIndexOperand(0))->value(), -156); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpConstant); |
| CHECK_EQ(Smi::cast(*iterator.GetConstantForIndexOperand(0))->value(), -160); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn); |
| iterator.Advance(); |
| CHECK(iterator.done()); |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, LabelReuse) { |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(0); |
| builder.set_locals_count(0); |
| builder.set_context_count(0); |
| |
| // Labels can only have 1 forward reference, but |
| // can be referred to mulitple times once bound. |
| BytecodeLabel label; |
| |
| builder.Jump(&label).Bind(&label).Jump(&label).Jump(&label).Return(); |
| |
| Handle<BytecodeArray> array = builder.ToBytecodeArray(); |
| BytecodeArrayIterator iterator(array); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 2); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 0); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump); |
| CHECK_EQ(iterator.GetImmediateOperand(0), -2); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn); |
| iterator.Advance(); |
| CHECK(iterator.done()); |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, LabelAddressReuse) { |
| static const int kRepeats = 3; |
| |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(0); |
| builder.set_locals_count(0); |
| builder.set_context_count(0); |
| |
| for (int i = 0; i < kRepeats; i++) { |
| BytecodeLabel label; |
| builder.Jump(&label).Bind(&label).Jump(&label).Jump(&label); |
| } |
| |
| builder.Return(); |
| |
| Handle<BytecodeArray> array = builder.ToBytecodeArray(); |
| BytecodeArrayIterator iterator(array); |
| for (int i = 0; i < kRepeats; i++) { |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 2); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump); |
| CHECK_EQ(iterator.GetImmediateOperand(0), 0); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJump); |
| CHECK_EQ(iterator.GetImmediateOperand(0), -2); |
| iterator.Advance(); |
| } |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn); |
| iterator.Advance(); |
| CHECK(iterator.done()); |
| } |
| |
| |
| TEST_F(BytecodeArrayBuilderTest, ToBoolean) { |
| BytecodeArrayBuilder builder(isolate(), zone()); |
| builder.set_parameter_count(0); |
| builder.set_locals_count(0); |
| builder.set_context_count(0); |
| |
| // Check ToBoolean emitted at start of a basic block. |
| builder.CastAccumulatorToBoolean(); |
| |
| // Check ToBoolean emitted preceding bytecode is non-boolean. |
| builder.LoadNull().CastAccumulatorToBoolean(); |
| |
| // Check ToBoolean omitted if preceding bytecode is boolean. |
| builder.LoadFalse().CastAccumulatorToBoolean(); |
| |
| // Check ToBoolean emitted if it is at the start of a basic block caused by a |
| // bound label. |
| BytecodeLabel label; |
| builder.LoadFalse() |
| .Bind(&label) |
| .CastAccumulatorToBoolean(); |
| |
| // Check ToBoolean emitted if it is at the start of a basic block caused by a |
| // jump. |
| builder.LoadFalse() |
| .JumpIfTrue(&label) |
| .CastAccumulatorToBoolean(); |
| |
| builder.Return(); |
| |
| Handle<BytecodeArray> array = builder.ToBytecodeArray(); |
| BytecodeArrayIterator iterator(array); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kToBoolean); |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kLdaNull); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kToBoolean); |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kLdaFalse); |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kLdaFalse); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kToBoolean); |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kLdaFalse); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kJumpIfTrue); |
| iterator.Advance(); |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kToBoolean); |
| iterator.Advance(); |
| |
| CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn); |
| iterator.Advance(); |
| CHECK(iterator.done()); |
| } |
| |
| |
| } // namespace interpreter |
| } // namespace internal |
| } // namespace v8 |