Use the same registers for StoreIC and KeyedStoreIC.

src/code-stubs.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/codegen.h"
@@ skipping 2437 matching lines @@
   ElementsKind from_kind() const { return from_kind_; }
   ElementsKind to_kind() const { return to_kind_; }
   bool is_jsarray() const { return is_jsarray_; }
   KeyedAccessStoreMode store_mode() const { return store_mode_; }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
+  enum RegisterInfo {

[Michael Starzinger, 2014/07/11 08:27:08]

nit: Let's add a comment "// Parameters accessed via
CodeStubGraphBuilder::GetParameter()" similar to the other hydrogen stubs here.
Also does it really increase readability to have an enum for this instead of a
list of const ints? I would prefer the latter.

[mvstanton, 2014/07/11 08:43:09]

Cool, I'll add the comment. As for the enum format, I'm following the convention
laid down in a few previous CLs in ic.h for Load/StoreKeyed. You get an enum
which gives you ordering for stack-based calls, then the registers. If it's cool
I'll keep that convention for now, perhaps later do a refactoring CL to turn
them into const ints monolithically.

[Michael Starzinger, 2014/07/11 09:04:10]

As discussed offline: In this case I am fine with keeping the enum as it is. But
please add the comment.

+    kValueIndex,
+    kMapIndex,
+    kKeyIndex,
+    kObjectIndex,
+    kRegisterArgumentCount

[Michael Starzinger, 2014/07/11 08:27:08]

nit: The register count doesn't seem to be used. Can we drop it to avoid
confusion?

[mvstanton, 2014/07/11 08:43:09]

It's part of the convention, and is used in some asserts for some ICs, but it's
true, I don't use this one. Actually, how about this idea: the bailout method
uses the constant in an assert around arguments length, the bailout method could
also use those indexes to extract arguments instead of 0, 1, 2, etc.

[Michael Starzinger, 2014/07/11 09:04:10]

Acknowledged.

+  };
+
+  static const Register ValueRegister() {
+    return KeyedStoreIC::ValueRegister();
+  }
+  static const Register MapRegister() { return KeyedStoreIC::MapRegister(); }
+  static const Register KeyRegister() { return KeyedStoreIC::NameRegister(); }
+  static const Register ObjectRegister() {
+    return KeyedStoreIC::ReceiverRegister();
+  }
+
  private:
   class FromBits:      public BitField<ElementsKind,          0, 8> {};
   class ToBits:        public BitField<ElementsKind,          8, 8> {};
   class IsJSArrayBits: public BitField<bool,                 16, 1> {};
   class StoreModeBits: public BitField<KeyedAccessStoreMode, 17, 4> {};
 
   Major MajorKey() const { return ElementsTransitionAndStore; }
   int NotMissMinorKey() const {
     return FromBits::encode(from_kind_) |
         ToBits::encode(to_kind_) |
@@ skipping 72 matching lines @@
 
 
 class CallDescriptors {
  public:
   static void InitializeForIsolate(Isolate* isolate);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_