Optimize Crankshaft array literal initialization from boilerplate.

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 3439 matching lines @@
 
 
 void HGraphBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   ZoneList<Expression*>* subexprs = expr->values();
   int length = subexprs->length();
   HValue* context = environment()->LookupContext();
 
-  HArrayLiteral* literal = new(zone()) HArrayLiteral(context,
-                                                     expr->constant_elements(),
-                                                     length,
-                                                     expr->literal_index(),
-                                                     expr->depth());
-  // The array is expected in the bailout environment during computation
-  // of the property values and is the value of the entire expression.
-  PushAndAdd(literal);
+  FixedArray* literals = environment()->closure()->literals();
+  Handle<Object> raw_boilerplate(literals->get(expr->literal_index()));
 
-  HLoadElements* elements = NULL;
+  // For now, no boilerplate causes a deopt.
+  if (raw_boilerplate->IsUndefined()) {
+    AddInstruction(new(zone()) HSoftDeoptimize);
+    return ast_context()->ReturnValue(graph()->GetConstantUndefined());
+  } else {

[Jakob Kummerow, 2011/11/30 14:04:51]

Since the if-branch ends with a return statement, you can skip the explicit
"else {" to avoid the "arrow" anti-pattern.

[danno, 2011/12/01 14:41:11]

Done.

+    Handle<JSObject> boilerplate(Handle<JSObject>::cast(raw_boilerplate));
+    ElementsKind boilerplate_elements_kind = boilerplate->GetElementsKind();
 
-  for (int i = 0; i < length; i++) {
-    Expression* subexpr = subexprs->at(i);
-    // If the subexpression is a literal or a simple materialized literal it
-    // is already set in the cloned array.
-    if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
+    HArrayLiteral* literal = new(zone()) HArrayLiteral(
+        context,
+        boilerplate,
+        length,
+        expr->literal_index(),
+        expr->depth());
 
-    CHECK_ALIVE(VisitForValue(subexpr));
-    HValue* value = Pop();
-    if (!Smi::IsValid(i)) return Bailout("Non-smi key in array literal");
+    // The array is expected in the bailout environment during computation
+    // of the property values and is the value of the entire expression.
+    PushAndAdd(literal);
 
-    elements = new(zone()) HLoadElements(literal);
-    AddInstruction(elements);
+    HLoadElements* elements = NULL;
 
-    HValue* key = AddInstruction(
-        new(zone()) HConstant(Handle<Object>(Smi::FromInt(i)),
-                              Representation::Integer32()));
-    HInstruction* elements_kind =
-        AddInstruction(new(zone()) HElementsKind(literal));
-    HBasicBlock* store_fast = graph()->CreateBasicBlock();
-    // Two empty blocks to satisfy edge split form.
-    HBasicBlock* store_fast_edgesplit1 = graph()->CreateBasicBlock();
-    HBasicBlock* store_fast_edgesplit2 = graph()->CreateBasicBlock();
-    HBasicBlock* store_generic = graph()->CreateBasicBlock();
-    HBasicBlock* check_smi_only_elements = graph()->CreateBasicBlock();
-    HBasicBlock* join = graph()->CreateBasicBlock();
+    for (int i = 0; i < length; i++) {
+      Expression* subexpr = subexprs->at(i);
+      // If the subexpression is a literal or a simple materialized literal it
+      // is already set in the cloned array.
+      if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
 
-    HIsSmiAndBranch* smicheck = new(zone()) HIsSmiAndBranch(value);
-    smicheck->SetSuccessorAt(0, store_fast_edgesplit1);
-    smicheck->SetSuccessorAt(1, check_smi_only_elements);
-    current_block()->Finish(smicheck);
-    store_fast_edgesplit1->Finish(new(zone()) HGoto(store_fast));
+      CHECK_ALIVE(VisitForValue(subexpr));
+      HValue* value = Pop();
+      if (!Smi::IsValid(i)) return Bailout("Non-smi key in array literal");
 
-    set_current_block(check_smi_only_elements);
-    HCompareConstantEqAndBranch* smi_elements_check =
-        new(zone()) HCompareConstantEqAndBranch(elements_kind,
-                                                FAST_ELEMENTS,
-                                                Token::EQ_STRICT);
-    smi_elements_check->SetSuccessorAt(0, store_fast_edgesplit2);
-    smi_elements_check->SetSuccessorAt(1, store_generic);
-    current_block()->Finish(smi_elements_check);
-    store_fast_edgesplit2->Finish(new(zone()) HGoto(store_fast));
+      elements = new(zone()) HLoadElements(literal);
+      AddInstruction(elements);
 
-    set_current_block(store_fast);
-    AddInstruction(new(zone()) HStoreKeyedFastElement(elements, key, value));
-    store_fast->Goto(join);
+      HValue* key = AddInstruction(
+          new(zone()) HConstant(Handle<Object>(Smi::FromInt(i)),
+                                Representation::Integer32()));
 
-    set_current_block(store_generic);
-    AddInstruction(BuildStoreKeyedGeneric(literal, key, value));
-    store_generic->Goto(join);
+      switch (boilerplate_elements_kind) {
+        case FAST_SMI_ONLY_ELEMENTS:
+        case FAST_ELEMENTS:
+          AddInstruction(new(zone()) HStoreKeyedFastElement(

[Jakob Kummerow, 2011/11/30 14:04:51]

Hm... this will deopt if |value| doesn't match |boilerplate_elements_kind|, but
IIUC your changes to runtime.cc should make sure that doesn't happen too often.
OK.

[danno, 2011/12/01 14:41:11]

Done.

+              elements,
+              key,
+              value,
+              boilerplate_elements_kind));
+          break;
+        case FAST_DOUBLE_ELEMENTS:
+          AddInstruction(new(zone()) HStoreKeyedFastDoubleElement(elements,
+                                                                  key,
+                                                                  value));
+          break;
+        default:
+          UNREACHABLE();
+          break;
+      }
 
-    join->SetJoinId(expr->id());
-    set_current_block(join);
-
-    AddSimulate(expr->GetIdForElement(i));
+      AddSimulate(expr->GetIdForElement(i));
+    }
+    return ast_context()->ReturnValue(Pop());
   }
-  return ast_context()->ReturnValue(Pop());
 }
 
 
 // Sets the lookup result and returns true if the store can be inlined.
 static bool ComputeStoredField(Handle<Map> type,
                                Handle<String> name,
                                LookupResult* lookup) {
   type->LookupInDescriptors(NULL, *name, lookup);
   if (!lookup->IsPropertyOrTransition()) return false;
   if (lookup->type() == FIELD) return true;
@@ skipping 3687 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal