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
10namespace v8 {
11namespace internal {
12
13LayoutDescriptor* LayoutDescriptor::FromSmi(Smi* smi) {
14  return LayoutDescriptor::cast(smi);
15}
16
17
18Handle<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
29bool 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
39LayoutDescriptor* LayoutDescriptor::FastPointerLayout() {
40  return LayoutDescriptor::FromSmi(Smi::FromInt(0));
41}
42
43
44bool 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
59LayoutDescriptor* LayoutDescriptor::SetRawData(int field_index) {
60  return SetTagged(field_index, false);
61}
62
63
64LayoutDescriptor* 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
95bool 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
117bool LayoutDescriptor::IsFastPointerLayout() {
118  return this == FastPointerLayout();
119}
120
121
122bool LayoutDescriptor::IsFastPointerLayout(Object* layout_descriptor) {
123  return layout_descriptor == FastPointerLayout();
124}
125
126
127bool LayoutDescriptor::IsSlowLayout() { return !IsSmi(); }
128
129
130int LayoutDescriptor::capacity() {
131  return IsSlowLayout() ? (length() * kNumberOfBits) : kSmiValueSize;
132}
133
134
135LayoutDescriptor* 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
151int 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
167int 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
199LayoutDescriptor* 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.
224LayoutDescriptorHelper::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
244bool 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