[hydrogen] don't bailout assignments to consts

src/hydrogen.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 3938 matching lines @@
 
   if (expr->is_compound()) {
     HandleCompoundAssignment(expr);
     return;
   }
 
   if (prop != NULL) {
     HandlePropertyAssignment(expr);
   } else if (proxy != NULL) {
     Variable* var = proxy->var();
-    if (var->mode() == CONST) {
-      if (expr->op() != Token::INIT_CONST) {
-        return Bailout("non-initializer assignment to const");
-      }
-      if (!var->IsStackAllocated()) {
-        return Bailout("assignment to const context slot");
-      }
-      // We insert a use of the old value to detect unsupported uses of const
-      // variables (e.g. initialization inside a loop).
-      HValue* old_value = environment()->Lookup(var);
-      AddInstruction(new HUseConst(old_value));
-    } else if (var->mode() == LET) {
+    if (var->mode() == LET) {
       if (!var->IsStackAllocated()) {
         return Bailout("assignment to let context slot");
       }
-    } else if (var->mode() == CONST_HARMONY) {
-      if (expr->op() != Token::INIT_CONST_HARMONY) {
-        return Bailout("non-initializer assignment to const");
+    }
+
+    if (var->is_const_mode()) {

[fschneider, 2011/12/08 13:01:30]

CONST_HARMONY has different semantics from CONST. There is another change under
review to deal with harmony-const (http://codereview.chromium.org/8820015/), so
you should leave it out in this change and only handle plain CONST.

+      // Changing value of const variable only possible at initialization
+      if (expr->op() != Token::INIT_CONST &&
+          expr->op() != Token::INIT_CONST_HARMONY) {
+        CHECK_ALIVE(VisitForValue(expr->value()));
+        return ast_context()->ReturnValue(Pop());
       }
-      if (!var->IsStackAllocated()) {
-        return Bailout("assignment to const context slot");
+
+      if (var->IsStackAllocated()) {
+        // We insert a use of the old value to detect unsupported uses of const
+        // variables (e.g. initialization inside a loop).
+        HValue* old_value = environment()->Lookup(var);
+        AddInstruction(new HUseConst(old_value));
       }
     }
 
     if (proxy->IsArguments()) return Bailout("assignment to arguments");
 
     // Handle the assignment.
     switch (var->location()) {
       case Variable::UNALLOCATED:
         CHECK_ALIVE(VisitForValue(expr->value()));
         HandleGlobalVariableAssignment(var,
@@ skipping 15 matching lines @@
         // 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();
         Bind(var, value);
         return ast_context()->ReturnValue(value);
       }
 
       case Variable::CONTEXT: {
-        ASSERT(var->mode() != CONST);
         // 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 (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 = info()->scope()->num_parameters();
           for (int i = 0; i < count; ++i) {
             if (var == info()->scope()->parameter(i)) {
               return Bailout("assignment to parameter in arguments object");
             }
           }
         }
 
         CHECK_ALIVE(VisitForValue(expr->value()));
         HValue* context = BuildContextChainWalk(var);
         HStoreContextSlot* instr =
             new(zone()) HStoreContextSlot(context, var->index(), Top());
+
+        // Ensure that const variable's value will be set only once
+        if (var->is_const_mode()) {
+          instr->ForceIsHoleCheck();
+        }
+
         AddInstruction(instr);
         if (instr->HasObservableSideEffects()) {
           AddSimulate(expr->AssignmentId());
         }
         return ast_context()->ReturnValue(Pop());
       }
 
       case Variable::LOOKUP:
         return Bailout("assignment to LOOKUP variable");
     }
@@ skipping 3204 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal