[interpreter] Add bytecodes for JumpIfNotHole with constant

src/interpreter/bytecode-generator.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/interpreter/bytecode-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/interpreter/bytecode-register-allocator.h"
 #include "src/interpreter/control-flow-builders.h"
@@ skipping 1680 matching lines @@
 
 
 void BytecodeGenerator::VisitVariableProxy(VariableProxy* proxy) {
   VisitVariableLoad(proxy->var(), proxy->VariableFeedbackSlot());
 }
 
 void BytecodeGenerator::BuildHoleCheckForVariableLoad(VariableMode mode,
                                                       Handle<String> name) {
   if (mode == CONST_LEGACY) {
     BytecodeLabel end_label;
-    builder()->JumpIfNotHole(&end_label);
-    builder()->LoadUndefined();
-    builder()->Bind(&end_label);
+    builder()->JumpIfNotHole(&end_label).LoadUndefined().Bind(&end_label);
   } else if (mode == LET || mode == CONST) {
     BuildThrowIfHole(name);
   }
 }
 
 void BytecodeGenerator::VisitVariableLoad(Variable* variable,
                                           FeedbackVectorSlot slot,
                                           TypeofMode typeof_mode) {
   VariableMode mode = variable->mode();
   switch (variable->location()) {
@@ skipping 49 matching lines @@
       break;
     }
     case VariableLocation::LOOKUP: {
       builder()->LoadLookupSlot(variable->name(), typeof_mode);
       execution_result()->SetResultInAccumulator();
       break;
     }
   }
 }
 
-
 void BytecodeGenerator::VisitVariableLoadForAccumulatorValue(
     Variable* variable, FeedbackVectorSlot slot, TypeofMode typeof_mode) {
   AccumulatorResultScope accumulator_result(this);
   VisitVariableLoad(variable, slot, typeof_mode);
 }
 
-
 Register BytecodeGenerator::VisitVariableLoadForRegisterValue(
     Variable* variable, FeedbackVectorSlot slot, TypeofMode typeof_mode) {
   RegisterResultScope register_scope(this);
   VisitVariableLoad(variable, slot, typeof_mode);
   return register_scope.ResultRegister();
 }
 
+void BytecodeGenerator::BuildThrowReferenceError(Handle<String> name) {
+  RegisterAllocationScope register_scope(this);
+  Register name_reg = register_allocator()->NewRegister();
+  builder()->LoadLiteral(name).StoreAccumulatorInRegister(name_reg).CallRuntime(
+      Runtime::kThrowReferenceError, name_reg, 1);
+}
+
 void BytecodeGenerator::BuildThrowIfHole(Handle<String> name) {
-  Register name_reg = register_allocator()->NewRegister();
-  BytecodeLabel end_label;
-  // TODO(mythria): This will be replaced by a new bytecode that throws an
-  // error if the value is the hole.
-  builder()
-      ->JumpIfNotHole(&end_label)
-      .LoadLiteral(name)
-      .StoreAccumulatorInRegister(name_reg)
-      .CallRuntime(Runtime::kThrowReferenceError, name_reg, 1)
-      .Bind(&end_label);
+  // TODO(interpreter): Can the parser reduce the number of checks
+  // performed? Or should there be a ThrowIfHole bytecode.
+  BytecodeLabel no_reference_error;
+  builder()->JumpIfNotHole(&no_reference_error);
+  BuildThrowReferenceError(name);
+  builder()->Bind(&no_reference_error);
 }
 
 void BytecodeGenerator::BuildThrowIfNotHole(Handle<String> name) {
-  Register name_reg = register_allocator()->NewRegister();
-  BytecodeLabel end_label;
-  // TODO(mythria): This will be replaced by a new bytecode that throws an
-  // error if the value is not the hole.
+  // TODO(interpreter): Can the parser reduce the number of checks
+  // performed? Or should there be a ThrowIfNotHole bytecode.
+  BytecodeLabel no_reference_error, reference_error;
   builder()
-      ->JumpIfHole(&end_label)
-      .LoadLiteral(name)
-      .StoreAccumulatorInRegister(name_reg)
-      .CallRuntime(Runtime::kThrowReferenceError, name_reg, 1)
-      .Bind(&end_label);
+      ->JumpIfNotHole(&reference_error)
+      .Jump(&no_reference_error)
+      .Bind(&reference_error);
+  BuildThrowReferenceError(name);
+  builder()->Bind(&no_reference_error);
 }
 
 void BytecodeGenerator::BuildThrowReassignConstant(Handle<String> name) {
-  Register name_reg = register_allocator()->NewRegister();
-  BytecodeLabel else_label;
   // TODO(mythria): This will be replaced by a new bytecode that throws an
   // appropriate error depending on the whether the value is a hole or not.
+  BytecodeLabel const_assign_error;
+  builder()->JumpIfNotHole(&const_assign_error);
+  BuildThrowReferenceError(name);
   builder()
-      ->JumpIfNotHole(&else_label)
-      .LoadLiteral(name)
-      .StoreAccumulatorInRegister(name_reg)
-      .CallRuntime(Runtime::kThrowReferenceError, name_reg, 1)
-      .Bind(&else_label)
+      ->Bind(&const_assign_error)
       .CallRuntime(Runtime::kThrowConstAssignError, Register(), 0);
 }
 
 void BytecodeGenerator::BuildHoleCheckForVariableAssignment(Variable* variable,
                                                             Token::Value op) {
   VariableMode mode = variable->mode();
   DCHECK(mode != CONST_LEGACY);
   if (mode == CONST && op != Token::INIT) {
     // Non-intializing assignments to constant is not allowed.
     BuildThrowReassignConstant(variable->name());
   } else if (mode == LET && op != Token::INIT) {
     // Perform an initialization check for let declared variables.
     // E.g. let x = (x = 20); is not allowed.
     BuildThrowIfHole(variable->name());
   } else {
     DCHECK(variable->is_this() && mode == CONST && op == Token::INIT);
     // Perform an initialization check for 'this'. 'this' variable is the
     // only variable able to trigger bind operations outside the TDZ
     // via 'super' calls.
-    BuildThrowIfNotHole(variable->name());
+    BuildThrowIfHole(variable->name());
   }
 }
 
 void BytecodeGenerator::VisitVariableAssignment(Variable* variable,
                                                 Token::Value op,
                                                 FeedbackVectorSlot slot) {
   VariableMode mode = variable->mode();
   RegisterAllocationScope assignment_register_scope(this);
   BytecodeLabel end_label;
   bool hole_check_required =
@@ skipping 1036 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8