Use mutable heapnumbers to store doubles in fields.

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 763 matching lines @@
   virtual Code::Kind GetCodeKind() const { return Code::STUB; }
   virtual int GetStubFlags() { return kind(); }
 
  protected:
   HandlerStub() : HICStub() { }
 };
 
 
 class LoadFieldStub: public HandlerStub {
  public:
-  LoadFieldStub(bool inobject, int index) : HandlerStub() {
-    Initialize(Code::LOAD_IC, inobject, index);
+  LoadFieldStub(bool inobject, int index, Representation representation)
+      : HandlerStub() {
+    Initialize(Code::LOAD_IC, inobject, index, representation);
   }
 
   virtual Handle<Code> GenerateCode();
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
   Representation representation() {
+    if (unboxed_double()) return Representation::Double();
     return Representation::Tagged();
   }
 
   virtual Code::Kind kind() const {
     return KindBits::decode(bit_field_);
   }
 
   bool is_inobject() {
     return InobjectBits::decode(bit_field_);
   }
 
   int offset() {
     int index = IndexBits::decode(bit_field_);
     int offset = index * kPointerSize;
     if (is_inobject()) return offset;
     return FixedArray::kHeaderSize + offset;
   }
 
+  bool unboxed_double() {
+    return UnboxedDoubleBits::decode(bit_field_);
+  }
+
   virtual Code::StubType GetStubType() { return Code::FIELD; }
 
  protected:
   LoadFieldStub() : HandlerStub() { }
 
-  void Initialize(Code::Kind kind, bool inobject, int index) {
+  void Initialize(Code::Kind kind,
+                  bool inobject,
+                  int index,
+                  Representation representation) {
+    bool unboxed_double = FLAG_track_double_fields && representation.IsDouble();
     bit_field_ = KindBits::encode(kind)
         | InobjectBits::encode(inobject)
-        | IndexBits::encode(index);
+        | IndexBits::encode(index)
+        | UnboxedDoubleBits::encode(unboxed_double);
   }
 
  private:
   STATIC_ASSERT(KindBits::kSize == 4);
   class InobjectBits: public BitField<bool, 4, 1> {};
   class IndexBits: public BitField<int, 5, 11> {};
+  class UnboxedDoubleBits: public BitField<bool, 16, 1> {};
   virtual CodeStub::Major MajorKey() { return LoadField; }
   virtual int NotMissMinorKey() { return bit_field_; }
 
   int bit_field_;
 };
 
 
 class KeyedLoadFieldStub: public LoadFieldStub {
  public:
-  KeyedLoadFieldStub(bool inobject, int index) : LoadFieldStub() {
-    Initialize(Code::KEYED_LOAD_IC, inobject, index);
+  KeyedLoadFieldStub(bool inobject, int index, Representation representation)
+      : LoadFieldStub() {
+    Initialize(Code::KEYED_LOAD_IC, inobject, index, representation);
   }
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
   virtual Handle<Code> GenerateCode();
 
  private:
   virtual CodeStub::Major MajorKey() { return KeyedLoadField; }
@@ skipping 1101 matching lines @@
 
   // The current function entry hook.
   static FunctionEntryHook entry_hook_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileEntryHookStub);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_