Hydrogen stubs for array constructors

src/x64/lithium-x64.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 2115 matching lines @@
 
     if (instr->value()->representation().IsDouble()) {
       object = UseRegisterAtStart(instr->elements());
       val = UseTempRegister(instr->value());
       key = clobbers_key ? UseTempRegister(instr->key())
           : UseRegisterOrConstantAtStart(instr->key());
     } else {
       ASSERT(instr->value()->representation().IsTagged());
       object = UseTempRegister(instr->elements());
       val = needs_write_barrier ? UseTempRegister(instr->value())
-          : UseRegisterAtStart(instr->value());
+          : UseRegisterOrConstantAtStart(instr->value());
       key = (clobbers_key || needs_write_barrier)
           ? UseTempRegister(instr->key())
           : UseRegisterOrConstantAtStart(instr->key());
     }
 
     return new(zone()) LStoreKeyed(object, key, val);
   }
 
   ASSERT(
       (instr->value()->representation().IsInteger32() &&
@@ skipping 76 matching lines @@
   if (needs_write_barrier) {
     obj = instr->is_in_object()
         ? UseRegister(instr->object())
         : UseTempRegister(instr->object());
   } else {
     obj = needs_write_barrier_for_map
         ? UseRegister(instr->object())
         : UseRegisterAtStart(instr->object());
   }
 
-  LOperand* val = needs_write_barrier
-      ? UseTempRegister(instr->value())
-      : UseRegister(instr->value());
+  LOperand* val = NULL;
+  if (needs_write_barrier) {
+    val = UseTempRegister(instr->value());
+  } else if (instr->value()->IsConstant()) {
+    // If it's tagged, it might still be in new space
+    HConstant* constant_value = HConstant::cast(instr->value());
+    if (constant_value->HasInteger32Value() ||
+        constant_value->HasDoubleValue() ||
+        constant_value->ImmortalImmovable()) {
+      val = UseRegisterOrConstant(instr->value());
+    }
+  }
+
+  if (val == NULL) {
+    val = UseRegister(instr->value());
+  }
 
   // We only need a scratch register if we have a write barrier or we
   // have a store into the properties array (not in-object-property).
   LOperand* temp = (!instr->is_in_object() || needs_write_barrier ||
       needs_write_barrier_for_map) ? TempRegister() : NULL;
 
   return new(zone()) LStoreNamedField(obj, val, temp);
 }
 
 
@@ skipping 89 matching lines @@
 
 LInstruction* LChunkBuilder::DoParameter(HParameter* instr) {
   LParameter* result = new(zone()) LParameter;
   if (instr->kind() == HParameter::STACK_PARAMETER) {
     int spill_index = chunk()->GetParameterStackSlot(instr->index());
     return DefineAsSpilled(result, spill_index);
   } else {
     ASSERT(info()->IsStub());
     CodeStubInterfaceDescriptor* descriptor =
         info()->code_stub()->GetInterfaceDescriptor(info()->isolate());
-    Register reg = descriptor->register_params_[instr->index()];
+    Register reg;
+    if (static_cast<int>(instr->index()) == descriptor->register_param_count_) {
+      reg = *(descriptor->stack_parameter_count_);
+    } else {
+      reg = descriptor->register_params_[instr->index()];
+    }
     return DefineFixed(result, reg);
   }
 }
 
 
 LInstruction* LChunkBuilder::DoUnknownOSRValue(HUnknownOSRValue* instr) {
   int spill_index = chunk()->GetNextSpillIndex(false);  // Not double-width.
   if (spill_index > LUnallocated::kMaxFixedIndex) {
     Abort("Too many spill slots needed for OSR");
     spill_index = 0;
@@ skipping 12 matching lines @@
   // There are no real uses of the arguments object.
   // arguments.length and element access are supported directly on
   // stack arguments, and any real arguments object use causes a bailout.
   // So this value is never used.
   return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoAccessArgumentsAt(HAccessArgumentsAt* instr) {
   LOperand* args = UseRegister(instr->arguments());
-  LOperand* length = UseTempRegister(instr->length());
-  LOperand* index = Use(instr->index());
+  LOperand* length;
+  LOperand* index;
+  if (instr->length()->IsConstant() && instr->index()->IsConstant()) {
+    length = UseRegisterOrConstant(instr->length());
+    index = UseOrConstant(instr->index());
+  } else {
+    length = UseTempRegister(instr->length());
+    index = Use(instr->index());
+  }
   return DefineAsRegister(new(zone()) LAccessArgumentsAt(args, length, index));
 }
 
 
 LInstruction* LChunkBuilder::DoToFastProperties(HToFastProperties* instr) {
   LOperand* object = UseFixed(instr->value(), rax);
   LToFastProperties* result = new(zone()) LToFastProperties(object);
   return MarkAsCall(DefineFixed(result, rax), instr);
 }
 
@@ skipping 130 matching lines @@
 LInstruction* LChunkBuilder::DoLoadFieldByIndex(HLoadFieldByIndex* instr) {
   LOperand* object = UseRegister(instr->object());
   LOperand* index = UseTempRegister(instr->index());
   return DefineSameAsFirst(new(zone()) LLoadFieldByIndex(object, index));
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64