Hydrogen stubs for array constructors

src/code-stubs-hydrogen.cc

 // Copyright 2012 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 114 matching lines @@
     parameters_[i] = param;
   }
 
   HInstruction* stack_parameter_count;
   if (descriptor_->stack_parameter_count_ != NULL) {
     ASSERT(descriptor_->environment_length() == (param_count + 1));
     stack_parameter_count = new(zone) HParameter(param_count,
                                                  HParameter::REGISTER_PARAMETER,
                                                  Representation::Integer32());
     // it's essential to bind this value to the environment in case of deopt
+    AddInstruction(stack_parameter_count);
     start_environment->Bind(param_count, stack_parameter_count);
-    AddInstruction(stack_parameter_count);
-    arguments_length_ = stack_parameter_count;
+    arguments_length_ = AddInstruction(new(zone) HChange(
+        stack_parameter_count,
+        Representation::Tagged(),
+        true,
+        false));
   } else {
     ASSERT(descriptor_->environment_length() == param_count);
     stack_parameter_count = graph()->GetConstantMinus1();
     arguments_length_ = graph()->GetConstant0();
   }
 
   context_ = new(zone) HContext();
   AddInstruction(context_);
   start_environment->BindContext(context_);
 
@@ skipping 247 matching lines @@
                                             map, true, JSArray::kMapOffset));
   return js_array;
 }
 
 
 Handle<Code> TransitionElementsKindStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
+// #define NOARG_DEOPT
+// #define ONEARG_DEOPT
+// #define NARG_DEOPT
 template <>
 HValue* CodeStubGraphBuilder<ArrayNoArgumentConstructorStub>::BuildCodeStub() {
+  // ----------- S t a t e -------------
+  //  -- Parameter 1 : type info cell
+  //  -- Parameter 0 : constructor
+  // -----------------------------------
+#ifdef NOARG_DEOPT
   HInstruction* deopt = new(zone()) HSoftDeoptimize();
   AddInstruction(deopt);
   current_block()->MarkAsDeoptimizing();
   return GetParameter(0);
+#else
+  // Get the right map
+  // Should be a constant
+  JSArrayBuilder array_builder(this,
+      casted_stub()->elements_kind(),
+      GetParameter(ArrayConstructorStubBase::kPropertyCell));
+  HValue* new_object = array_builder.AllocateEmptyArray();
+  return new_object;
+#endif
 }
 
 
 Handle<Code> ArrayNoArgumentConstructorStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<ArraySingleArgumentConstructorStub>::
     BuildCodeStub() {
+#ifdef ONEARG_DEOPT
   HInstruction* deopt = new(zone()) HSoftDeoptimize();
   AddInstruction(deopt);
   current_block()->MarkAsDeoptimizing();
   return GetParameter(0);
+#else
+  // Smi check and range check on the input arg.
+  HValue* constant_one = graph()->GetConstant1();
+  HValue* constant_zero = graph()->GetConstant0();
+
+  HInstruction* elements = AddInstruction(
+      new(zone()) HArgumentsElements(false));
+  HInstruction* argument = AddInstruction(
+      new(zone()) HAccessArgumentsAt(elements, constant_one, constant_zero));
+
+  HConstant* max_alloc_length =
+      new(zone()) HConstant(JSObject::kInitialMaxFastElementArray,
+                            Representation::Tagged());
+  AddInstruction(max_alloc_length);
+  const int initial_capacity = JSArray::kPreallocatedArrayElements;
+  HConstant* initial_capacity_node =
+      new(zone()) HConstant(initial_capacity, Representation::Tagged());
+  AddInstruction(initial_capacity_node);
+
+  // Since we're forcing Integer32 representation for this HBoundsCheck,
+  // there's no need to Smi-check the index.
+  HBoundsCheck* checked_arg = AddBoundsCheck(argument, max_alloc_length,
+                                             ALLOW_SMI_KEY,
+                                             Representation::Tagged());
+  IfBuilder if_builder(this);
+  if_builder.BeginIf(checked_arg, constant_zero, Token::EQ);
+  Push(initial_capacity_node);  // capacity
+  Push(constant_zero);  // length
+  if_builder.BeginElse();
+  Push(checked_arg);  // capacity
+  Push(checked_arg);  // length
+  if_builder.End();
+
+  // Figure out total size
+  HValue* length = Pop();
+  HValue* capacity = Pop();
+
+  JSArrayBuilder array_builder(this,
+      casted_stub()->elements_kind(),
+      GetParameter(ArrayConstructorStubBase::kPropertyCell));
+  HValue* size_in_bytes = array_builder.EstablishAllocationSize(capacity);
+  HValue* new_object = array_builder.AllocateArray(size_in_bytes,
+                                                   capacity,
+                                                   length,
+                                                   true);
+  return new_object;
+#endif
 }
 
 
 Handle<Code> ArraySingleArgumentConstructorStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<ArrayNArgumentsConstructorStub>::BuildCodeStub() {
+#ifdef NARG_DEOPT
   HInstruction* deopt = new(zone()) HSoftDeoptimize();
   AddInstruction(deopt);
   current_block()->MarkAsDeoptimizing();
   return GetParameter(0);
+#else
+  ElementsKind kind = casted_stub()->elements_kind();
+  HValue* length = GetArgumentsLength();
+
+  JSArrayBuilder array_builder(this,
+      kind,
+      GetParameter(ArrayConstructorStubBase::kPropertyCell));
+
+  HValue* total_size = array_builder.EstablishAllocationSize(length);
+  // We need to fill with the hole if it's a smi array in the multi-argument
+  // case because we might have to bail out while copying arguments into
+  // the array because they aren't compatible with a smi array.
+  // If it's a double array, no problem, and if it's fast then no
+  // problem either because doubles are boxed.
+  bool fill_with_hole = IsFastSmiElementsKind(kind);
+  HValue* new_object = array_builder.AllocateArray(total_size,
+                                                   length,
+                                                   length,
+                                                   fill_with_hole);
+  HValue* elements = array_builder.GetElementsLocation();
+  ASSERT(elements != NULL);
+
+  // Now populate the elements correctly.
+  LoopBuilder builder(this,
+                      context(),
+                      LoopBuilder::kPostIncrement);
+  HValue* start = graph()->GetConstant0();
+  HValue* key = builder.BeginBody(start, length, Token::LT);
+  HInstruction* argument_elements = AddInstruction(
+      new(zone()) HArgumentsElements(false));
+  HInstruction* argument = AddInstruction(new(zone()) HAccessArgumentsAt(
+      argument_elements, length, key));
+
+  // Checks to prevent incompatible stores
+  if (IsFastSmiElementsKind(kind)) {
+    AddInstruction(new(zone()) HCheckSmi(argument));
+  }
+
+  AddInstruction(new(zone()) HStoreKeyed(elements, key, argument, kind));
+  AddSimulate(BailoutId::StubEntry(), REMOVABLE_SIMULATE);
+  builder.EndBody();
+  return new_object;
+#endif
 }
 
 
 Handle<Code> ArrayNArgumentsConstructorStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 } }  // namespace v8::internal