Home | History | Annotate | Download | only in src 
      1 // Copyright 2014 the V8 project authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef V8_PROPERTY_H_
      6 #define V8_PROPERTY_H_
      7 
      8 #include <iosfwd>
      9 
     10 #include "src/factory.h"
     11 #include "src/isolate.h"
     12 
     13 namespace v8 {
     14 namespace internal {
     15 
     16 // Abstraction for elements in instance-descriptor arrays.
     17 //
     18 // Each descriptor has a key, property attributes, property type,
     19 // property index (in the actual instance-descriptor array) and
     20 // optionally a piece of data.
     21 class Descriptor final BASE_EMBEDDED {
     22  public:
     23   Descriptor() : details_(Smi::kZero) {}
     24 
     25   Handle<Name> GetKey() const { return key_; }
     26   Handle<Object> GetValue() const { return value_; }
     27   PropertyDetails GetDetails() const { return details_; }
     28 
     29   void SetSortedKeyIndex(int index) { details_ = details_.set_pointer(index); }
     30 
     31   static Descriptor DataField(Handle<Name> key, int field_index,
     32                               PropertyAttributes attributes,
     33                               Representation representation);
     34 
     35   static Descriptor DataField(Handle<Name> key, int field_index,
     36                               PropertyAttributes attributes,
     37                               PropertyConstness constness,
     38                               Representation representation,
     39                               Handle<Object> wrapped_field_type);
     40 
     41   static Descriptor DataConstant(Handle<Name> key, Handle<Object> value,
     42                                  PropertyAttributes attributes) {
     43     return Descriptor(key, value, kData, attributes, kDescriptor, kConst,
     44                       value->OptimalRepresentation(), 0);
     45   }
     46 
     47   static Descriptor DataConstant(Handle<Name> key, int field_index,
     48                                  Handle<Object> value,
     49                                  PropertyAttributes attributes);
     50 
     51   static Descriptor AccessorConstant(Handle<Name> key, Handle<Object> foreign,
     52                                      PropertyAttributes attributes) {
     53     return Descriptor(key, foreign, kAccessor, attributes, kDescriptor, kConst,
     54                       Representation::Tagged(), 0);
     55   }
     56 
     57  private:
     58   Handle<Name> key_;
     59   Handle<Object> value_;
     60   PropertyDetails details_;
     61 
     62  protected:
     63   void Init(Handle<Name> key, Handle<Object> value, PropertyDetails details) {
     64     DCHECK(key->IsUniqueName());
     65     DCHECK_IMPLIES(key->IsPrivate(), !details.IsEnumerable());
     66     key_ = key;
     67     value_ = value;
     68     details_ = details;
     69   }
     70 
     71   Descriptor(Handle<Name> key, Handle<Object> value, PropertyDetails details)
     72       : key_(key), value_(value), details_(details) {
     73     DCHECK(key->IsUniqueName());
     74     DCHECK_IMPLIES(key->IsPrivate(), !details_.IsEnumerable());
     75   }
     76 
     77   Descriptor(Handle<Name> key, Handle<Object> value, PropertyKind kind,
     78              PropertyAttributes attributes, PropertyLocation location,
     79              PropertyConstness constness, Representation representation,
     80              int field_index)
     81       : key_(key),
     82         value_(value),
     83         details_(kind, attributes, location, constness, representation,
     84                  field_index) {
     85     DCHECK(key->IsUniqueName());
     86     DCHECK_IMPLIES(key->IsPrivate(), !details_.IsEnumerable());
     87   }
     88 
     89   friend class DescriptorArray;
     90   friend class Map;
     91   friend class MapUpdater;
     92 };
     93 
     94 }  // namespace internal
     95 }  // namespace v8
     96 
     97 #endif  // V8_PROPERTY_H_
     98