Better support for 'polymorphic' JS and external arrays

src/code-stubs.h

 // 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 48 matching lines @@
   V(RevertToNumber)                      \
   V(ToBoolean)                           \
   V(ToNumber)                            \
   V(CounterOp)                           \
   V(ArgumentsAccess)                     \
   V(RegExpExec)                          \
   V(RegExpConstructResult)               \
   V(NumberToString)                      \
   V(CEntry)                              \
   V(JSEntry)                             \
+  V(ObjectKeyedLoad)                     \
+  V(JSArrayKeyedLoad)                    \
+  V(ObjectKeyedStore)                    \
+  V(JSArrayKeyedStore)                   \
+  V(ExternalByteArrayLoad)               \
+  V(ExternalUnsignedByteArrayLoad)       \
+  V(ExternalShortArrayLoad)              \
+  V(ExternalUnsignedShortArrayLoad)      \
+  V(ExternalIntArrayLoad)                \
+  V(ExternalUnsignedIntArrayLoad)        \
+  V(ExternalFloatArrayLoad)              \
+  V(ExternalDoubleArrayLoad)             \
+  V(ExternalPixelArrayLoad)              \
+  V(ExternalByteArrayStore)              \
+  V(ExternalUnsignedByteArrayStore)      \
+  V(ExternalShortArrayStore)             \
+  V(ExternalUnsignedShortArrayStore)     \
+  V(ExternalIntArrayStore)               \
+  V(ExternalUnsignedIntArrayStore)       \
+  V(ExternalFloatArrayStore)             \
+  V(ExternalDoubleArrayStore)            \
+  V(ExternalPixelArrayStore)             \
   V(DebuggerStatement)                   \
   V(StringDictionaryNegativeLookup)
 
 // List of code stubs only used on ARM platforms.
 #ifdef V8_TARGET_ARCH_ARM
 #define CODE_STUB_LIST_ARM(V)  \
   V(GetProperty)               \
   V(SetProperty)               \
   V(InvokeBuiltin)             \
   V(RegExpCEntry)              \
@@ skipping 835 matching lines @@
     masm_->set_allow_stub_calls(previous_allow_);
   }
 
  private:
   MacroAssembler* masm_;
   bool previous_allow_;
 
   DISALLOW_COPY_AND_ASSIGN(AllowStubCallsScope);
 };
 
+#ifdef DEBUG
+#define DECLARE_ARRAY_STUB_PRINT(name) void Print() { PrintF(#name); }
+#else
+#define DECLARE_ARRAY_STUB_PRINT(name)
+#endif
+
+
+class KeyedLoadStub : public CodeStub {
+ public:
+  explicit KeyedLoadStub(bool is_js_array)
+      : is_js_array_(is_js_array) {
+  }
+
+  void Generate(MacroAssembler* masm);
+ private:
+  bool is_js_array_;
+};
+
+
+class ObjectKeyedLoadStub: public KeyedLoadStub {
+ public:
+  ObjectKeyedLoadStub() : KeyedLoadStub(false) { }
+
+ private:
+  Major MajorKey() { return ObjectKeyedLoad; }
+  int MinorKey() { return 0; }
+
+  const char* GetName() { return "ObjectKeyedLoadStub"; }
+
+  DECLARE_ARRAY_STUB_PRINT(ObjectKeyedLoadStub)
+};
+
+
+class JSArrayKeyedLoadStub: public KeyedLoadStub {
+ public:
+  JSArrayKeyedLoadStub() : KeyedLoadStub(true) { }
+
+ private:
+  Major MajorKey() { return JSArrayKeyedLoad; }
+  int MinorKey() { return 0; }
+
+  const char* GetName() { return "JSArrayKeyedLoadStub"; }
+
+  DECLARE_ARRAY_STUB_PRINT(JSArrayKeyedLoadStub)
+};
+
+
+class KeyedStoreStub : public CodeStub {

[Mads Ager (chromium), 2011/05/10 13:38:06]

Why not just have this one and have a minor key for Object and one for Array?
They share code generation.

[danno, 2011/05/11 14:20:19]

Yes, that's a really good idea. Should have thought of it myself. Done.
On 2011/05/10 13:38:06, Mads Ager wrote:

+ public:
+  explicit KeyedStoreStub(bool is_js_array)
+      : is_js_array_(is_js_array) { }
+
+  void Generate(MacroAssembler* masm);
+ private:
+  bool is_js_array_;
+};
+
+
+class ObjectKeyedStoreStub: public KeyedStoreStub {
+ public:
+  ObjectKeyedStoreStub() : KeyedStoreStub(false) { }
+
+ private:
+  Major MajorKey() { return ObjectKeyedStore; }
+  int MinorKey() { return 0; }
+
+  const char* GetName() { return "ObjectKeyedStoreStub"; }
+
+  DECLARE_ARRAY_STUB_PRINT(ObjectKeyedStoreStub)
+};
+
+
+class JSArrayKeyedStoreStub: public KeyedStoreStub {
+ public:
+  JSArrayKeyedStoreStub() : KeyedStoreStub(true) { }
+
+ private:
+  Major MajorKey() { return JSArrayKeyedStore; }
+  int MinorKey() { return 0; }
+
+  const char* GetName() { return "JSArrayKeyedStoreStub"; }
+
+  DECLARE_ARRAY_STUB_PRINT(JSArrayKeyedStoreStub)
+};
+
+
+class ExternalArrayStub : public CodeStub {
+ public:
+  explicit ExternalArrayStub(ExternalArrayType array_type)
+      : array_type_(array_type) { }
+
+  Major MajorKey() {

[Mads Ager (chromium), 2011/05/10 13:38:06]

Just don't implement Major and Minor key?

[danno, 2011/05/11 14:20:19]

Done.

+    UNREACHABLE();
+    return static_cast<Major>(0);
+  }
+  int MinorKey() {
+    UNREACHABLE();
+    return 0;
+  }
+
+ protected:
+  ExternalArrayType array_type_;
+};
+
+
+class ExternalArrayLoadStub : public ExternalArrayStub {
+ public:
+  explicit ExternalArrayLoadStub(ExternalArrayType array_type)
+      : ExternalArrayStub(array_type) { }
+
+  void Generate(MacroAssembler* masm);
+};
+
+
+class ExternalArrayStoreStub : public ExternalArrayStub {
+ public:
+  explicit ExternalArrayStoreStub(ExternalArrayType array_type)
+      : ExternalArrayStub(array_type) { }
+
+  void Generate(MacroAssembler* masm);
+};
+
+
+#define DECLARE_EXTERNAL_ARRAY_STUB(op, type)                           \

