Turn the load field code stub into a hydrogen code stub.

src/code-stubs.h

 // 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 69 matching lines @@
   V(KeyedStoreElement)                   \
   V(DebuggerStatement)                   \
   V(NameDictionaryLookup)                \
   V(ElementsTransitionAndStore)          \
   V(TransitionElementsKind)              \
   V(StoreArrayLiteralElement)            \
   V(StubFailureTrampoline)               \
   V(ArrayConstructor)                    \
   V(ProfileEntryHook)                    \
   /* IC Handler stubs */                 \
-  V(LoadField)
+  V(LoadField)                           \
+  V(KeyedLoadField)
 
 // 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)              \
   V(DirectCEntry)
 #else
@@ skipping 77 matching lines @@
   // Returns information for computing the number key.
   virtual Major MajorKey() = 0;
   virtual int MinorKey() = 0;
 
   virtual InlineCacheState GetICState() {
     return UNINITIALIZED;
   }
   virtual Code::ExtraICState GetExtraICState() {
     return Code::kNoExtraICState;
   }
+  virtual Code::StubType GetStubType() {
+    return Code::NORMAL;
+  }
+  virtual int GetStubFlags() {
+    return -1;
+  }
 
  protected:
   static bool CanUseFPRegisters();
 
   // Generates the assembler code for the stub.
   virtual Handle<Code> GenerateCode() = 0;
 
-  virtual Code::StubType GetStubType() {
-    return Code::NORMAL;
-  }
 
   // Returns whether the code generated for this stub needs to be allocated as
   // a fixed (non-moveable) code object.
   virtual bool NeedsImmovableCode() { return false; }
 
  private:
   // Perform bookkeeping required after code generation when stub code is
   // initially generated.
   void RecordCodeGeneration(Code* code, Isolate* isolate);
 
@@ skipping 38 matching lines @@
   friend class BreakPointIterator;
 };
 
 
 class PlatformCodeStub : public CodeStub {
  public:
   // Retrieve the code for the stub. Generate the code if needed.
   virtual Handle<Code> GenerateCode();
 
   virtual Code::Kind GetCodeKind() const { return Code::STUB; }
-  virtual int GetStubFlags() { return -1; }
 
  protected:
   // Generates the assembler code for the stub.
   virtual void Generate(MacroAssembler* masm) = 0;
 };
 
 
 enum StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE };
 
 
@@ skipping 480 matching lines @@
  public:
   explicit StoreArrayLengthStub(Code::Kind kind, StrictModeFlag strict_mode)
       : StoreICStub(kind, strict_mode) { }
   virtual void Generate(MacroAssembler* masm);
 
  private:
   virtual CodeStub::Major MajorKey() { return StoreArrayLength; }
 };
 
 
-class HandlerStub: public ICStub {
+class HICStub: public HydrogenCodeStub {
  public:
-  explicit HandlerStub(Code::Kind kind) : ICStub(kind) { }
+  explicit HICStub(Code::Kind kind)
+      : HydrogenCodeStub(CODE_STUB_IS_NOT_MISS), kind_(kind) { }
+  virtual Code::Kind GetCodeKind() const { return kind_; }
+  virtual InlineCacheState GetICState() { return MONOMORPHIC; }
+
+ protected:
+  class KindBits: public BitField<Code::Kind, 0, 4> {};
+  Code::Kind kind() { return kind_; }
+
+ private:
+  Code::Kind kind_;
+};
+
+
+class HandlerStub: public HICStub {
+ public:
+  explicit HandlerStub(Code::Kind kind) : HICStub(kind) { }
   virtual Code::Kind GetCodeKind() const { return Code::STUB; }
   virtual int GetStubFlags() { return kind(); }
 };
 
 
 class LoadFieldStub: public HandlerStub {
  public:
-  LoadFieldStub(Register reg, bool inobject, int index)
-      : HandlerStub(Code::LOAD_IC),
-        reg_(reg),
+  LoadFieldStub(bool inobject,
+                int index,
+                Representation representation,
+                Code::Kind kind = Code::LOAD_IC)
+      : HandlerStub(kind),
         inobject_(inobject),
-        index_(index) { }
-  virtual void Generate(MacroAssembler* masm);
+        index_(index) {
+    unboxed_double_ = FLAG_track_double_fields && representation.IsDouble();
+  }
+  virtual Handle<Code> GenerateCode();
 
- protected:
+  virtual void InitializeInterfaceDescriptor(
+      Isolate* isolate,
+      CodeStubInterfaceDescriptor* descriptor);
+
+  Representation representation() {
+    if (unboxed_double_) return Representation::Double();

[danno, 2013/05/02 11:41:48]

Not yet?

+    return Representation::Tagged();
+  }
+
+  bool is_inobject() { return inobject_; }
+
+  int offset() {
+    int offset = index_ * kPointerSize;
+    if (is_inobject()) return offset;
+    return FixedArray::kHeaderSize + offset;
+  }
+
   virtual Code::StubType GetStubType() { return Code::FIELD; }
 
  private:
   STATIC_ASSERT(KindBits::kSize == 4);
-  class RegisterBits: public BitField<int, 4, 6> {};
-  class InobjectBits: public BitField<bool, 10, 1> {};
-  class IndexBits: public BitField<int, 11, 11> {};
+  class InobjectBits: public BitField<bool, 4, 1> {};
+  class IndexBits: public BitField<int, 5, 11> {};
+  class UnboxedDoubleBits: public BitField<bool, 16, 1> {};

[danno, 2013/05/02 10:56:59]

Seems premature for this CL?

   virtual CodeStub::Major MajorKey() { return LoadField; }
-  virtual int MinorKey() {
+
+  virtual int NotMissMinorKey() {
     return KindBits::encode(kind())
-        | RegisterBits::encode(reg_.code())
         | InobjectBits::encode(inobject_)
-        | IndexBits::encode(index_);
+        | IndexBits::encode(index_)
+        | UnboxedDoubleBits::encode(unboxed_double_);
   }
 
-  Register reg_;
   bool inobject_;

[danno, 2013/05/02 10:56:59]

Other stubs store the |'ed version in a field called bit_field_ and extract them
in accessors. Any reason to not do that here?

   int index_;
+  bool unboxed_double_;
 };
 
 
+class KeyedLoadFieldStub: public LoadFieldStub {
+ public:
+  KeyedLoadFieldStub(bool inobject,
+                     int index,
+                     Representation representation)
+      : LoadFieldStub(inobject, index, representation, Code::KEYED_LOAD_IC) { }
+
+  virtual void InitializeInterfaceDescriptor(
+      Isolate* isolate,
+      CodeStubInterfaceDescriptor* descriptor);
+
+  virtual Handle<Code> GenerateCode();
+
+ private:
+  virtual CodeStub::Major MajorKey() { return KeyedLoadField; }
+};
+
+
 class BinaryOpStub: public PlatformCodeStub {
  public:
   BinaryOpStub(Token::Value op, OverwriteMode mode)
       : op_(op),
         mode_(mode),
         platform_specific_bit_(false),
         left_type_(BinaryOpIC::UNINITIALIZED),
         right_type_(BinaryOpIC::UNINITIALIZED),
         result_type_(BinaryOpIC::UNINITIALIZED) {
     Initialize();
@@ skipping 1088 matching lines @@
 
   // The current function entry hook.
   static FunctionEntryHook entry_hook_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileEntryHookStub);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_