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_LAYOUT_DESCRIPTOR_INL_H_
      6 #define V8_LAYOUT_DESCRIPTOR_INL_H_
      7 
      8 #include "src/layout-descriptor.h"
      9 
     10 namespace v8 {
     11 namespace internal {
     12 
     13 LayoutDescriptor* LayoutDescriptor::FromSmi(Smi* smi) {
     14   return LayoutDescriptor::cast(smi);
     15 }
     16 
     17 
     18 Handle<LayoutDescriptor> LayoutDescriptor::New(Isolate* isolate, int length) {
     19   if (length <= kSmiValueSize) {
     20     // The whole bit vector fits into a smi.
     21     return handle(LayoutDescriptor::FromSmi(Smi::FromInt(0)), isolate);
     22   }
     23   length = GetSlowModeBackingStoreLength(length);
     24   return Handle<LayoutDescriptor>::cast(isolate->factory()->NewFixedTypedArray(
     25       length, kExternalUint32Array, true));
     26 }
     27 
     28 
     29 bool LayoutDescriptor::InobjectUnboxedField(int inobject_properties,
     30                                             PropertyDetails details) {
     31   if (details.type() != DATA || !details.representation().IsDouble()) {
     32     return false;
     33   }
     34   // We care only about in-object properties.
     35   return details.field_index() < inobject_properties;
     36 }
     37 
     38 
     39 LayoutDescriptor* LayoutDescriptor::FastPointerLayout() {
     40   return LayoutDescriptor::FromSmi(Smi::FromInt(0));
     41 }
     42 
     43 
     44 bool LayoutDescriptor::GetIndexes(int field_index, int* layout_word_index,
     45                                   int* layout_bit_index) {
     46   if (static_cast<unsigned>(field_index) >= static_cast<unsigned>(capacity())) {
     47     return false;
     48   }
     49 
     50   *layout_word_index = field_index / kNumberOfBits;
     51   CHECK((!IsSmi() && (*layout_word_index < length())) ||
     52         (IsSmi() && (*layout_word_index < 1)));
     53 
     54   *layout_bit_index = field_index % kNumberOfBits;
     55   return true;
     56 }
     57 
     58 
     59 LayoutDescriptor* LayoutDescriptor::SetRawData(int field_index) {
     60   return SetTagged(field_index, false);
     61 }
     62 
     63 
     64 LayoutDescriptor* LayoutDescriptor::SetTagged(int field_index, bool tagged) {
     65   int layout_word_index = 0;
     66   int layout_bit_index = 0;
     67 
     68   if (!GetIndexes(field_index, &layout_word_index, &layout_bit_index)) {
     69     CHECK(false);
     70     return this;
     71   }
     72   uint32_t layout_mask = static_cast<uint32_t>(1) << layout_bit_index;
     73 
     74   if (IsSlowLayout()) {
     75     uint32_t value = get_scalar(layout_word_index);
     76     if (tagged) {
     77       value &= ~layout_mask;
     78     } else {
     79       value |= layout_mask;
     80     }
     81     set(layout_word_index, value);
     82     return this;
     83   } else {
     84     uint32_t value = static_cast<uint32_t>(Smi::cast(this)->value());
     85     if (tagged) {
     86       value &= ~layout_mask;
     87     } else {
     88       value |= layout_mask;
     89     }
     90     return LayoutDescriptor::FromSmi(Smi::FromInt(static_cast<int>(value)));
     91   }
     92 }
     93 
     94 
     95 bool LayoutDescriptor::IsTagged(int field_index) {
     96   if (IsFastPointerLayout()) return true;
     97 
     98   int layout_word_index;
     99   int layout_bit_index;
    100 
    101   if (!GetIndexes(field_index, &layout_word_index, &layout_bit_index)) {
    102     // All bits after Out of bounds queries
    103     return true;
    104   }
    105   uint32_t layout_mask = static_cast<uint32_t>(1) << layout_bit_index;
    106 
    107   if (IsSlowLayout()) {
    108     uint32_t value = get_scalar(layout_word_index);
    109     return (value & layout_mask) == 0;
    110   } else {
    111     uint32_t value = static_cast<uint32_t>(Smi::cast(this)->value());
    112     return (value & layout_mask) == 0;
    113   }
    114 }
    115 
    116 
    117 bool LayoutDescriptor::IsFastPointerLayout() {
    118   return this == FastPointerLayout();
    119 }
    120 
    121 
    122 bool LayoutDescriptor::IsFastPointerLayout(Object* layout_descriptor) {
    123   return layout_descriptor == FastPointerLayout();
    124 }
    125 
    126 
    127 bool LayoutDescriptor::IsSlowLayout() { return !IsSmi(); }
    128 
    129 
    130 int LayoutDescriptor::capacity() {
    131   return IsSlowLayout() ? (length() * kNumberOfBits) : kSmiValueSize;
    132 }
    133 
    134 
    135 LayoutDescriptor* LayoutDescriptor::cast_gc_safe(Object* object) {
    136   if (object->IsSmi()) {
    137     // Fast mode layout descriptor.
    138     return reinterpret_cast<LayoutDescriptor*>(object);
    139   }
    140 
    141   // This is a mixed descriptor which is a fixed typed array.
    142   MapWord map_word = reinterpret_cast<HeapObject*>(object)->map_word();
    143   if (map_word.IsForwardingAddress()) {
    144     // Mark-compact has already moved layout descriptor.
    145     object = map_word.ToForwardingAddress();
    146   }
    147   return LayoutDescriptor::cast(object);
    148 }
    149 
    150 
    151 int LayoutDescriptor::GetSlowModeBackingStoreLength(int length) {
    152   length = (length + kNumberOfBits - 1) / kNumberOfBits;
    153   DCHECK_LT(0, length);
    154 
    155   if (SmiValuesAre32Bits() && (length & 1)) {
    156     // On 64-bit systems if the length is odd then the half-word space would be
    157     // lost anyway (due to alignment and the fact that we are allocating
    158     // uint32-typed array), so we increase the length of allocated array
    159     // to utilize that "lost" space which could also help to avoid layout
    160     // descriptor reallocations.
    161     ++length;
    162   }
    163   return length;
    164 }
    165 
    166 
    167 int LayoutDescriptor::CalculateCapacity(Map* map, DescriptorArray* descriptors,
    168                                         int num_descriptors) {
    169   int inobject_properties = map->GetInObjectProperties();
    170   if (inobject_properties == 0) return 0;
    171 
    172   DCHECK_LE(num_descriptors, descriptors->number_of_descriptors());
    173 
    174   int layout_descriptor_length;
    175   const int kMaxWordsPerField = kDoubleSize / kPointerSize;
    176 
    177   if (num_descriptors <= kSmiValueSize / kMaxWordsPerField) {
    178     // Even in the "worst" case (all fields are doubles) it would fit into
    179     // a Smi, so no need to calculate length.
    180     layout_descriptor_length = kSmiValueSize;
    181 
    182   } else {
    183     layout_descriptor_length = 0;
    184 
    185     for (int i = 0; i < num_descriptors; i++) {
    186       PropertyDetails details = descriptors->GetDetails(i);
    187       if (!InobjectUnboxedField(inobject_properties, details)) continue;
    188       int field_index = details.field_index();
    189       int field_width_in_words = details.field_width_in_words();
    190       layout_descriptor_length =
    191           Max(layout_descriptor_length, field_index + field_width_in_words);
    192     }
    193   }
    194   layout_descriptor_length = Min(layout_descriptor_length, inobject_properties);
    195   return layout_descriptor_length;
    196 }
    197 
    198 
    199 LayoutDescriptor* LayoutDescriptor::Initialize(
    200     LayoutDescriptor* layout_descriptor, Map* map, DescriptorArray* descriptors,
    201     int num_descriptors) {
    202   DisallowHeapAllocation no_allocation;
    203   int inobject_properties = map->GetInObjectProperties();
    204 
    205   for (int i = 0; i < num_descriptors; i++) {
    206     PropertyDetails details = descriptors->GetDetails(i);
    207     if (!InobjectUnboxedField(inobject_properties, details)) {
    208       DCHECK(details.location() != kField ||
    209              layout_descriptor->IsTagged(details.field_index()));
    210       continue;
    211     }
    212     int field_index = details.field_index();
    213     layout_descriptor = layout_descriptor->SetRawData(field_index);
    214     if (details.field_width_in_words() > 1) {
    215       layout_descriptor = layout_descriptor->SetRawData(field_index + 1);
    216     }
    217   }
    218   return layout_descriptor;
    219 }
    220 
    221 
    222 // LayoutDescriptorHelper is a helper class for querying whether inobject
    223 // property at offset is Double or not.
    224 LayoutDescriptorHelper::LayoutDescriptorHelper(Map* map)
    225     : all_fields_tagged_(true),
    226       header_size_(0),
    227       layout_descriptor_(LayoutDescriptor::FastPointerLayout()) {
    228   if (!FLAG_unbox_double_fields) return;
    229 
    230   layout_descriptor_ = map->layout_descriptor_gc_safe();
    231   if (layout_descriptor_->IsFastPointerLayout()) {
    232     return;
    233   }
    234 
    235   int inobject_properties = map->GetInObjectProperties();
    236   DCHECK(inobject_properties > 0);
    237   header_size_ = map->instance_size() - (inobject_properties * kPointerSize);
    238   DCHECK(header_size_ >= 0);
    239 
    240   all_fields_tagged_ = false;
    241 }
    242 
    243 
    244 bool LayoutDescriptorHelper::IsTagged(int offset_in_bytes) {
    245   DCHECK(IsAligned(offset_in_bytes, kPointerSize));
    246   if (all_fields_tagged_) return true;
    247   // Object headers do not contain non-tagged fields.
    248   if (offset_in_bytes < header_size_) return true;
    249   int field_index = (offset_in_bytes - header_size_) / kPointerSize;
    250 
    251   return layout_descriptor_->IsTagged(field_index);
    252 }
    253 }  // namespace internal
    254 }  // namespace v8
    255 
    256 #endif  // V8_LAYOUT_DESCRIPTOR_INL_H_
    257