[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 {
 
+class BytecodeArrayBuilder::PreviousBytecodeHelper {
+ public:
+  explicit PreviousBytecodeHelper(BytecodeArrayBuilder& array_builder)

[oth, 2015/11/24 13:49:26]

The array_builder argument and member should be const:
https://google.github.io/styleguide/cppguide.html#Reference_Arguments

[mythria, 2015/11/24 14:33:06]

Done.

+      : array_builder(array_builder) {}
+
+  Bytecode GetBytecode() const {
+    // Returns the previous bytecode in the same basicblock. If there is none it
+    // returns Bytecode::kLast.
+    if (!array_builder.LastBytecodeInSameBlock()) {
+      return Bytecode::kLast;
+    }
+    return Bytecodes::FromByte(
+        array_builder.bytecodes()->at(array_builder.last_bytecode_start_));
+  }
+
+  uint32_t GetOperand(int operand_index) const {
+    Bytecode bytecode = GetBytecode();
+    DCHECK_GE(operand_index, 0);
+    DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(bytecode));
+    size_t operand_offset =
+        array_builder.last_bytecode_start_ +
+        Bytecodes::GetOperandOffset(bytecode, operand_index);
+    OperandSize size = Bytecodes::GetOperandSize(bytecode, operand_index);
+    switch (size) {
+      default:
+      case OperandSize::kNone:
+        UNREACHABLE();
+      case OperandSize::kByte:
+        return static_cast<uint32_t>(
+            array_builder.bytecodes()->at(operand_offset));
+      case OperandSize::kShort:
+        uint16_t operand =
+            (array_builder.bytecodes()->at(operand_offset) << 8) +
+            array_builder.bytecodes()->at(operand_offset + 1);
+        return static_cast<uint32_t>(operand);
+    }
+  }
+
+  Handle<Object> GetConstantForIndexOperand(int operand_index) const {
+    return array_builder.constants_.at(GetOperand(operand_index));
+  }
+
+ private:
+  BytecodeArrayBuilder& array_builder;

[oth, 2015/11/24 13:49:26]

Coding style is for members of a class to end with underscore.

[mythria, 2015/11/24 14:33:06]

Done.

+};
+
+
 BytecodeArrayBuilder::BytecodeArrayBuilder(Isolate* isolate, Zone* zone)
     : isolate_(isolate),
       zone_(zone),
       bytecodes_(zone),
       bytecode_generated_(false),
       last_block_end_(0),
       last_bytecode_start_(~0),
       exit_seen_in_block_(false),
       constants_map_(isolate->heap(), zone),
       constants_(zone),
@@ skipping 249 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_))) {
+  PreviousBytecodeHelper previous_bytecode(*this);
+  switch (previous_bytecode.GetBytecode()) {
     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() {
+  PreviousBytecodeHelper previous_bytecode(*this);
   // If the previous bytecode puts a boolean in the accumulator
   // there is no need to emit an instruction.
   if (NeedToBooleanCast()) {
-    Output(Bytecode::kToBoolean);
+    switch (previous_bytecode.GetBytecode()) {
+      // If the previous bytecode is a constant evaluate it and return false.
+      case Bytecode::kLdaZero: {
+        LoadFalse();
+        break;
+      }
+      case Bytecode::kLdaSmi8: {
+        LoadBooleanConstant(previous_bytecode.GetOperand(0) != 0);
+        break;
+      }
+      case Bytecode::kLdaConstant: {
+        Handle<Object> object = previous_bytecode.GetConstantForIndexOperand(0);
+        LoadBooleanConstant(object->BooleanValue());
+        break;
+      }
+      default:
+        Output(Bytecode::kToBoolean);
+    }
   }
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CastAccumulatorToJSObject() {
   Output(Bytecode::kToObject);
   return *this;
 }
 
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::CastAccumulatorToName() {
+  PreviousBytecodeHelper previous_bytecode(*this);
+  switch (previous_bytecode.GetBytecode()) {
+    case Bytecode::kLdaConstantWide:
+    case Bytecode::kLdaConstant: {
+      Handle<Object> object = previous_bytecode.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 411 matching lines @@
 }
 
 
 bool BytecodeArrayBuilder::LastBytecodeInSameBlock() const {
   return last_bytecode_start_ < bytecodes()->size() &&
          last_bytecode_start_ >= last_block_end_;
 }
 
 
 bool BytecodeArrayBuilder::IsRegisterInAccumulator(Register reg) {
-  if (!LastBytecodeInSameBlock()) return false;
-  Bytecode previous_bytecode =
-      Bytecodes::FromByte(bytecodes()->at(last_bytecode_start_));
-  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))) {
+  PreviousBytecodeHelper previous_bytecode(*this);
+  if (previous_bytecode.GetBytecode() == Bytecode::kLdar ||
+      previous_bytecode.GetBytecode() == Bytecode::kStar) {
+    if (reg == Register::FromOperand(previous_bytecode.GetOperand(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