Consolidated all the key store/load classes in the Hydrogen and Lithium

src/mips/lithium-codegen-mips.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 2604 matching lines @@
   // There are two words between the frame pointer and the last argument.
   // Subtracting from length accounts for one of them, add one more.
   __ subu(length, length, index);
   __ Addu(length, length, Operand(1));
   __ sll(length, length, kPointerSizeLog2);
   __ Addu(at, arguments, Operand(length));
   __ lw(result, MemOperand(at, 0));
 }
 
 
-void LCodeGen::DoLoadKeyedFastElement(LLoadKeyedFastElement* instr) {
-  Register elements = ToRegister(instr->elements());
-  Register result = ToRegister(instr->result());
-  Register scratch = scratch0();
-  Register store_base = scratch;
-  int offset = 0;
-
-  if (instr->key()->IsConstantOperand()) {
-    LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
-    offset = FixedArray::OffsetOfElementAt(ToInteger32(const_operand) +
-                                           instr->additional_index());
-    store_base = elements;
-  } else {
-    Register key = EmitLoadRegister(instr->key(), scratch);
-    // Even though the HLoadKeyedFastElement instruction forces the input
-    // representation for the key to be an integer, the input gets replaced
-    // during bound check elimination with the index argument to the bounds
-    // check, which can be tagged, so that case must be handled here, too.
-    if (instr->hydrogen()->key()->representation().IsTagged()) {
-      __ sll(scratch, key, kPointerSizeLog2 - kSmiTagSize);
-      __ addu(scratch, elements, scratch);
-    } else {
-      __ sll(scratch, key, kPointerSizeLog2);
-      __ addu(scratch, elements, scratch);
-    }
-    offset = FixedArray::OffsetOfElementAt(instr->additional_index());
-  }
-  __ lw(result, FieldMemOperand(store_base, offset));
-
-  // Check for the hole value.
-  if (instr->hydrogen()->RequiresHoleCheck()) {
-    if (IsFastSmiElementsKind(instr->hydrogen()->elements_kind())) {
-      __ And(scratch, result, Operand(kSmiTagMask));
-      DeoptimizeIf(ne, instr->environment(), scratch, Operand(zero_reg));
-    } else {
-      __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
-      DeoptimizeIf(eq, instr->environment(), result, Operand(scratch));
-    }
-  }
-}
-
-
-void LCodeGen::DoLoadKeyedFastDoubleElement(
-    LLoadKeyedFastDoubleElement* instr) {
-  Register elements = ToRegister(instr->elements());
-  bool key_is_constant = instr->key()->IsConstantOperand();
-  Register key = no_reg;
-  DoubleRegister result = ToDoubleRegister(instr->result());
-  Register scratch = scratch0();
-
-  int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
-  int shift_size = (instr->hydrogen()->key()->representation().IsTagged())
-      ? (element_size_shift - kSmiTagSize) : element_size_shift;
-  int constant_key = 0;
-  if (key_is_constant) {
-    constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
-    if (constant_key & 0xF0000000) {
-      Abort("array index constant value too big.");
-    }
-  } else {
-    key = ToRegister(instr->key());
-  }
-
-  if (key_is_constant) {
-    __ Addu(elements, elements,
-        Operand(((constant_key + instr->additional_index()) <<
-                 element_size_shift) +
-                FixedDoubleArray::kHeaderSize - kHeapObjectTag));
-  } else {
-    __ sll(scratch, key, shift_size);
-    __ Addu(elements, elements, Operand(scratch));
-    __ Addu(elements, elements,
-            Operand((FixedDoubleArray::kHeaderSize - kHeapObjectTag) +
-                    (instr->additional_index() << element_size_shift)));
-  }
-
-  if (instr->hydrogen()->RequiresHoleCheck()) {
-    __ lw(scratch, MemOperand(elements, sizeof(kHoleNanLower32)));
-    DeoptimizeIf(eq, instr->environment(), scratch, Operand(kHoleNanUpper32));
-  }
-
-  __ ldc1(result, MemOperand(elements));
-}
-
-
-MemOperand LCodeGen::PrepareKeyedOperand(Register key,
-                                         Register base,
-                                         bool key_is_constant,
-                                         int constant_key,
-                                         int element_size,
-                                         int shift_size,
-                                         int additional_index,
-                                         int additional_offset) {
-  if (additional_index != 0 && !key_is_constant) {
-    additional_index *= 1 << (element_size - shift_size);
-    __ Addu(scratch0(), key, Operand(additional_index));
-  }
-
-  if (key_is_constant) {
-    return MemOperand(base,
-                      (constant_key << element_size) + additional_offset);
-  }
-
-  if (additional_index == 0) {
-    if (shift_size >= 0) {
-      __ sll(scratch0(), key, shift_size);
-      __ Addu(scratch0(), base, scratch0());
-      return MemOperand(scratch0());
-    } else {
-      ASSERT_EQ(-1, shift_size);
-      __ srl(scratch0(), key, 1);
-      __ Addu(scratch0(), base, scratch0());
-      return MemOperand(scratch0());
-    }
-  }
-
-  if (shift_size >= 0) {
-    __ sll(scratch0(), scratch0(), shift_size);
-    __ Addu(scratch0(), base, scratch0());
-    return MemOperand(scratch0());
-  } else {
-    ASSERT_EQ(-1, shift_size);
-    __ srl(scratch0(), scratch0(), 1);
-    __ Addu(scratch0(), base, scratch0());
-    return MemOperand(scratch0());
-  }
-}
-
-
-void LCodeGen::DoLoadKeyedSpecializedArrayElement(
-    LLoadKeyedSpecializedArrayElement* instr) {
+void LCodeGen::DoLoadKeyedExternal(LLoadKeyed* instr) {
   Register external_pointer = ToRegister(instr->external_pointer());
   Register key = no_reg;
   ElementsKind elements_kind = instr->elements_kind();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int constant_key = 0;
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort("array index constant value too big.");
     }
   } else {
     key = ToRegister(instr->key());
   }
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
   int shift_size = (instr->hydrogen()->key()->representation().IsTagged())
       ? (element_size_shift - kSmiTagSize) : element_size_shift;
   int additional_offset = instr->additional_index() << element_size_shift;
 
   if (elements_kind == EXTERNAL_FLOAT_ELEMENTS ||
       elements_kind == EXTERNAL_DOUBLE_ELEMENTS) {
     FPURegister result = ToDoubleRegister(instr->result());
     if (key_is_constant) {
-      __ Addu(scratch0(), external_pointer, constant_key << element_size_shift);
+      __ Addu(scratch0(), external_pointer,
+              constant_key << element_size_shift);
     } else {
       __ sll(scratch0(), key, shift_size);
       __ Addu(scratch0(), scratch0(), external_pointer);
     }
 
     if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) {
       __ lwc1(result, MemOperand(scratch0(), additional_offset));
       __ cvt_d_s(result, result);
     } else  {  // i.e. elements_kind == EXTERNAL_DOUBLE_ELEMENTS
       __ ldc1(result, MemOperand(scratch0(), additional_offset));
@@ skipping 18 matching lines @@
       case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
         __ lhu(result, mem_operand);
         break;
       case EXTERNAL_INT_ELEMENTS:
         __ lw(result, mem_operand);
         break;
       case EXTERNAL_UNSIGNED_INT_ELEMENTS:
         __ lw(result, mem_operand);
         if (!instr->hydrogen()->CheckFlag(HInstruction::kUint32)) {
           DeoptimizeIf(Ugreater_equal, instr->environment(),
-              result, Operand(0x80000000));
+                       result, Operand(0x80000000));
         }
         break;
       case EXTERNAL_FLOAT_ELEMENTS:
       case EXTERNAL_DOUBLE_ELEMENTS:
       case FAST_DOUBLE_ELEMENTS:
       case FAST_ELEMENTS:
       case FAST_SMI_ELEMENTS:
       case FAST_HOLEY_DOUBLE_ELEMENTS:
       case FAST_HOLEY_ELEMENTS:
       case FAST_HOLEY_SMI_ELEMENTS:
       case DICTIONARY_ELEMENTS:
       case NON_STRICT_ARGUMENTS_ELEMENTS:
         UNREACHABLE();
         break;
     }
   }
 }
 
