Avoid setting / depending on flags when transitioning, and when fields are known to be constant.

src/hydrogen-instructions.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 5402 matching lines @@
 
   int slot_index_;
   Mode mode_;
 };
 
 
 // Represents an access to a portion of an object, such as the map pointer,
 // array elements pointer, etc, but not accesses to array elements themselves.
 class HObjectAccess V8_FINAL {
  public:
+  // Indicates whether the field is initialized while transitioning, or also
+  // mutable afterwards. Transitioning stores only initialize new fields rather
+  // than changing existing fields, so they are marked as CONSTANT.
+  enum FieldType { MUTABLE, CONSTANT };
+
   inline bool IsInobject() const {
     return portion() != kBackingStore && portion() != kExternalMemory;
   }
 
   inline bool IsExternalMemory() const {
     return portion() == kExternalMemory;
   }
 
   inline bool IsStringLength() const {
     return portion() == kStringLengths;
   }
 
   inline int offset() const {
     return OffsetField::decode(value_);
   }
 
   inline Representation representation() const {
     return Representation::FromKind(RepresentationField::decode(value_));
   }
 
   inline Handle<String> name() const {
     return name_;
   }
 
-  inline HObjectAccess WithRepresentation(Representation representation) {
-    return HObjectAccess(portion(), offset(), representation, name());
+  inline HObjectAccess WithRepresentation(Representation representation,
+                                          FieldType field_type = MUTABLE) {
+    return HObjectAccess(
+        portion(), offset(), representation, name(), field_type);
   }
 
   static HObjectAccess ForHeapNumberValue() {
     return HObjectAccess(
         kDouble, HeapNumber::kValueOffset, Representation::Double());
   }
 
   static HObjectAccess ForElementsPointer() {
     return HObjectAccess(kElementsPointer, JSObject::kElementsOffset);
   }
@@ skipping 100 matching lines @@
     kStringLengths,    // the length of a string
     kElementsPointer,  // elements pointer
     kBackingStore,     // some field in the backing store
     kDouble,           // some double field
     kInobject,         // some other in-object field
     kExternalMemory    // some field in external memory
   };
 
   HObjectAccess(Portion portion, int offset,
                 Representation representation = Representation::Tagged(),
-                Handle<String> name = Handle<String>::null())
+                Handle<String> name = Handle<String>::null(),
+                FieldType field_type = MUTABLE)
     : value_(PortionField::encode(portion) |
-             RepresentationField::encode(representation.kind()) |
-             OffsetField::encode(offset)),
+                RepresentationField::encode(representation.kind()) |
+                FieldTypeField::encode(field_type) |
+                OffsetField::encode(offset)),
       name_(name) {
     // assert that the fields decode correctly
     ASSERT(this->offset() == offset);
     ASSERT(this->portion() == portion);
     ASSERT(RepresentationField::decode(value_) == representation.kind());
   }
 
   class PortionField : public BitField<Portion, 0, 3> {};
   class RepresentationField : public BitField<Representation::Kind, 3, 3> {};
-  class OffsetField : public BitField<int, 6, 26> {};
+  class FieldTypeField : public BitField<FieldType, 6, 1> {};
+  class OffsetField : public BitField<int, 7, 25> {};
 
   uint32_t value_;  // encodes portion, representation, and offset
   Handle<String> name_;
 
   friend class HLoadNamedField;
   friend class HStoreNamedField;
 
   inline Portion portion() const {
     return PortionField::decode(value_);
   }
@@ skipping 1199 matching lines @@
   virtual bool IsDeletable() const V8_OVERRIDE { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_