New class for Date objects: caches individual date components.

src/objects.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 46 matching lines @@
 //           - JSSet
 //           - JSMap
 //           - JSWeakMap
 //           - JSRegExp
 //           - JSFunction
 //           - GlobalObject
 //             - JSGlobalObject
 //             - JSBuiltinsObject
 //           - JSGlobalProxy
 //           - JSValue
+//             - JSDate
 //           - JSMessageObject
 //         - JSProxy
 //           - JSFunctionProxy
 //       - FixedArrayBase
 //         - ByteArray
 //         - FixedArray
 //           - DescriptorArray
 //           - HashTable
 //             - Dictionary
 //             - SymbolTable
@@ skipping 211 matching lines @@
   V(CODE_CACHE_TYPE)                                                           \
   V(POLYMORPHIC_CODE_CACHE_TYPE)                                               \
                                                                                \
   V(FIXED_ARRAY_TYPE)                                                          \
   V(FIXED_DOUBLE_ARRAY_TYPE)                                                   \
   V(SHARED_FUNCTION_INFO_TYPE)                                                 \
                                                                                \
   V(JS_MESSAGE_OBJECT_TYPE)                                                    \
                                                                                \
   V(JS_VALUE_TYPE)                                                             \
+  V(JS_DATE_TYPE)                                                              \
   V(JS_OBJECT_TYPE)                                                            \
   V(JS_CONTEXT_EXTENSION_OBJECT_TYPE)                                          \
   V(JS_GLOBAL_OBJECT_TYPE)                                                     \
   V(JS_BUILTINS_OBJECT_TYPE)                                                   \
   V(JS_GLOBAL_PROXY_TYPE)                                                      \
   V(JS_ARRAY_TYPE)                                                             \
   V(JS_PROXY_TYPE)                                                             \
   V(JS_WEAK_MAP_TYPE)                                                          \
   V(JS_REGEXP_TYPE)                                                            \
                                                                                \
@@ skipping 295 matching lines @@
 
   // All the following types are subtypes of JSReceiver, which corresponds to
   // objects in the JS sense. The first and the last type in this range are
   // the two forms of function. This organization enables using the same
   // compares for checking the JS_RECEIVER/SPEC_OBJECT range and the
   // NONCALLABLE_JS_OBJECT range.
   JS_FUNCTION_PROXY_TYPE,  // FIRST_JS_RECEIVER_TYPE, FIRST_JS_PROXY_TYPE
   JS_PROXY_TYPE,  // LAST_JS_PROXY_TYPE
 
   JS_VALUE_TYPE,  // FIRST_JS_OBJECT_TYPE
+  JS_DATE_TYPE,
   JS_OBJECT_TYPE,
   JS_CONTEXT_EXTENSION_OBJECT_TYPE,
   JS_GLOBAL_OBJECT_TYPE,
   JS_BUILTINS_OBJECT_TYPE,
   JS_GLOBAL_PROXY_TYPE,
   JS_ARRAY_TYPE,
   JS_SET_TYPE,
   JS_MAP_TYPE,
   JS_WEAK_MAP_TYPE,
 
@@ skipping 173 matching lines @@
   V(FixedArray)                                \
   V(FixedDoubleArray)                          \
   V(Context)                                   \
   V(GlobalContext)                             \
   V(ScopeInfo)                                 \
   V(JSFunction)                                \
   V(Code)                                      \
   V(Oddball)                                   \
   V(SharedFunctionInfo)                        \
   V(JSValue)                                   \
+  V(JSDate)                                    \
   V(JSMessageObject)                           \
   V(StringWrapper)                             \
   V(Foreign)                                   \
   V(Boolean)                                   \
   V(JSArray)                                   \
   V(JSProxy)                                   \
   V(JSFunctionProxy)                           \
   V(JSSet)                                     \
   V(JSMap)                                     \
   V(JSWeakMap)                                 \
@@ skipping 5000 matching lines @@
 
   static int OffsetOfCodeWithId(Builtins::JavaScript id) {
     return kJSBuiltinsCodeOffset + id * kPointerSize;
   }
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSBuiltinsObject);
 };
 
 
