Implement KeyedStoreICs to grow arrays on out-of-bound stores.

src/code-stubs.h

-// Copyright 2011 the V8 project authors. All rights reserved.
+// 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
 //       with the distribution.
@@ skipping 966 matching lines @@
  private:
   ElementsKind elements_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyedLoadElementStub);
 };
 
 
 class KeyedStoreElementStub : public CodeStub {
  public:
   KeyedStoreElementStub(bool is_js_array,
-                        ElementsKind elements_kind)
+                        ElementsKind elements_kind,
+                        KeyedAccessGrowMode grow_mode)
     : is_js_array_(is_js_array),

[Jakob Kummerow, 2012/02/09 14:51:25]

nit: 4-space indent

[danno, 2012/02/10 12:25:34]

Done.

-    elements_kind_(elements_kind) { }
+      elements_kind_(elements_kind),
+      grow_mode_(grow_mode) { }
 
   Major MajorKey() { return KeyedStoreElement; }
   int MinorKey() {
-    return (is_js_array_ ? 0 : kElementsKindCount) + elements_kind_;
+    int multiplier = is_js_array_ ? 1 : 0;

[Vyacheslav Egorov (Chromium), 2012/02/10 00:19:18]

is there any particular reason why you don't want to use BitField's here? I
think it would be much more readable.

[danno, 2012/02/10 12:25:34]

Done.

+    multiplier += (grow_mode_ == ALLOW_JSARRAY_GROWTH) ? 2 : 0;
+    return (multiplier * kElementsKindCount) + elements_kind_;
   }
 
   void Generate(MacroAssembler* masm);
 
  private:
   bool is_js_array_;
   ElementsKind elements_kind_;
+  KeyedAccessGrowMode grow_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyedStoreElementStub);
 };
 
 
 class ToBooleanStub: public CodeStub {
  public:
   enum Type {
     UNDEFINED,
     BOOLEAN,
@@ skipping 57 matching lines @@
   Register tos_;
   Types types_;
 };
 
 
 class ElementsTransitionAndStoreStub : public CodeStub {
  public:
   ElementsTransitionAndStoreStub(ElementsKind from,
                                  ElementsKind to,
                                  bool is_jsarray,
-                                 StrictModeFlag strict_mode)
+                                 StrictModeFlag strict_mode,
+                                 KeyedAccessGrowMode grow_mode)
       : from_(from),
         to_(to),
         is_jsarray_(is_jsarray),
-        strict_mode_(strict_mode) {}
+        strict_mode_(strict_mode),
+        grow_mode_(grow_mode) {}
 
  private:
   class FromBits:       public BitField<ElementsKind,    0, 8> {};
   class ToBits:         public BitField<ElementsKind,    8, 8> {};
   class IsJSArrayBits:  public BitField<bool,           16, 8> {};
   class StrictModeBits: public BitField<StrictModeFlag, 24, 8> {};
 
   Major MajorKey() { return ElementsTransitionAndStore; }
   int MinorKey() {
     return FromBits::encode(from_) |
         ToBits::encode(to_) |
         IsJSArrayBits::encode(is_jsarray_) |
         StrictModeBits::encode(strict_mode_);

[Vyacheslav Egorov (Chromium), 2012/02/10 00:19:18]

i think grow_mode_ should be embedded into MinorKey.

[danno, 2012/02/10 12:25:34]

Done.

   }
 
   void Generate(MacroAssembler* masm);
 
   ElementsKind from_;
   ElementsKind to_;
   bool is_jsarray_;
   StrictModeFlag strict_mode_;
+  KeyedAccessGrowMode grow_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(ElementsTransitionAndStoreStub);
 };
 
 
 class StoreArrayLiteralElementStub : public CodeStub {
  public:
   explicit StoreArrayLiteralElementStub() {}
 
  private:
   Major MajorKey() { return StoreArrayLiteralElement; }
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
 
   DISALLOW_COPY_AND_ASSIGN(StoreArrayLiteralElementStub);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_