[Interpreter] Add support for cast operators to bytecode graph builder and

src/interpreter/bytecode-array-builder.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/interpreter/bytecode-array-builder.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 259 matching lines @@
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadFalse() {
   Output(Bytecode::kLdaFalse);
   return *this;
 }
 
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::LoadBooleanConstant(bool value) {
+  if (value) {
+    LoadTrue();
+  } else {
+    LoadFalse();
+  }
+  return *this;
+}
+
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadAccumulatorWithRegister(
     Register reg) {
   if (!IsRegisterInAccumulator(reg)) {
     Output(Bytecode::kLdar, reg.ToOperand());
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreAccumulatorInRegister(
@@ skipping 216 matching lines @@
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::PopContext(Register context) {
   Output(Bytecode::kPopContext, context.ToOperand());
   return *this;
 }
 
 
 bool BytecodeArrayBuilder::NeedToBooleanCast() {
-  if (!LastBytecodeInSameBlock()) {
-    // If the previous bytecode was from a different block return false.
-    return true;
-  }
-
-  // If the previous bytecode puts a boolean in the accumulator return true.
-  switch (Bytecodes::FromByte(bytecodes()->at(last_bytecode_start_))) {
+  switch (GetPreviousBytecodeInSameBlock()) {
     case Bytecode::kToBoolean:
       UNREACHABLE();
+    // If the previous bytecode puts a boolean in the accumulator return true.
     case Bytecode::kLdaTrue:
     case Bytecode::kLdaFalse:
     case Bytecode::kLogicalNot:
     case Bytecode::kTestEqual:
     case Bytecode::kTestNotEqual:
     case Bytecode::kTestEqualStrict:
     case Bytecode::kTestNotEqualStrict:
     case Bytecode::kTestLessThan:
     case Bytecode::kTestLessThanOrEqual:
     case Bytecode::kTestGreaterThan:
     case Bytecode::kTestGreaterThanOrEqual:
     case Bytecode::kTestInstanceOf:
     case Bytecode::kTestIn:
     case Bytecode::kForInDone:
       return false;
+    // Also handles the case where the previous bytecode was in a different
+    // block.
     default:
       return true;
   }
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CastAccumulatorToBoolean() {
   // If the previous bytecode puts a boolean in the accumulator
   // there is no need to emit an instruction.
   if (NeedToBooleanCast()) {
-    Output(Bytecode::kToBoolean);
+    switch (GetPreviousBytecodeInSameBlock()) {
+      // If the previous bytecode is a constant evaluate it and return false.
+      case Bytecode::kLdaZero: {
+        LoadFalse();
+        break;
+      }
+      case Bytecode::kLdaSmi8: {
+        LoadBooleanConstant(GetRawOperand(0) != 0);
+        break;
+      }
+      case Bytecode::kLdaConstant: {
+        Handle<Object> object = GetConstantForIndexOperand(0);
+        LoadBooleanConstant(object->BooleanValue());
+        break;
+      }
+      default:
+        Output(Bytecode::kToBoolean);
+    }
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CastAccumulatorToJSObject() {
   Output(Bytecode::kToObject);
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CastAccumulatorToName() {
+  Bytecode prev_bytecode = GetPreviousBytecodeInSameBlock();
+  switch (prev_bytecode) {
+    case Bytecode::kLdaConstantWide:
+    case Bytecode::kLdaConstant: {
+      Handle<Object> object = GetConstantForIndexOperand(0);
+      if (object->IsName()) return *this;
+      break;
+    }
+    case Bytecode::kToName:
+    case Bytecode::kTypeOf:
+      return *this;
+    default:
+      break;
+  }
   Output(Bytecode::kToName);
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CastAccumulatorToNumber() {
   // TODO(rmcilroy): consider omitting if the preceeding bytecode always returns
   // a number.
   Output(Bytecode::kToNumber);
   return *this;
@@ skipping 410 matching lines @@
   return false;
 }
 
 
 bool BytecodeArrayBuilder::LastBytecodeInSameBlock() const {
   return last_bytecode_start_ < bytecodes()->size() &&
          last_bytecode_start_ >= last_block_end_;
 }
 
 
+Bytecode BytecodeArrayBuilder::GetPreviousBytecodeInSameBlock() const {

[oth, 2015/11/23 13:46:41]

Suggest renaming to GetPreviousBytecode() as the method works if previous
bytecode is not in the same block and the name is pretty long otherwise.

[mythria, 2015/11/24 12:58:48]

I added a helper class that takes BytecodeArrayBuilder. I could also change it
to take more specific information it needs: last_bytecode_start_,
last_block_end_ and bytecode array. I am not sure which is better. Any
suggestions?

+  // Returns the previous bytecode in the same basicblock. If there is none it
+  // returns Bytecode::kLast.
+  if (!LastBytecodeInSameBlock()) {
+    return Bytecode::kLast;
+  }
+  return Bytecodes::FromByte(bytecodes()->at(last_bytecode_start_));
+}
+
+
+uint32_t BytecodeArrayBuilder::GetRawOperand(int operand_index) const {

[oth, 2015/11/23 13:46:41]

For clarity, it would be better to call this something like:

GetOperandOfPreviousBytecode().

+  Bytecode bytecode = GetPreviousBytecodeInSameBlock();
+  DCHECK_GE(operand_index, 0);
+  DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(bytecode));
+  size_t operand_offset = last_bytecode_start_ +
+                          Bytecodes::GetOperandOffset(bytecode, operand_index);
+  OperandSize size = Bytecodes::GetOperandSize(GetPreviousBytecodeInSameBlock(),
+                                               operand_index);
+  switch (size) {
+    default:
+    case OperandSize::kNone:
+      UNREACHABLE();
+    case OperandSize::kByte:
+      return static_cast<uint32_t>(bytecodes()->at(operand_offset));
+    case OperandSize::kShort:
+      uint16_t operand = (bytecodes()->at(operand_offset) << 8) +
+                         bytecodes()->at(operand_offset + 1);
+      return static_cast<uint32_t>(operand);
+  }
+}
+
+
+Handle<Object> BytecodeArrayBuilder::GetConstantForIndexOperand(

[oth, 2015/11/23 13:46:41]

GetConstantForIndexOperandOfPreviousBytecode(). Phew! Seems pretty long...

+    int operand_index) {
+  return constants_.at(GetRawOperand(operand_index));
+}
+
+
 bool BytecodeArrayBuilder::IsRegisterInAccumulator(Register reg) {
-  if (!LastBytecodeInSameBlock()) return false;
-  Bytecode previous_bytecode =
-      Bytecodes::FromByte(bytecodes()->at(last_bytecode_start_));
+  Bytecode previous_bytecode = GetPreviousBytecodeInSameBlock();
   if (previous_bytecode == Bytecode::kLdar ||
       previous_bytecode == Bytecode::kStar) {
-    size_t operand_offset = last_bytecode_start_ +
-                            Bytecodes::GetOperandOffset(previous_bytecode, 0);
-    if (reg == Register::FromOperand(bytecodes()->at(operand_offset))) {
+    if (reg == Register::FromOperand(GetRawOperand(0))) {
       return true;
     }
   }
   return false;
 }
 
 
 // static
 Bytecode BytecodeArrayBuilder::BytecodeForBinaryOperation(Token::Value op) {
   switch (op) {
@@ skipping 318 matching lines @@
   DCHECK_GT(next_consecutive_count_, 0);
   builder_->BorrowConsecutiveTemporaryRegister(next_consecutive_register_);
   allocated_.push_back(next_consecutive_register_);
   next_consecutive_count_--;
   return Register(next_consecutive_register_++);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8