Simple support for const variables in Crankshaft....

src/hydrogen.cc

 // Copyright 2010 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 484 matching lines @@
 HConstant* HGraph::GetConstantTrue() {
   return GetConstant(&constant_true_, Heap::true_value());
 }
 
 
 HConstant* HGraph::GetConstantFalse() {
   return GetConstant(&constant_false_, Heap::false_value());
 }
 
 
+HConstant* HGraph::GetConstantHole() {
+  return GetConstant(&constant_hole_, Heap::the_hole_value());
+}
+
+
 void HSubgraph::AppendOptional(HSubgraph* graph,
                                bool on_true_branch,
                                HValue* boolean_value) {
   ASSERT(HasExit() && graph->HasExit());
   HBasicBlock* other_block = graph_->CreateBasicBlock();
   HBasicBlock* join_block = graph_->CreateBasicBlock();
 
   HBasicBlock* true_branch = other_block;
   HBasicBlock* false_branch = graph->entry_block();
   if (on_true_branch) {
@@ skipping 369 matching lines @@
 
 bool HGraph::CollectPhis() {
   const ZoneList<HBasicBlock*>* blocks = graph_->blocks();
   phi_list_ = new ZoneList<HPhi*>(blocks->length());
   for (int i = 0; i < blocks->length(); ++i) {
     for (int j = 0; j < blocks->at(i)->phis()->length(); j++) {
       HPhi* phi = blocks->at(i)->phis()->at(j);
       phi_list_->Add(phi);
       // We don't support phi uses of arguments for now.
       if (phi->CheckFlag(HValue::kIsArguments)) return false;
+      // Check for the hole value (from an uninitialized const).
+      for (int k = 0; k < phi->OperandCount(); k++) {
+        if (phi->OperandAt(k) == GetConstantHole()) return false;
+      }
     }
   }
   return true;
 }
 
 
 void HGraph::InferTypes(ZoneList<HValue*>* worklist) {
   BitVector in_worklist(GetMaximumValueID());
   for (int i = 0; i < worklist->length(); ++i) {
     ASSERT(!in_worklist.Contains(worklist->at(i)->id()));
@@ skipping 1309 matching lines @@
 
     if (graph_->HasExit()) {
       graph_->FinishExit(new HReturn(graph_->GetConstantUndefined()));
     }
   }
 
   graph_->OrderBlocks();
   graph_->AssignDominators();
   graph_->EliminateRedundantPhis();
   if (!graph_->CollectPhis()) {
-    Bailout("Phi-use of arguments object");
+    Bailout("Unsupported phi-use");
     return NULL;
   }
 
   HInferRepresentation rep(graph_);
   rep.Analyze();
 
   if (FLAG_use_range) {
     HRangeAnalysis rangeAnalysis(graph_);
     rangeAnalysis.Analyze();
   }
@@ skipping 88 matching lines @@
 }
 
 
 void HGraphBuilder::SetupScope(Scope* scope) {
   // We don't yet handle the function name for named function expressions.
   if (scope->function() != NULL) BAILOUT("named function expression");
 
   // We can't handle heap-allocated locals.
   if (scope->num_heap_slots() > 0) BAILOUT("heap allocated locals");
 
+  if (scope->HasIllegalRedeclaration()) BAILOUT("illegal redeclaration");
+
   HConstant* undefined_constant =
       new HConstant(Factory::undefined_value(), Representation::Tagged());
   AddInstruction(undefined_constant);
   graph_->set_undefined_constant(undefined_constant);
 
   // Set the initial values of parameters including "this".  "This" has
   // parameter index 0.
   int count = scope->num_parameters() + 1;
   for (int i = 0; i < count; ++i) {
     HInstruction* parameter = AddInstruction(new HParameter(i));
@@ skipping 587 matching lines @@
     BAILOUT("read-only global variable");
   }
 }
 
 
 void HGraphBuilder::VisitVariableProxy(VariableProxy* expr) {
   Variable* variable = expr->AsVariable();
   if (variable == NULL) {
     BAILOUT("reference to rewritten variable");
   } else if (variable->IsStackAllocated()) {
-    if (environment()->Lookup(variable)->CheckFlag(HValue::kIsArguments)) {
+    HValue* value = environment()->Lookup(variable);
+    if (value->CheckFlag(HValue::kIsArguments)) {
       BAILOUT("unsupported context for arguments object");
     }
-    ast_context()->ReturnValue(environment()->Lookup(variable));
+    if (variable->mode() == Variable::CONST &&
+        value == graph()->GetConstantHole()) {
+      BAILOUT("unsupported reference to const variable");

[Kevin Millikin (Chromium), 2011/01/04 13:46:33]

ast_context()->ReturnValue(graph()->GetConstantUndefined());

+    }
+    ast_context()->ReturnValue(value);
   } else if (variable->is_global()) {
     LookupResult lookup;
     LookupGlobalPropertyCell(variable, &lookup, false);
     CHECK_BAILOUT;
 
     Handle<GlobalObject> global(graph()->info()->global_object());
     // TODO(3039103): Handle global property load through an IC call when access
     // checks are enabled.
     if (global->IsAccessCheckNeeded()) {
       BAILOUT("global object requires access check");
@@ skipping 398 matching lines @@
   Variable* var = proxy->AsVariable();
   Property* prop = target->AsProperty();
   ASSERT(var == 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();
   operation->RecordTypeFeedback(oracle());
 
   if (var != NULL) {
+    if (var->mode() == Variable::CONST) BAILOUT("unsupported const assignment");

[Kevin Millikin (Chromium), 2011/01/04 13:46:33]

Instead of statically bailing out, how about visiting the operation and then
guarding the assignment with something like

if (var->mode() != Variable::CONST) ....

     if (!var->is_global() && !var->IsStackAllocated()) {
       BAILOUT("non-stack/non-global in compound assignment");
     }
 
     VISIT_FOR_VALUE(operation);
 
     if (var->is_global()) {
       HandleGlobalVariableAssignment(var,
                                      Top(),
                                      expr->position(),
@@ skipping 84 matching lines @@
   Variable* var = proxy->AsVariable();
   Property* prop = expr->target()->AsProperty();
   ASSERT(var == NULL || prop == NULL);
 
   if (expr->is_compound()) {
     HandleCompoundAssignment(expr);
     return;
   }
 
   if (var != NULL) {
+    if (var->mode() == Variable::CONST) {
+      if (expr->op() != Token::INIT_CONST) {
+        BAILOUT("unsupported const assignment");

[Kevin Millikin (Chromium), 2011/01/04 13:46:33]

Instead of statically bailing out for non-INIT_CONST assignments to CONST
variables, you could just ignore them.

+      }
+      // 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);

[Kevin Millikin (Chromium), 2011/01/04 13:46:33]

It's a little indirect to add this use and detect it in a postprocessing pass. 
It seems more direct (though a bit more implementation effort) to keep track of
a loop nesting depth and bailout if non-zero.

I'm also not thrilled with InitConst as an instruction.  It's not initializing
anything and it's odd that it refers to the old value and not the new.  It's
more like UseValue or something.

+      AddInstruction(new HInitConst(old_value));
+    }
+
+
     if (proxy->IsArguments()) BAILOUT("assignment to arguments");
 
     // Handle the assignment.
     if (var->is_global()) {
       VISIT_FOR_VALUE(expr->value());
       HandleGlobalVariableAssignment(var,
                                      Top(),
                                      expr->position(),
                                      expr->AssignmentId());
     } else {
@@ skipping 1052 matching lines @@
 void HGraphBuilder::VisitCountOperation(CountOperation* expr) {
   IncrementOperation* increment = expr->increment();
   Expression* target = increment->expression();
   VariableProxy* proxy = target->AsVariableProxy();
   Variable* var = proxy->AsVariable();
   Property* prop = target->AsProperty();
   ASSERT(var == NULL || prop == NULL);
   bool inc = expr->op() == Token::INC;
 
   if (var != NULL) {
+    if (var->mode() == Variable::CONST) BAILOUT("unsupported count operation");

[Kevin Millikin (Chromium), 2011/01/04 13:46:33]

Same comment.

     if (!var->is_global() && !var->IsStackAllocated()) {
       BAILOUT("non-stack/non-global variable in count operation");
     }
 
     VISIT_FOR_VALUE(target);
 
     // Match the full code generator stack by simulating an extra stack
     // element for postfix operations in a non-effect context.
     bool has_extra = expr->is_postfix() && !ast_context()->IsEffect();
     HValue* before = has_extra ? Top() : Pop();
@@ skipping 334 matching lines @@
 
 
 void HGraphBuilder::VisitThisFunction(ThisFunction* expr) {
   BAILOUT("ThisFunction");
 }
 
 
 void HGraphBuilder::VisitDeclaration(Declaration* decl) {
   // We allow only declarations that do not require code generation.
   // The following all require code generation: global variables and
-  // functions, variables with slot type LOOKUP, declarations with
-  // mode CONST, and functions.
+  // functions, variables with slot type LOOKUP

[Kevin Millikin (Chromium), 2011/01/04 13:46:33]

Fix the comment so it's still a sentence (add "and" and a period).

   Variable* var = decl->proxy()->var();
   Slot* slot = var->AsSlot();
   if (var->is_global() ||
       (slot != NULL && slot->type() == Slot::LOOKUP) ||
-      decl->mode() == Variable::CONST ||
       decl->fun() != NULL) {
     BAILOUT("unsupported declaration");
   }
+
+  if (var->mode() == Variable::CONST) {

[Kevin Millikin (Chromium), 2011/01/04 13:46:33]

I don't think you should change the test against decl->mode() to one against
var->mode().  Declaration::mode() can only be VAR or CONST, while
Variable::mode() could be all kinds of other stuff (DYNAMIC, DYNAMIC_GLOBAL,
etc).

I'm worried that things will break as we support more stuff if we don't handle
constants more or less like the baseline compiler.

+    environment()->Bind(var, graph()->GetConstantHole());

[Kevin Millikin (Chromium), 2011/01/04 13:46:33]

I'm surprised you don't have to check that the variable is stack allocated here.

+  }
 }
 
 
 // Generators for inline runtime functions.
 // Support for types.
 void HGraphBuilder::GenerateIsSmi(int argument_count, int ast_id) {
   ASSERT(argument_count == 1);
   HValue* value = Pop();
   HIsSmi* result = new HIsSmi(value);
   ast_context()->ReturnInstruction(result, ast_id);
@@ skipping 763 matching lines @@
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (chunk_ != NULL) chunk_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal