Revert remove dead hole check logic

src/crankshaft/hydrogen.cc

 // Copyright 2013 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/crankshaft/hydrogen.h"
 
 #include <memory>
 #include <sstream>
 
 #include "src/allocation-site-scopes.h"
@@ skipping 4225 matching lines @@
   { BreakAndContinueScope push(&break_info, this);
     if (scope != NULL) {
       if (scope->NeedsContext()) {
         // Load the function object.
         DeclarationScope* declaration_scope = scope->GetDeclarationScope();
         HInstruction* function;
         HValue* outer_context = environment()->context();
         if (declaration_scope->is_script_scope() ||
             declaration_scope->is_eval_scope()) {
           function = new (zone())
-              HLoadContextSlot(outer_context, Context::CLOSURE_INDEX);
+              HLoadContextSlot(outer_context, Context::CLOSURE_INDEX,
+                               HLoadContextSlot::kNoCheck);
         } else {
           function = New<HThisFunction>();
         }
         AddInstruction(function);
         // Allocate a block context and store it to the stack frame.
         HValue* scope_info = Add<HConstant>(scope->scope_info());
         Add<HPushArguments>(scope_info, function);
         HInstruction* inner_context = Add<HCallRuntime>(
             Runtime::FunctionForId(Runtime::kPushBlockContext), 2);
         inner_context->SetFlag(HValue::kHasNoObservableSideEffects);
@@ skipping 971 matching lines @@
     instr->SetDependsOnFlag(kGlobalVars);
     return ast_context()->ReturnInstruction(instr, ast_id);
   }
 }
 
 void HOptimizedGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
   DCHECK(!HasStackOverflow());
   DCHECK(current_block() != NULL);
   DCHECK(current_block()->HasPredecessor());
   Variable* variable = expr->var();
-  DCHECK(!variable->binding_needs_init());
   switch (variable->location()) {
     case VariableLocation::UNALLOCATED: {
+      if (IsLexicalVariableMode(variable->mode())) {
+        // TODO(rossberg): should this be an DCHECK?
+        return Bailout(kReferenceToGlobalLexicalVariable);
+      }
       // Handle known global constants like 'undefined' specially to avoid a
       // load from a global cell for them.
       Handle<Object> constant_value =
           isolate()->factory()->GlobalConstantFor(variable->name());
       if (!constant_value.is_null()) {
         HConstant* instr = New<HConstant>(constant_value);
         return ast_context()->ReturnInstruction(instr, expr->id());
       }
 
       Handle<JSGlobalObject> global(current_info()->global_object());
@@ skipping 41 matching lines @@
         HCallWithDescriptor* instr = New<HCallWithDescriptor>(
             Code::LOAD_GLOBAL_IC, stub, 0, callable.descriptor(),
             ArrayVector(values));
         return ast_context()->ReturnInstruction(instr, expr->id());
       }
     }
 
     case VariableLocation::PARAMETER:
     case VariableLocation::LOCAL: {
       HValue* value = LookupAndMakeLive(variable);
+      if (value == graph()->GetConstantHole()) {
+        DCHECK(IsDeclaredVariableMode(variable->mode()) &&
+               variable->mode() != VAR);
+        return Bailout(kReferenceToUninitializedVariable);
+      }
       return ast_context()->ReturnValue(value);
     }
 
     case VariableLocation::CONTEXT: {
       HValue* context = BuildContextChainWalk(variable);
+      HLoadContextSlot::Mode mode;
+      switch (variable->mode()) {
+        case LET:
+        case CONST:
+          mode = HLoadContextSlot::kCheckDeoptimize;
+          break;
+        default:
+          mode = HLoadContextSlot::kNoCheck;
+          break;
+      }
       HLoadContextSlot* instr =
-          new (zone()) HLoadContextSlot(context, variable->index());
+          new(zone()) HLoadContextSlot(context, variable->index(), mode);
       return ast_context()->ReturnInstruction(instr, expr->id());
     }
 
     case VariableLocation::LOOKUP:
       return Bailout(kReferenceToAVariableWhichRequiresDynamicLookup);
 
     case VariableLocation::MODULE:
       UNREACHABLE();
   }
 }
@@ skipping 1200 matching lines @@
   VariableProxy* proxy = target->AsVariableProxy();
   Property* prop = target->AsProperty();
   DCHECK(proxy == NULL || prop == NULL);
 
   // We have a second position recorded in the FullCodeGenerator to have
   // type feedback for the binary operation.
   BinaryOperation* operation = expr->binary_operation();
 
   if (proxy != NULL) {
     Variable* var = proxy->var();
-    DCHECK(!var->binding_needs_init());
+    if (var->mode() == LET)  {
+      return Bailout(kUnsupportedLetCompoundAssignment);
+    }
 
     CHECK_ALIVE(VisitForValue(operation));
 
     switch (var->location()) {
       case VariableLocation::UNALLOCATED:
         HandleGlobalVariableAssignment(var, Top(), expr->AssignmentSlot(),
                                        expr->AssignmentId());
         break;
 
       case VariableLocation::PARAMETER:
@@ skipping 13 matching lines @@
           // direct way to detect that the variable is a parameter so we do
           // a linear search of the parameter variables.
           int count = current_info()->scope()->num_parameters();
           for (int i = 0; i < count; ++i) {
             if (var == current_info()->scope()->parameter(i)) {
               Bailout(kAssignmentToParameterFunctionUsesArgumentsObject);
             }
           }
         }
 
-        if (var->mode() == CONST) {
-          if (var->throw_on_const_assignment(function_language_mode())) {
-            return Bailout(kNonInitializerAssignmentToConst);
-          } else {
-            return ast_context()->ReturnValue(Pop());
-          }
+        HStoreContextSlot::Mode mode;
+
+        switch (var->mode()) {
+          case LET:
+            mode = HStoreContextSlot::kCheckDeoptimize;
+            break;
+          case CONST:
+            if (var->throw_on_const_assignment(function_language_mode())) {
+              return Bailout(kNonInitializerAssignmentToConst);
+            } else {
+              return ast_context()->ReturnValue(Pop());
+            }
+          default:
+            mode = HStoreContextSlot::kNoCheck;
         }
 
         HValue* context = BuildContextChainWalk(var);
-        HStoreContextSlot* instr =
-            Add<HStoreContextSlot>(context, var->index(), Top());
+        HStoreContextSlot* instr = Add<HStoreContextSlot>(
+            context, var->index(), mode, Top());
         if (instr->HasObservableSideEffects()) {
           Add<HSimulate>(expr->AssignmentId(), REMOVABLE_SIMULATE);
         }
         break;
       }
 
       case VariableLocation::LOOKUP:
         return Bailout(kCompoundAssignmentToLookupSlot);
 
       case VariableLocation::MODULE:
@@ skipping 37 matching lines @@
 
   if (expr->is_compound()) {
     HandleCompoundAssignment(expr);
     return;
   }
 
   if (prop != NULL) {
     HandlePropertyAssignment(expr);
   } else if (proxy != NULL) {
     Variable* var = proxy->var();
-    DCHECK(!var->binding_needs_init());
 
-    if (var->mode() == CONST && expr->op() != Token::INIT) {
-      if (var->throw_on_const_assignment(function_language_mode())) {
-        return Bailout(kNonInitializerAssignmentToConst);
-      } else {
-        CHECK_ALIVE(VisitForValue(expr->value()));
-        return ast_context()->ReturnValue(Pop());
+    if (var->mode() == CONST) {
+      if (expr->op() != Token::INIT) {
+        if (var->throw_on_const_assignment(function_language_mode())) {
+          return Bailout(kNonInitializerAssignmentToConst);
+        } else {
+          CHECK_ALIVE(VisitForValue(expr->value()));
+          return ast_context()->ReturnValue(Pop());
+        }
       }
     }
 
     // Handle the assignment.
     switch (var->location()) {
       case VariableLocation::UNALLOCATED:
         CHECK_ALIVE(VisitForValue(expr->value()));
         HandleGlobalVariableAssignment(var, Top(), expr->AssignmentSlot(),
                                        expr->AssignmentId());
         return ast_context()->ReturnValue(Pop());
 
       case VariableLocation::PARAMETER:
       case VariableLocation::LOCAL: {
+        // Perform an initialization check for let declared variables
+        // or parameters.
+        if (var->mode() == LET && expr->op() == Token::ASSIGN) {
+          HValue* env_value = environment()->Lookup(var);
+          if (env_value == graph()->GetConstantHole()) {
+            return Bailout(kAssignmentToLetVariableBeforeInitialization);
+          }
+        }
         // We do not allow the arguments object to occur in a context where it
         // may escape, but assignments to stack-allocated locals are
         // permitted.
         CHECK_ALIVE(VisitForValue(expr->value(), ARGUMENTS_ALLOWED));
         HValue* value = Pop();
         BindIfLive(var, value);
         return ast_context()->ReturnValue(value);
       }
 
       case VariableLocation::CONTEXT: {
         // Bail out if we try to mutate a parameter value in a function using
         // the arguments object.  We do not (yet) correctly handle the
         // arguments property of the function.
         if (current_info()->scope()->arguments() != NULL) {
           // Parameters will rewrite to context slots.  We have no direct way
           // to detect that the variable is a parameter.
           int count = current_info()->scope()->num_parameters();
           for (int i = 0; i < count; ++i) {
             if (var == current_info()->scope()->parameter(i)) {
               return Bailout(kAssignmentToParameterInArgumentsObject);
             }
           }
         }
 
         CHECK_ALIVE(VisitForValue(expr->value()));
+        HStoreContextSlot::Mode mode;
+        if (expr->op() == Token::ASSIGN) {
+          switch (var->mode()) {
+            case LET:
+              mode = HStoreContextSlot::kCheckDeoptimize;
+              break;
+            case CONST:
+              // If we reached this point, the only possibility
+              // is a sloppy assignment to a function name.
+              DCHECK(function_language_mode() == SLOPPY &&
+                     !var->throw_on_const_assignment(SLOPPY));
+              return ast_context()->ReturnValue(Pop());
+            default:
+              mode = HStoreContextSlot::kNoCheck;
+          }
+        } else {
+          DCHECK_EQ(Token::INIT, expr->op());
+          mode = HStoreContextSlot::kNoCheck;
+        }
+
         HValue* context = BuildContextChainWalk(var);
-        HStoreContextSlot* instr =
-            Add<HStoreContextSlot>(context, var->index(), Top());
+        HStoreContextSlot* instr = Add<HStoreContextSlot>(
+            context, var->index(), mode, Top());
         if (instr->HasObservableSideEffects()) {
           Add<HSimulate>(expr->AssignmentId(), REMOVABLE_SIMULATE);
         }
         return ast_context()->ReturnValue(Pop());
       }
 
       case VariableLocation::LOOKUP:
         return Bailout(kAssignmentToLOOKUPVariable);
 
       case VariableLocation::MODULE:
@@ skipping 3675 matching lines @@
   // Match the full code generator stack by simulating an extra stack
   // element for postfix operations in a non-effect context.  The return
   // value is ToNumber(input).
   bool returns_original_input =
       expr->is_postfix() && !ast_context()->IsEffect();
   HValue* input = NULL;  // ToNumber(original_input).
   HValue* after = NULL;  // The result after incrementing or decrementing.
 
   if (proxy != NULL) {
     Variable* var = proxy->var();
-    DCHECK(!var->binding_needs_init());
     if (var->mode() == CONST) {
       return Bailout(kNonInitializerAssignmentToConst);
     }
     // Argument of the count operation is a variable, not a property.
     DCHECK(prop == NULL);
     CHECK_ALIVE(VisitForValue(target));
 
     after = BuildIncrement(expr);
     input = returns_original_input ? Top() : Pop();
     Push(after);
 
     switch (var->location()) {
       case VariableLocation::UNALLOCATED:
         HandleGlobalVariableAssignment(var, after, expr->CountSlot(),
                                        expr->AssignmentId());
         break;
 
       case VariableLocation::PARAMETER:
       case VariableLocation::LOCAL:
         BindIfLive(var, after);
         break;
 
       case VariableLocation::CONTEXT: {
         HValue* context = BuildContextChainWalk(var);
-        HStoreContextSlot* instr =
-            Add<HStoreContextSlot>(context, var->index(), after);
+        HStoreContextSlot::Mode mode = IsLexicalVariableMode(var->mode())
+            ? HStoreContextSlot::kCheckDeoptimize : HStoreContextSlot::kNoCheck;
+        HStoreContextSlot* instr = Add<HStoreContextSlot>(context, var->index(),
+                                                          mode, after);
         if (instr->HasObservableSideEffects()) {
           Add<HSimulate>(expr->AssignmentId(), REMOVABLE_SIMULATE);
         }
         break;
       }
 
       case VariableLocation::LOOKUP:
         return Bailout(kLookupVariableInCountOperation);
 
       case VariableLocation::MODULE:
@@ skipping 1362 matching lines @@
     Add<HDeclareGlobals>(array, flags, vector);
     globals_.Rewind(0);
   }
 }
 
 
 void HOptimizedGraphBuilder::VisitVariableDeclaration(
     VariableDeclaration* declaration) {
   VariableProxy* proxy = declaration->proxy();
   Variable* variable = proxy->var();
-  DCHECK(!variable->binding_needs_init());
   switch (variable->location()) {
     case VariableLocation::UNALLOCATED: {
+      DCHECK(!variable->binding_needs_init());
       globals_.Add(variable->name(), zone());
       FeedbackVectorSlot slot = proxy->VariableFeedbackSlot();
       DCHECK(!slot.IsInvalid());
       globals_.Add(handle(Smi::FromInt(slot.ToInt()), isolate()), zone());
       globals_.Add(isolate()->factory()->undefined_value(), zone());
       return;
     }
     case VariableLocation::PARAMETER:
     case VariableLocation::LOCAL:
+      if (variable->binding_needs_init()) {
+        HValue* value = graph()->GetConstantHole();
+        environment()->Bind(variable, value);
+      }
+      break;
     case VariableLocation::CONTEXT:
+      if (variable->binding_needs_init()) {
+        HValue* value = graph()->GetConstantHole();
+        HValue* context = environment()->context();
+        HStoreContextSlot* store = Add<HStoreContextSlot>(
+            context, variable->index(), HStoreContextSlot::kNoCheck, value);
+        if (store->HasObservableSideEffects()) {
+          Add<HSimulate>(proxy->id(), REMOVABLE_SIMULATE);
+        }
+      }
       break;
     case VariableLocation::LOOKUP:
       return Bailout(kUnsupportedLookupSlotInDeclaration);
     case VariableLocation::MODULE:
       UNREACHABLE();
   }
 }
 
 
 void HOptimizedGraphBuilder::VisitFunctionDeclaration(
@@ skipping 17 matching lines @@
     case VariableLocation::LOCAL: {
       CHECK_ALIVE(VisitForValue(declaration->fun()));
       HValue* value = Pop();
       BindIfLive(variable, value);
       break;
     }
     case VariableLocation::CONTEXT: {
       CHECK_ALIVE(VisitForValue(declaration->fun()));
       HValue* value = Pop();
       HValue* context = environment()->context();
-      HStoreContextSlot* store =
-          Add<HStoreContextSlot>(context, variable->index(), value);
+      HStoreContextSlot* store = Add<HStoreContextSlot>(
+          context, variable->index(), HStoreContextSlot::kNoCheck, value);
       if (store->HasObservableSideEffects()) {
         Add<HSimulate>(proxy->id(), REMOVABLE_SIMULATE);
       }
       break;
     }
     case VariableLocation::LOOKUP:
       return Bailout(kUnsupportedLookupSlotInDeclaration);
     case VariableLocation::MODULE:
       UNREACHABLE();
   }
@@ skipping 1093 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8