-// Representation for JS Wrapper objects, String, Number, Boolean, Date, etc.
+// Representation for JS Wrapper objects, String, Number, Boolean, etc.
 class JSValue: public JSObject {
  public:
   // [value]: the object being wrapped.
   DECL_ACCESSORS(value, Object)
 
   // Casting.
   static inline JSValue* cast(Object* obj);
 
   // Dispatched behavior.
 #ifdef OBJECT_PRINT
   inline void JSValuePrint() {
     JSValuePrint(stdout);
   }
   void JSValuePrint(FILE* out);
 #endif
 #ifdef DEBUG
   void JSValueVerify();
 #endif
 
   // Layout description.
   static const int kValueOffset = JSObject::kHeaderSize;
   static const int kSize = kValueOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSValue);
 };
 
 
+// Representation for JS date objects.
+class JSDate: public JSObject {

[ulan, 2012/01/25 13:08:48]

As we discussed offline, all these fields could be packed into few SMIs and we
could designate one bit in each SMI as "the date is a NaN" indicator. A possible
layout would be:

[value]: the time value.

[year_month_day]: SMI that caches the year in bits[31:12], the month in
bits[11:8], the day in bits[7:3], the is_cache_filled flag in bit[2], and the
is_nan flag in bit[1].

[hour_min_sec_ms]: SMI that caches the components similar to [year_month_day].

Advantages of this layout:
- the caches can be filled in lazily;
- less memory usage and CPU cache pressure.

Disadvantage:
- need to check is_nan flag in the getters.

[rossberg, 2012/01/25 15:48:37]

Yeah, I don't want to optimize this prematurely. The whole patch is for
benchmark speed, so I'd like to avoid the extra arithmetic for now and see where
we stand.  Frankly, I don't think space usage matters much for dates anyway, not
on benchmarks and even less so in reality. But let's see.

+ public:
+  // If one component is NaN, all of them are, indicating a NaN time value.
+  // [value]: the time value. Transitional, will disappear.

[ulan, 2012/01/25 13:08:48]

As we discussed offline, the [value] should stay since it's difficult to
reconstruct it.

[rossberg, 2012/01/25 15:48:37]

Done.

+  DECL_ACCESSORS(value, Object)
+  // [year]: caches year.
+  DECL_ACCESSORS(year, Object)
+  // [day]: caches month.
+  DECL_ACCESSORS(month, Object)
+  // [day]: caches day.
+  DECL_ACCESSORS(day, Object)
+  // [day]: caches hours.

[ulan, 2012/01/25 13:08:48]

[day] -> [hour] in the comment.

[rossberg, 2012/01/25 15:48:37]

Done. (And for month above.)

+  DECL_ACCESSORS(hour, Object)
+  // [min]: caches minutes.
+  DECL_ACCESSORS(min, Object)
+  // [sec]: caches seconds.
+  DECL_ACCESSORS(sec, Object)
+  // [ms]: caches milliseconds.
+  DECL_ACCESSORS(ms, Object)
+
+  // Casting.
+  static inline JSDate* cast(Object* obj);
+
+  // Dispatched behavior.
+#ifdef OBJECT_PRINT
+  inline void JSDatePrint() {
+    JSDatePrint(stdout);
+  }
+  void JSDatePrint(FILE* out);
+#endif
+#ifdef DEBUG
+  void JSDateVerify();
+#endif
+
+  // Layout description.
+  static const int kValueOffset = JSObject::kHeaderSize;  // transitional
+  static const int kYearOffset = kValueOffset + kPointerSize;
+  static const int kMonthOffset = kYearOffset + kPointerSize;
+  static const int kDayOffset = kMonthOffset + kPointerSize;
+  static const int kHourOffset = kDayOffset + kPointerSize;
+  static const int kMinOffset = kHourOffset + kPointerSize;
+  static const int kSecOffset = kMinOffset + kPointerSize;
+  static const int kMsOffset = kSecOffset + kPointerSize;
+  static const int kSize = kMsOffset + kPointerSize;
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(JSDate);
+};
+
+
 // Representation of message objects used for error reporting through
 // the API. The messages are formatted in JavaScript so this object is
 // a real JavaScript object. The information used for formatting the
 // error messages are not directly accessible from JavaScript to
 // prevent leaking information to user code called during error
 // formatting.
 class JSMessageObject: public JSObject {
  public:
   // [type]: the type of error message.
   DECL_ACCESSORS(type, String)
@@ skipping 2329 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_