+void LCodeGen::DoLoadKeyed(LLoadKeyed* instr) {
+  if (instr->is_external()) {
+    DoLoadKeyedExternal(instr);
+  } else if (instr->hydrogen()->representation().IsDouble()) {
+    Register elements = ToRegister(instr->elements());
+    bool key_is_constant = instr->key()->IsConstantOperand();
+    Register key = no_reg;
+    DoubleRegister result = ToDoubleRegister(instr->result());
+    Register scratch = scratch0();
+
+    int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
+    int shift_size = (instr->hydrogen()->key()->representation().IsTagged())
+        ? (element_size_shift - kSmiTagSize) : element_size_shift;
+    int constant_key = 0;
+    if (key_is_constant) {
+      constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
+      if (constant_key & 0xF0000000) {
+        Abort("array index constant value too big.");
+      }
+    } else {
+      key = ToRegister(instr->key());
+    }
+
+    if (key_is_constant) {
+      __ Addu(elements, elements,
+              Operand(((constant_key + instr->additional_index()) <<
+                       element_size_shift) +
+                      FixedDoubleArray::kHeaderSize - kHeapObjectTag));
+    } else {
+      __ sll(scratch, key, shift_size);
+      __ Addu(elements, elements, Operand(scratch));
+      __ Addu(elements, elements,
+              Operand((FixedDoubleArray::kHeaderSize - kHeapObjectTag) +
+                      (instr->additional_index() << element_size_shift)));
+    }
+
+    if (instr->hydrogen()->RequiresHoleCheck()) {
+      __ lw(scratch, MemOperand(elements, sizeof(kHoleNanLower32)));
+      DeoptimizeIf(eq, instr->environment(), scratch, Operand(kHoleNanUpper32));
+    }
+
+    __ ldc1(result, MemOperand(elements));
+  } else {
+    Register elements = ToRegister(instr->elements());
+    Register result = ToRegister(instr->result());
+    Register scratch = scratch0();
+    Register store_base = scratch;
+    int offset = 0;
+
+    if (instr->key()->IsConstantOperand()) {
+      LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
+      offset = FixedArray::OffsetOfElementAt(ToInteger32(const_operand) +
+                                             instr->additional_index());
+      store_base = elements;
+    } else {
+      Register key = EmitLoadRegister(instr->key(), scratch);
+      // Even though the HLoadKeyed instruction forces the input
+      // representation for the key to be an integer, the input gets replaced
+      // during bound check elimination with the index argument to the bounds
+      // check, which can be tagged, so that case must be handled here, too.
+      if (instr->hydrogen()->key()->representation().IsTagged()) {
+        __ sll(scratch, key, kPointerSizeLog2 - kSmiTagSize);
+        __ addu(scratch, elements, scratch);
+      } else {
+        __ sll(scratch, key, kPointerSizeLog2);
+        __ addu(scratch, elements, scratch);
+      }
+      offset = FixedArray::OffsetOfElementAt(instr->additional_index());
+    }
+    __ lw(result, FieldMemOperand(store_base, offset));
+
+    // Check for the hole value.
+    if (instr->hydrogen()->RequiresHoleCheck()) {
+      if (IsFastSmiElementsKind(instr->hydrogen()->elements_kind())) {
+        __ And(scratch, result, Operand(kSmiTagMask));
+        DeoptimizeIf(ne, instr->environment(), scratch, Operand(zero_reg));
+      } else {
+        __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
+        DeoptimizeIf(eq, instr->environment(), result, Operand(scratch));
+      }
+    }
+  }
+}
+
+
+MemOperand LCodeGen::PrepareKeyedOperand(Register key,
+                                         Register base,
+                                         bool key_is_constant,
+                                         int constant_key,
+                                         int element_size,
+                                         int shift_size,
+                                         int additional_index,
+                                         int additional_offset) {
+  if (additional_index != 0 && !key_is_constant) {
+    additional_index *= 1 << (element_size - shift_size);
+    __ Addu(scratch0(), key, Operand(additional_index));
+  }
+
+  if (key_is_constant) {
+    return MemOperand(base,
+                      (constant_key << element_size) + additional_offset);
+  }
+
+  if (additional_index == 0) {
+    if (shift_size >= 0) {
+      __ sll(scratch0(), key, shift_size);
+      __ Addu(scratch0(), base, scratch0());
+      return MemOperand(scratch0());
+    } else {
+      ASSERT_EQ(-1, shift_size);
+      __ srl(scratch0(), key, 1);
+      __ Addu(scratch0(), base, scratch0());
+      return MemOperand(scratch0());
+    }
+  }
+
+  if (shift_size >= 0) {
+    __ sll(scratch0(), scratch0(), shift_size);
+    __ Addu(scratch0(), base, scratch0());
+    return MemOperand(scratch0());
+  } else {
+    ASSERT_EQ(-1, shift_size);
+    __ srl(scratch0(), scratch0(), 1);
+    __ Addu(scratch0(), base, scratch0());
+    return MemOperand(scratch0());
+  }
+}
+
 
 void LCodeGen::DoLoadKeyedGeneric(LLoadKeyedGeneric* instr) {
   ASSERT(ToRegister(instr->object()).is(a1));
   ASSERT(ToRegister(instr->key()).is(a0));
 
   Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Initialize();
   CallCode(ic, RelocInfo::CODE_TARGET, instr);
 }
 
 