[Mads Ager (chromium), 2011/05/10 13:38:06]

Do you really need all of these different types here. They share code
generation, right? So, why not just have ExternalArrayLoadStub with a minor key
that is the type (byte, unsigned, ...)?

[danno, 2011/05/11 14:20:19]

Done.

+class External##type##Array##op##Stub : public ExternalArray##op##Stub {\
+  public:                                                               \
+  External##type##Array##op##Stub()                                     \
+      : ExternalArray##op##Stub(k##External##type##Array) { }           \
+                                                                        \
+  private:                                                              \
+  Major MajorKey() { return External##type##Array##op; }                \
+  int MinorKey() { return 0; }                                          \
+                                                                        \
+  const char* GetName() { return "External" #type "Array" #op; }        \
+                                                                        \
+  DECLARE_ARRAY_STUB_PRINT(External##type##Array##op##Stub)             \
+}
+
+
+DECLARE_EXTERNAL_ARRAY_STUB(Load, Byte);
+DECLARE_EXTERNAL_ARRAY_STUB(Load, UnsignedByte);
+DECLARE_EXTERNAL_ARRAY_STUB(Load, Short);
+DECLARE_EXTERNAL_ARRAY_STUB(Load, UnsignedShort);
+DECLARE_EXTERNAL_ARRAY_STUB(Load, Int);
+DECLARE_EXTERNAL_ARRAY_STUB(Load, UnsignedInt);
+DECLARE_EXTERNAL_ARRAY_STUB(Load, Float);
+DECLARE_EXTERNAL_ARRAY_STUB(Load, Double);
+DECLARE_EXTERNAL_ARRAY_STUB(Load, Pixel);
+
+DECLARE_EXTERNAL_ARRAY_STUB(Store, Byte);
+DECLARE_EXTERNAL_ARRAY_STUB(Store, UnsignedByte);
+DECLARE_EXTERNAL_ARRAY_STUB(Store, Short);
+DECLARE_EXTERNAL_ARRAY_STUB(Store, UnsignedShort);
+DECLARE_EXTERNAL_ARRAY_STUB(Store, Int);
+DECLARE_EXTERNAL_ARRAY_STUB(Store, UnsignedInt);
+DECLARE_EXTERNAL_ARRAY_STUB(Store, Float);
+DECLARE_EXTERNAL_ARRAY_STUB(Store, Double);
+DECLARE_EXTERNAL_ARRAY_STUB(Store, Pixel);
+
+
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_