blob: 76dd3f618bb0f59a7330f15f9c45ed1449674d75 [file] [log] [blame]
// Copyright 2014 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_OBJECTS_LAYOUT_DESCRIPTOR_INL_H_
#define V8_OBJECTS_LAYOUT_DESCRIPTOR_INL_H_
#include "src/objects/layout-descriptor.h"
#include "src/handles/handles-inl.h"
#include "src/objects/descriptor-array-inl.h"
#include "src/objects/fixed-array-inl.h"
#include "src/objects/objects-inl.h"
#include "src/objects/smi.h"
// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"
namespace v8 {
namespace internal {
LayoutDescriptor::LayoutDescriptor(Address ptr)
: ByteArray(ptr, AllowInlineSmiStorage::kAllowBeingASmi) {
SLOW_DCHECK(IsLayoutDescriptor());
}
CAST_ACCESSOR(LayoutDescriptor)
LayoutDescriptor LayoutDescriptor::FromSmi(Smi smi) {
return LayoutDescriptor::cast(smi);
}
Handle<LayoutDescriptor> LayoutDescriptor::New(Isolate* isolate, int length) {
if (length <= kBitsInSmiLayout) {
// The whole bit vector fits into a smi.
return handle(LayoutDescriptor::FromSmi(Smi::zero()), isolate);
}
int backing_store_length = GetSlowModeBackingStoreLength(length);
Handle<LayoutDescriptor> result =
Handle<LayoutDescriptor>::cast(isolate->factory()->NewByteArray(
backing_store_length, AllocationType::kOld));
memset(reinterpret_cast<void*>(result->GetDataStartAddress()), 0,
result->DataSize());
return result;
}
bool LayoutDescriptor::InobjectUnboxedField(int inobject_properties,
PropertyDetails details) {
if (details.location() != kField || !details.representation().IsDouble()) {
return false;
}
// We care only about in-object properties.
return details.field_index() < inobject_properties;
}
LayoutDescriptor LayoutDescriptor::FastPointerLayout() {
return LayoutDescriptor::FromSmi(Smi::zero());
}
bool LayoutDescriptor::GetIndexes(int field_index, int* layout_word_index,
int* layout_bit_index) {
if (static_cast<unsigned>(field_index) >= static_cast<unsigned>(capacity())) {
return false;
}
*layout_word_index = field_index / kBitsPerLayoutWord;
CHECK((!IsSmi() && (*layout_word_index < length())) ||
(IsSmi() && (*layout_word_index < 1)));
*layout_bit_index = field_index % kBitsPerLayoutWord;
return true;
}
LayoutDescriptor LayoutDescriptor::SetRawData(int field_index) {
return SetTagged(field_index, false);
}
LayoutDescriptor LayoutDescriptor::SetTagged(int field_index, bool tagged) {
int layout_word_index = 0;
int layout_bit_index = 0;
CHECK(GetIndexes(field_index, &layout_word_index, &layout_bit_index));
uint32_t layout_mask = static_cast<uint32_t>(1) << layout_bit_index;
if (IsSlowLayout()) {
uint32_t value = get_layout_word(layout_word_index);
if (tagged) {
value &= ~layout_mask;
} else {
value |= layout_mask;
}
set_layout_word(layout_word_index, value);
return *this;
} else {
uint32_t value = static_cast<uint32_t>(Smi::ToInt(*this));
if (tagged) {
value &= ~layout_mask;
} else {
value |= layout_mask;
}
return LayoutDescriptor::FromSmi(Smi::FromInt(static_cast<int>(value)));
}
}
bool LayoutDescriptor::IsTagged(int field_index) {
if (IsFastPointerLayout()) return true;
int layout_word_index;
int layout_bit_index;
if (!GetIndexes(field_index, &layout_word_index, &layout_bit_index)) {
// All bits after Out of bounds queries
return true;
}
uint32_t layout_mask = static_cast<uint32_t>(1) << layout_bit_index;
if (IsSlowLayout()) {
uint32_t value = get_layout_word(layout_word_index);
return (value & layout_mask) == 0;
} else {
uint32_t value = static_cast<uint32_t>(Smi::ToInt(*this));
return (value & layout_mask) == 0;
}
}
bool LayoutDescriptor::IsFastPointerLayout() {
return *this == FastPointerLayout();
}
bool LayoutDescriptor::IsFastPointerLayout(Object layout_descriptor) {
return layout_descriptor == FastPointerLayout();
}
bool LayoutDescriptor::IsSlowLayout() { return !IsSmi(); }
int LayoutDescriptor::capacity() {
return IsSlowLayout() ? (length() * kBitsPerByte) : kBitsInSmiLayout;
}
LayoutDescriptor LayoutDescriptor::cast_gc_safe(Object object) {
// The map word of the object can be a forwarding pointer during
// object evacuation phase of GC. Since the layout descriptor methods
// for checking whether a field is tagged or not do not depend on the
// object map, it should be safe.
return LayoutDescriptor::unchecked_cast(object);
}
int LayoutDescriptor::GetSlowModeBackingStoreLength(int length) {
DCHECK_LT(0, length);
// We allocate kTaggedSize rounded blocks of memory anyway so we increase
// the length of allocated array to utilize that "lost" space which could
// also help to avoid layout descriptor reallocations.
return RoundUp(length, kBitsPerByte * kTaggedSize) / kBitsPerByte;
}
int LayoutDescriptor::CalculateCapacity(Map map, DescriptorArray descriptors,
int num_descriptors) {
int inobject_properties = map.GetInObjectProperties();
if (inobject_properties == 0) return 0;
DCHECK_LE(num_descriptors, descriptors.number_of_descriptors());
int layout_descriptor_length;
const int kMaxWordsPerField = kDoubleSize / kTaggedSize;
if (num_descriptors <= kBitsInSmiLayout / kMaxWordsPerField) {
// Even in the "worst" case (all fields are doubles) it would fit into
// a Smi, so no need to calculate length.
layout_descriptor_length = kBitsInSmiLayout;
} else {
layout_descriptor_length = 0;
for (InternalIndex i : InternalIndex::Range(num_descriptors)) {
PropertyDetails details = descriptors.GetDetails(i);
if (!InobjectUnboxedField(inobject_properties, details)) continue;
int field_index = details.field_index();
int field_width_in_words = details.field_width_in_words();
layout_descriptor_length = std::max(layout_descriptor_length,
field_index + field_width_in_words);
}
}
layout_descriptor_length =
std::min(layout_descriptor_length, inobject_properties);
return layout_descriptor_length;
}
LayoutDescriptor LayoutDescriptor::Initialize(
LayoutDescriptor layout_descriptor, Map map, DescriptorArray descriptors,
int num_descriptors) {
DisallowHeapAllocation no_allocation;
int inobject_properties = map.GetInObjectProperties();
for (InternalIndex i : InternalIndex::Range(num_descriptors)) {
PropertyDetails details = descriptors.GetDetails(i);
if (!InobjectUnboxedField(inobject_properties, details)) {
DCHECK(details.location() != kField ||
layout_descriptor.IsTagged(details.field_index()));
continue;
}
int field_index = details.field_index();
layout_descriptor = layout_descriptor.SetRawData(field_index);
if (details.field_width_in_words() > 1) {
layout_descriptor = layout_descriptor.SetRawData(field_index + 1);
}
}
return layout_descriptor;
}
int LayoutDescriptor::number_of_layout_words() {
return length() / kUInt32Size;
}
uint32_t LayoutDescriptor::get_layout_word(int index) const {
return get_uint32_relaxed(index);
}
void LayoutDescriptor::set_layout_word(int index, uint32_t value) {
set_uint32_relaxed(index, value);
}
// LayoutDescriptorHelper is a helper class for querying whether inobject
// property at offset is Double or not.
LayoutDescriptorHelper::LayoutDescriptorHelper(Map map)
: all_fields_tagged_(true),
header_size_(0),
layout_descriptor_(LayoutDescriptor::FastPointerLayout()) {
if (!FLAG_unbox_double_fields) return;
layout_descriptor_ = map.layout_descriptor_gc_safe();
if (layout_descriptor_.IsFastPointerLayout()) {
return;
}
header_size_ = map.GetInObjectPropertiesStartInWords() * kTaggedSize;
DCHECK_GE(header_size_, 0);
all_fields_tagged_ = false;
}
bool LayoutDescriptorHelper::IsTagged(int offset_in_bytes) {
DCHECK(IsAligned(offset_in_bytes, kTaggedSize));
if (all_fields_tagged_) return true;
// Object headers do not contain non-tagged fields.
if (offset_in_bytes < header_size_) return true;
int field_index = (offset_in_bytes - header_size_) / kTaggedSize;
return layout_descriptor_.IsTagged(field_index);
}
} // namespace internal
} // namespace v8
#include "src/objects/object-macros-undef.h"
#endif // V8_OBJECTS_LAYOUT_DESCRIPTOR_INL_H_