@@ skipping 884 matching lines @@
                  Operand(ToRegister(instr->length())));
   } else {
     DeoptimizeIf(hs,
                  instr->environment(),
                  ToRegister(instr->index()),
                  Operand(ToRegister(instr->length())));
   }
 }
 
 
-void LCodeGen::DoStoreKeyedFastElement(LStoreKeyedFastElement* instr) {
-  Register value = ToRegister(instr->value());
-  Register elements = ToRegister(instr->object());
-  Register key = instr->key()->IsRegister() ? ToRegister(instr->key()) : no_reg;
-  Register scratch = scratch0();
-  Register store_base = scratch;
-  int offset = 0;
-
-  // Do the store.
-  if (instr->key()->IsConstantOperand()) {
-    ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
-    LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
-    offset = FixedArray::OffsetOfElementAt(ToInteger32(const_operand) +
-                                           instr->additional_index());
-    store_base = elements;
-  } else {
-    // Even though the HLoadKeyedFastElement instruction forces the input
-    // representation for the key to be an integer, the input gets replaced
-    // during bound check elimination with the index argument to the bounds
-    // check, which can be tagged, so that case must be handled here, too.
-    if (instr->hydrogen()->key()->representation().IsTagged()) {
-      __ sll(scratch, key, kPointerSizeLog2 - kSmiTagSize);
-      __ addu(scratch, elements, scratch);
-    } else {
-      __ sll(scratch, key, kPointerSizeLog2);
-      __ addu(scratch, elements, scratch);
-    }
-    offset = FixedArray::OffsetOfElementAt(instr->additional_index());
-  }
-  __ sw(value, FieldMemOperand(store_base, offset));
-
-  if (instr->hydrogen()->NeedsWriteBarrier()) {
-    HType type = instr->hydrogen()->value()->type();
-    SmiCheck check_needed =
-        type.IsHeapObject() ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
-    // Compute address of modified element and store it into key register.
-    __ Addu(key, store_base, Operand(offset - kHeapObjectTag));
-    __ RecordWrite(elements,
-                   key,
-                   value,
-                   kRAHasBeenSaved,
-                   kSaveFPRegs,
-                   EMIT_REMEMBERED_SET,
-                   check_needed);
-  }
-}
-
-
-void LCodeGen::DoStoreKeyedFastDoubleElement(
-    LStoreKeyedFastDoubleElement* instr) {
-  DoubleRegister value = ToDoubleRegister(instr->value());
-  Register elements = ToRegister(instr->elements());
-  Register key = no_reg;
-  Register scratch = scratch0();
-  bool key_is_constant = instr->key()->IsConstantOperand();
-  int constant_key = 0;
-  Label not_nan;
-
-  // Calculate the effective address of the slot in the array to store the
-  // double value.
-  if (key_is_constant) {
-    constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
-    if (constant_key & 0xF0000000) {
-      Abort("array index constant value too big.");
-    }
-  } else {
-    key = ToRegister(instr->key());
-  }
-  int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
-  int shift_size = (instr->hydrogen()->key()->representation().IsTagged())
-      ? (element_size_shift - kSmiTagSize) : element_size_shift;
-  if (key_is_constant) {
-    __ Addu(scratch, elements, Operand((constant_key << element_size_shift) +
-            FixedDoubleArray::kHeaderSize - kHeapObjectTag));
-  } else {
-    __ sll(scratch, key, shift_size);
-    __ Addu(scratch, elements, Operand(scratch));
-    __ Addu(scratch, scratch,
-            Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag));
-  }
-
-  if (instr->NeedsCanonicalization()) {
-    Label is_nan;
-    // Check for NaN. All NaNs must be canonicalized.
-    __ BranchF(NULL, &is_nan, eq, value, value);
-    __ Branch(&not_nan);
-
-    // Only load canonical NaN if the comparison above set the overflow.
-    __ bind(&is_nan);
-    __ Move(value, FixedDoubleArray::canonical_not_the_hole_nan_as_double());
-  }
-
-  __ bind(&not_nan);
-  __ sdc1(value, MemOperand(scratch, instr->additional_index() <<
-      element_size_shift));
-}
-
-
-void LCodeGen::DoStoreKeyedSpecializedArrayElement(
-    LStoreKeyedSpecializedArrayElement* instr) {
-
+void LCodeGen::DoStoreKeyedExternal(LStoreKeyed* instr) {
   Register external_pointer = ToRegister(instr->external_pointer());
   Register key = no_reg;
   ElementsKind elements_kind = instr->elements_kind();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int constant_key = 0;
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
       Abort("array index constant value too big.");
     }
   } else {
     key = ToRegister(instr->key());
   }
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
   int shift_size = (instr->hydrogen()->key()->representation().IsTagged())
       ? (element_size_shift - kSmiTagSize) : element_size_shift;
   int additional_offset = instr->additional_index() << element_size_shift;
 
   if (elements_kind == EXTERNAL_FLOAT_ELEMENTS ||
       elements_kind == EXTERNAL_DOUBLE_ELEMENTS) {
     FPURegister value(ToDoubleRegister(instr->value()));
     if (key_is_constant) {
       __ Addu(scratch0(), external_pointer, constant_key <<
-          element_size_shift);
+              element_size_shift);
     } else {
       __ sll(scratch0(), key, shift_size);
       __ Addu(scratch0(), scratch0(), external_pointer);
     }
 
     if (elements_kind == EXTERNAL_FLOAT_ELEMENTS) {
       __ cvt_s_d(double_scratch0(), value);
       __ swc1(double_scratch0(), MemOperand(scratch0(), additional_offset));
     } else {  // i.e. elements_kind == EXTERNAL_DOUBLE_ELEMENTS
       __ sdc1(value, MemOperand(scratch0(), additional_offset));
@@ skipping 27 matching lines @@
       case FAST_HOLEY_ELEMENTS:
       case FAST_HOLEY_SMI_ELEMENTS:
       case DICTIONARY_ELEMENTS:
       case NON_STRICT_ARGUMENTS_ELEMENTS:
         UNREACHABLE();
         break;
     }
   }
 }
 
