Optimize calls to object literal properties that are initialized with a funct...

src/hydrogen-instructions.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 130 matching lines @@
   V(StoreGlobal)                               \
   V(StoreKeyedFastElement)                     \
   V(StoreKeyedGeneric)                         \
   V(StoreNamedField)                           \
   V(StoreNamedGeneric)                         \
   V(StringCharCodeAt)                          \
   V(StringLength)                              \
   V(Sub)                                       \
   V(Test)                                      \
   V(Throw)                                     \
+  V(ToFastProperties)                          \
   V(Typeof)                                    \
   V(TypeofIs)                                  \
   V(UnaryMathOperation)                        \
   V(UnknownOSRValue)                           \
   V(ValueOf)
 
 #define GVN_FLAG_LIST(V)                       \
   V(Calls)                                     \
   V(InobjectFields)                            \
   V(BackingStoreFields)                        \
@@ skipping 2843 matching lines @@
   int length_;
   Handle<FixedArray> constant_elements_;
 };
 
 
 class HObjectLiteral: public HMaterializedLiteral {
  public:
   HObjectLiteral(Handle<FixedArray> constant_properties,
                  bool fast_elements,
                  int literal_index,
-                 int depth)
+                 int depth,
+                 bool has_function)
       : HMaterializedLiteral(literal_index, depth),
         constant_properties_(constant_properties),
-        fast_elements_(fast_elements) {}
+        fast_elements_(fast_elements),
+        has_function_(has_function) {}
 
   Handle<FixedArray> constant_properties() const {
     return constant_properties_;
   }
   bool fast_elements() const { return fast_elements_; }
+  bool has_function() const { return has_function_; }
 
   DECLARE_CONCRETE_INSTRUCTION(ObjectLiteral, "object_literal")
 
  private:
   Handle<FixedArray> constant_properties_;
   bool fast_elements_;
+  bool has_function_;
 };
 
 
 class HRegExpLiteral: public HMaterializedLiteral {
  public:
   HRegExpLiteral(Handle<String> pattern,
                  Handle<String> flags,
                  int literal_index)
       : HMaterializedLiteral(literal_index, 0),
         pattern_(pattern),
@@ skipping 31 matching lines @@
 class HTypeof: public HUnaryOperation {
  public:
   explicit HTypeof(HValue* value) : HUnaryOperation(value) {
     set_representation(Representation::Tagged());
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof")
 };
 
 
+class HToFastProperties: public HUnaryOperation {

[Mads Ager (chromium), 2011/02/02 13:07:52]

Is it OK that this is not marked as changing maps when that is exactly what it
is doing? I'm concerned that maybe code that relies on the new map can be
hoisted to before this instruction where the map is not the same?

[fschneider, 2011/02/02 14:23:32]

As discussed I'm making the return value of the ToFastProperties-call the result
of the whole object literal expression and assert that the HToFastProperties is
only used with an freshly created object literal as input.

+ public:
+  explicit HToFastProperties(HValue* value) : HUnaryOperation(value) {
+    set_representation(Representation::Tagged());
+  }
+
+  DECLARE_CONCRETE_INSTRUCTION(ToFastProperties, "to_fast_properties")
+};
+
+
 class HValueOf: public HUnaryOperation {
  public:
   explicit HValueOf(HValue* value) : HUnaryOperation(value) {
     set_representation(Representation::Tagged());
   }
 
   DECLARE_CONCRETE_INSTRUCTION(ValueOf, "value_of")
 };
 
 
@@ skipping 14 matching lines @@
   HValue* object() const { return left(); }
   HValue* key() const { return right(); }
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_