src/layout-descriptor.cc

   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 #include <sstream>
   6
   7 #include "src/v8.h"
   8
   9 #include "src/base/bits.h"
  10 #include "src/layout-descriptor.h"
  11
  12 using v8::base::bits::CountTrailingZeros32;
  13
  14 namespace v8 {
  15 namespace internal {
  16
  17 Handle<LayoutDescriptor> LayoutDescriptor::New(
  18     Handle<Map> map, Handle<DescriptorArray> descriptors, int num_descriptors) {
  19   Isolate* isolate = descriptors->GetIsolate();
  20   if (!FLAG_unbox_double_fields) return handle(FastPointerLayout(), isolate);
  21
  22   int layout_descriptor_length =
  23       CalculateCapacity(*map, *descriptors, num_descriptors);
  24
  25   if (layout_descriptor_length == 0) {
  26     // No double fields were found, use fast pointer layout.
  27     return handle(FastPointerLayout(), isolate);
  28   }
  29
  30   // Initially, layout descriptor corresponds to an object with all fields
  31   // tagged.
  32   Handle<LayoutDescriptor> layout_descriptor_handle =
  33       LayoutDescriptor::New(isolate, layout_descriptor_length);
  34
  35   LayoutDescriptor* layout_descriptor = Initialize(
  36       *layout_descriptor_handle, *map, *descriptors, num_descriptors);
  37
  38   return handle(layout_descriptor, isolate);
  39 }
  40
  41
  42 Handle<LayoutDescriptor> LayoutDescriptor::ShareAppend(
  43     Handle<Map> map, PropertyDetails details) {
  44   DCHECK(map->owns_descriptors());
  45   Isolate* isolate = map->GetIsolate();
  46   Handle<LayoutDescriptor> layout_descriptor(map->GetLayoutDescriptor(),
  47                                              isolate);
  48
  49   if (!InobjectUnboxedField(map->inobject_properties(), details)) {
  50     DCHECK(details.location() != kField ||
  51            layout_descriptor->IsTagged(details.field_index()));
  52     return layout_descriptor;
  53   }
  54   int field_index = details.field_index();
  55   layout_descriptor = LayoutDescriptor::EnsureCapacity(
  56       isolate, layout_descriptor, field_index + details.field_width_in_words());
  57
  58   DisallowHeapAllocation no_allocation;
  59   LayoutDescriptor* layout_desc = *layout_descriptor;
  60   layout_desc = layout_desc->SetRawData(field_index);
  61   if (details.field_width_in_words() > 1) {
  62     layout_desc = layout_desc->SetRawData(field_index + 1);
  63   }
  64   return handle(layout_desc, isolate);
  65 }
  66
  67
  68 Handle<LayoutDescriptor> LayoutDescriptor::AppendIfFastOrUseFull(
  69     Handle<Map> map, PropertyDetails details,
  70     Handle<LayoutDescriptor> full_layout_descriptor) {
  71   DisallowHeapAllocation no_allocation;
  72   LayoutDescriptor* layout_descriptor = map->layout_descriptor();
  73   if (layout_descriptor->IsSlowLayout()) {
  74     return full_layout_descriptor;
  75   }
  76   if (!InobjectUnboxedField(map->inobject_properties(), details)) {
  77     DCHECK(details.location() != kField ||
  78            layout_descriptor->IsTagged(details.field_index()));
  79     return handle(layout_descriptor, map->GetIsolate());
  80   }
  81   int field_index = details.field_index();
  82   int new_capacity = field_index + details.field_width_in_words();
  83   if (new_capacity > layout_descriptor->capacity()) {
  84     // Current map's layout descriptor runs out of space, so use the full
  85     // layout descriptor.
  86     return full_layout_descriptor;
  87   }
  88
  89   layout_descriptor = layout_descriptor->SetRawData(field_index);
  90   if (details.field_width_in_words() > 1) {
  91     layout_descriptor = layout_descriptor->SetRawData(field_index + 1);
  92   }
  93   return handle(layout_descriptor, map->GetIsolate());
  94 }
  95
  96
  97 Handle<LayoutDescriptor> LayoutDescriptor::EnsureCapacity(
  98     Isolate* isolate, Handle<LayoutDescriptor> layout_descriptor,
  99     int new_capacity) {
 100   int old_capacity = layout_descriptor->capacity();
 101   if (new_capacity <= old_capacity) {
 102     return layout_descriptor;
 103   }
 104   Handle<LayoutDescriptor> new_layout_descriptor =
 105       LayoutDescriptor::New(isolate, new_capacity);
 106   DCHECK(new_layout_descriptor->IsSlowLayout());
 107
 108   if (layout_descriptor->IsSlowLayout()) {
 109     memcpy(new_layout_descriptor->DataPtr(), layout_descriptor->DataPtr(),
 110            layout_descriptor->DataSize());
 111     return new_layout_descriptor;
 112   } else {
 113     // Fast layout.
 114     uint32_t value =
 115         static_cast<uint32_t>(Smi::cast(*layout_descriptor)->value());
 116     new_layout_descriptor->set(0, value);
 117     return new_layout_descriptor;
 118   }
 119 }
 120
 121
 122 bool LayoutDescriptor::IsTagged(int field_index, int max_sequence_length,
 123                                 int* out_sequence_length) {
 124   DCHECK(max_sequence_length > 0);
 125   if (IsFastPointerLayout()) {
 126     *out_sequence_length = max_sequence_length;
 127     return true;
 128   }
 129
 130   int layout_word_index;
 131   int layout_bit_index;
 132
 133   if (!GetIndexes(field_index, &layout_word_index, &layout_bit_index)) {
 134     // Out of bounds queries are considered tagged.
 135     *out_sequence_length = max_sequence_length;
 136     return true;
 137   }
 138   uint32_t layout_mask = static_cast<uint32_t>(1) << layout_bit_index;
 139
 140   uint32_t value = IsSlowLayout()
 141                        ? get_scalar(layout_word_index)
 142                        : static_cast<uint32_t>(Smi::cast(this)->value());
 143
 144   bool is_tagged = (value & layout_mask) == 0;
 145   if (!is_tagged) value = ~value;  // Count set bits instead of cleared bits.
 146   value = value & ~(layout_mask - 1);  // Clear bits we are not interested in.
 147   int sequence_length = CountTrailingZeros32(value) - layout_bit_index;
 148
 149   if (layout_bit_index + sequence_length == kNumberOfBits) {
 150     // This is a contiguous sequence till the end of current word, proceed
 151     // counting in the subsequent words.
 152     if (IsSlowLayout()) {
 153       int len = length();
 154       ++layout_word_index;
 155       for (; layout_word_index < len; layout_word_index++) {
 156         value = get_scalar(layout_word_index);
 157         bool cur_is_tagged = (value & 1) == 0;
 158         if (cur_is_tagged != is_tagged) break;
 159         if (!is_tagged) value = ~value;  // Count set bits instead.
 160         int cur_sequence_length = CountTrailingZeros32(value);
 161         sequence_length += cur_sequence_length;
 162         if (sequence_length >= max_sequence_length) break;
 163         if (cur_sequence_length != kNumberOfBits) break;
 164       }
 165     }
 166     if (is_tagged && (field_index + sequence_length == capacity())) {
 167       // The contiguous sequence of tagged fields lasts till the end of the
 168       // layout descriptor which means that all the fields starting from
 169       // field_index are tagged.
 170       sequence_length = std::numeric_limits<int>::max();
 171     }
 172   }
 173   *out_sequence_length = Min(sequence_length, max_sequence_length);
 174   return is_tagged;
 175 }
 176
 177
 178 Handle<LayoutDescriptor> LayoutDescriptor::NewForTesting(Isolate* isolate,
 179                                                          int length) {
 180   return New(isolate, length);
 181 }
 182
 183
 184 LayoutDescriptor* LayoutDescriptor::SetTaggedForTesting(int field_index,
 185                                                         bool tagged) {
 186   return SetTagged(field_index, tagged);
 187 }
 188
 189
 190 bool LayoutDescriptorHelper::IsTagged(
 191     int offset_in_bytes, int end_offset,
 192     int* out_end_of_contiguous_region_offset) {
 193   DCHECK(IsAligned(offset_in_bytes, kPointerSize));
 194   DCHECK(IsAligned(end_offset, kPointerSize));
 195   DCHECK(offset_in_bytes < end_offset);
 196   if (all_fields_tagged_) {
 197     *out_end_of_contiguous_region_offset = end_offset;
 198     DCHECK(offset_in_bytes < *out_end_of_contiguous_region_offset);
 199     return true;
 200   }
 201   int max_sequence_length = (end_offset - offset_in_bytes) / kPointerSize;
 202   int field_index = Max(0, (offset_in_bytes - header_size_) / kPointerSize);
 203   int sequence_length;
 204   bool tagged = layout_descriptor_->IsTagged(field_index, max_sequence_length,
 205                                              &sequence_length);
 206   DCHECK(sequence_length > 0);
 207   if (offset_in_bytes < header_size_) {
 208     // Object headers do not contain non-tagged fields. Check if the contiguous
 209     // region continues after the header.
 210     if (tagged) {
 211       // First field is tagged, calculate end offset from there.
 212       *out_end_of_contiguous_region_offset =
 213           header_size_ + sequence_length * kPointerSize;
 214
 215     } else {
 216       *out_end_of_contiguous_region_offset = header_size_;
 217     }
 218     DCHECK(offset_in_bytes < *out_end_of_contiguous_region_offset);
 219     return true;
 220   }
 221   *out_end_of_contiguous_region_offset =
 222       offset_in_bytes + sequence_length * kPointerSize;
 223   DCHECK(offset_in_bytes < *out_end_of_contiguous_region_offset);
 224   return tagged;
 225 }
 226
 227
 228 LayoutDescriptor* LayoutDescriptor::Trim(Heap* heap, Map* map,
 229                                          DescriptorArray* descriptors,
 230                                          int num_descriptors) {
 231   DisallowHeapAllocation no_allocation;
 232   // Fast mode descriptors are never shared and therefore always fully
 233   // correspond to their map.
 234   if (!IsSlowLayout()) return this;
 235
 236   int layout_descriptor_length =
 237       CalculateCapacity(map, descriptors, num_descriptors);
 238   // It must not become fast-mode descriptor here, because otherwise it has to
 239   // be fast pointer layout descriptor already but it's is slow mode now.
 240   DCHECK_LT(kSmiValueSize, layout_descriptor_length);
 241
 242   // Trim, clean and reinitialize this slow-mode layout descriptor.
 243   int array_length = GetSlowModeBackingStoreLength(layout_descriptor_length);
 244   int current_length = length();
 245   if (current_length != array_length) {
 246     DCHECK_LT(array_length, current_length);
 247     int delta = current_length - array_length;
 248     heap->RightTrimFixedArray<Heap::SEQUENTIAL_TO_SWEEPER>(this, delta);
 249   }
 250   memset(DataPtr(), 0, DataSize());
 251   LayoutDescriptor* layout_descriptor =
 252       Initialize(this, map, descriptors, num_descriptors);
 253   DCHECK_EQ(this, layout_descriptor);
 254   return layout_descriptor;
 255 }
 256
 257
 258 bool LayoutDescriptor::IsConsistentWithMap(Map* map, bool check_tail) {
 259   if (FLAG_unbox_double_fields) {
 260     DescriptorArray* descriptors = map->instance_descriptors();
 261     int nof_descriptors = map->NumberOfOwnDescriptors();
 262     int last_field_index = 0;
 263     for (int i = 0; i < nof_descriptors; i++) {
 264       PropertyDetails details = descriptors->GetDetails(i);
 265       if (details.location() != kField) continue;
 266       FieldIndex field_index = FieldIndex::ForDescriptor(map, i);
 267       bool tagged_expected =
 268           !field_index.is_inobject() || !details.representation().IsDouble();
 269       for (int bit = 0; bit < details.field_width_in_words(); bit++) {
 270         bool tagged_actual = IsTagged(details.field_index() + bit);
 271         DCHECK_EQ(tagged_expected, tagged_actual);
 272         if (tagged_actual != tagged_expected) return false;
 273       }
 274       last_field_index =
 275           Max(last_field_index,
 276               details.field_index() + details.field_width_in_words());
 277     }
 278     if (check_tail) {
 279       int n = capacity();
 280       for (int i = last_field_index; i < n; i++) {
 281         DCHECK(IsTagged(i));
 282       }
 283     }
 284   }
 285   return true;
 286 }
 287 }  // namespace internal
 288 }  // namespace v8