+void LCodeGen::DoStoreKeyed(LStoreKeyed* instr) {
+  // By cases: external, fast double, fast
+  if (instr->is_external()) {
+    DoStoreKeyedEternal(instr);
+  } else if (instr->hydrogen()->value()->representation().IsDouble()) {
+    DoubleRegister value = ToDoubleRegister(instr->value());
+    Register elements = ToRegister(instr->elements());
+    Register key = no_reg;
+    Register scratch = scratch0();
+    bool key_is_constant = instr->key()->IsConstantOperand();
+    int constant_key = 0;
+    Label not_nan;
+
+    // Calculate the effective address of the slot in the array to store the
+    // double value.
+    if (key_is_constant) {
+      constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
+      if (constant_key & 0xF0000000) {
+        Abort("array index constant value too big.");
+      }
+    } else {
+      key = ToRegister(instr->key());
+    }
+    int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
+    int shift_size = (instr->hydrogen()->key()->representation().IsTagged())
+        ? (element_size_shift - kSmiTagSize) : element_size_shift;
+    if (key_is_constant) {
+      __ Addu(scratch, elements,
+              Operand((constant_key << element_size_shift) +
+                      FixedDoubleArray::kHeaderSize - kHeapObjectTag));
+    } else {
+      __ sll(scratch, key, shift_size);
+      __ Addu(scratch, elements, Operand(scratch));
+      __ Addu(scratch, scratch,
+              Operand(FixedDoubleArray::kHeaderSize - kHeapObjectTag));
+    }
+
+    if (instr->NeedsCanonicalization()) {
+      Label is_nan;
+      // Check for NaN. All NaNs must be canonicalized.
+      __ BranchF(NULL, &is_nan, eq, value, value);
+      __ Branch(&not_nan);
+
+      // Only load canonical NaN if the comparison above set the overflow.
+      __ bind(&is_nan);
+      __ Move(value, FixedDoubleArray::canonical_not_the_hole_nan_as_double());
+    }
+
+    __ bind(&not_nan);
+    __ sdc1(value, MemOperand(scratch, instr->additional_index() <<
+                              element_size_shift));
+  } else {
+    Register value = ToRegister(instr->value());
+    Register elements = ToRegister(instr->object());
+    Register key = instr->key()->IsRegister() ? ToRegister(instr->key())
+                                              : no_reg;
+    Register scratch = scratch0();
+    Register store_base = scratch;
+    int offset = 0;
+
+    // Do the store.
+    if (instr->key()->IsConstantOperand()) {
+      ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
+      LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
+      offset = FixedArray::OffsetOfElementAt(ToInteger32(const_operand) +
+                                             instr->additional_index());
+      store_base = elements;
+    } else {
+      // Even though the HLoadKeyed instruction forces the input
+      // representation for the key to be an integer, the input gets replaced
+      // during bound check elimination with the index argument to the bounds
+      // check, which can be tagged, so that case must be handled here, too.
+      if (instr->hydrogen()->key()->representation().IsTagged()) {
+        __ sll(scratch, key, kPointerSizeLog2 - kSmiTagSize);
+        __ addu(scratch, elements, scratch);
+      } else {
+        __ sll(scratch, key, kPointerSizeLog2);
+        __ addu(scratch, elements, scratch);
+      }
+      offset = FixedArray::OffsetOfElementAt(instr->additional_index());
+    }
+    __ sw(value, FieldMemOperand(store_base, offset));
+
+    if (instr->hydrogen()->NeedsWriteBarrier()) {
+      HType type = instr->hydrogen()->value()->type();
+      SmiCheck check_needed =
+          type.IsHeapObject() ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
+      // Compute address of modified element and store it into key register.
+      __ Addu(key, store_base, Operand(offset - kHeapObjectTag));
+      __ RecordWrite(elements,
+                     key,
+                     value,
+                     kRAHasBeenSaved,
+                     kSaveFPRegs,
+                     EMIT_REMEMBERED_SET,
+                     check_needed);
+    }
+  }
+}
+
+
 void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
   ASSERT(ToRegister(instr->object()).is(a2));
   ASSERT(ToRegister(instr->key()).is(a1));
   ASSERT(ToRegister(instr->value()).is(a0));
 
   Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode)
       ? isolate()->builtins()->KeyedStoreIC_Initialize_Strict()
       : isolate()->builtins()->KeyedStoreIC_Initialize();
   CallCode(ic, RelocInfo::CODE_TARGET, instr);
 }
@@ skipping 1517 matching lines @@
   __ Subu(scratch, result, scratch);
   __ lw(result, FieldMemOperand(scratch,
                                 FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal