[runtime][ic] Constant field tracking support.

src/property-details.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PROPERTY_DETAILS_H_
 #define V8_PROPERTY_DETAILS_H_
 
 #include "include/v8.h"
 #include "src/allocation.h"
+// TODO(ishell): remove once FLAG_track_constant_fields is removed.
+#include "src/flags.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 // ES6 6.1.7.1
 enum PropertyAttributes {
   NONE = ::v8::None,
   READ_ONLY = ::v8::ReadOnly,
   DONT_ENUM = ::v8::DontEnum,
@@ skipping 49 matching lines @@
 enum PropertyKind { kData = 0, kAccessor = 1 };
 
 // Order of modes is significant.
 // Must fit in the BitField PropertyDetails::LocationField.
 enum PropertyLocation { kField = 0, kDescriptor = 1 };
 
 // Order of modes is significant.
 // Must fit in the BitField PropertyDetails::ConstnessField.
 enum PropertyConstness { kMutable = 0, kConst = 1 };
 
+// TODO(ishell): remove once constant field tracking is done.
+const PropertyConstness kDefaultFieldConstness =
+    FLAG_track_constant_fields ? kConst : kMutable;
+
 class Representation {
  public:
   enum Kind {
     kNone,
     kInteger8,
     kUInteger8,
     kInteger16,
     kUInteger16,
     kSmi,
     kInteger32,
@@ skipping 174 matching lines @@
 
   PropertyDetails set_index(int index) const {
     PropertyDetails details = *this;
     details.value_ = DictionaryStorageField::update(details.value_, index);
     return details;
   }
 
   PropertyDetails CopyWithRepresentation(Representation representation) const {
     return PropertyDetails(value_, representation);
   }
+  PropertyDetails CopyWithConstness(PropertyConstness constness) const {
+    return PropertyDetails(value_, constness);
+  }
   PropertyDetails CopyAddAttributes(PropertyAttributes new_attributes) const {
     new_attributes =
         static_cast<PropertyAttributes>(attributes() | new_attributes);
     return PropertyDetails(value_, new_attributes);
   }
 
   // Conversion for storing details as Object*.
   explicit inline PropertyDetails(Smi* smi);
   inline Smi* AsSmi() const;
 
@@ skipping 90 matching lines @@
   void PrintAsFastTo(std::ostream& out, PrintMode mode = kPrintFull);
 
  private:
   PropertyDetails(int value, int pointer) {
     value_ = DescriptorPointer::update(value, pointer);
   }
   PropertyDetails(int value, Representation representation) {
     value_ = RepresentationField::update(
         value, EncodeRepresentation(representation));
   }
+  PropertyDetails(int value, PropertyConstness constness) {
+    value_ = ConstnessField::update(value, constness);
+  }
   PropertyDetails(int value, PropertyAttributes attributes) {
     value_ = AttributesField::update(value, attributes);
   }
 
   uint32_t value_;
 };
 
 // kField location is more general than kDescriptor, kDescriptor generalizes
 // only to itself.
 inline bool IsGeneralizableTo(PropertyLocation a, PropertyLocation b) {
@@ skipping 10 matching lines @@
                                              PropertyConstness b) {
   return a == kMutable ? kMutable : b;
 }
 
 std::ostream& operator<<(std::ostream& os,
                          const PropertyAttributes& attributes);
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PROPERTY_DETAILS_H_