lookup.cc | Explore in Territory

// 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.

#include "src/objects/lookup.h"

#include <optional>

#include "src/common/globals.h"
#include "src/deoptimizer/deoptimizer.h"
#include "src/execution/isolate-inl.h"
#include "src/execution/protectors-inl.h"
#include "src/init/bootstrapper.h"
#include "src/logging/counters.h"
#include "src/objects/arguments-inl.h"
#include "src/objects/elements.h"
#include "src/objects/field-type.h"
#include "src/objects/hash-table-inl.h"
#include "src/objects/heap-number-inl.h"
#include "src/objects/js-shared-array-inl.h"
#include "src/objects/js-struct-inl.h"
#include "src/objects/map-updater.h"
#include "src/objects/ordered-hash-table.h"
#include "src/objects/property-details.h"
#include "src/objects/struct-inl.h"

namespace v8::internal {

PropertyKey::PropertyKey(Isolate* isolate, Handle<Object> key, bool* success) { … }

template <bool is_element>
void LookupIterator::Start() { … }

template void LookupIterator::Start<true>();
template void LookupIterator::Start<false>();

void LookupIterator::Next() { … }

template <bool is_element>
void LookupIterator::NextInternal(Tagged<Map> map, Tagged<JSReceiver> holder) { … }

template <bool is_element>
void LookupIterator::RestartInternal(InterceptorState interceptor_state) { … }

template void LookupIterator::RestartInternal<true>(InterceptorState);
template void LookupIterator::RestartInternal<false>(InterceptorState);

// static
MaybeHandle<JSReceiver> LookupIterator::GetRootForNonJSReceiver(
    Isolate* isolate, DirectHandle<JSPrimitive> lookup_start_object,
    size_t index, Configuration configuration) { … }

Handle<Map> LookupIterator::GetReceiverMap() const { … }

bool LookupIterator::HasAccess() const { … }

template <bool is_element>
void LookupIterator::ReloadPropertyInformation() { … }

// static
void LookupIterator::InternalUpdateProtector(Isolate* isolate,
                                             Handle<Object> receiver_generic,
                                             DirectHandle<Name> name) { … }

void LookupIterator::PrepareForDataProperty(DirectHandle<Object> value) { … }

void LookupIterator::ReconfigureDataProperty(Handle<Object> value,
                                             PropertyAttributes attributes) { … }

// Can only be called when the receiver is a JSObject, or when the name is a
// private field, otherwise JSProxy has to be handled via a trap.
// Adding properties to primitive values is not observable.
void LookupIterator::PrepareTransitionToDataProperty(
    Handle<JSReceiver> receiver, DirectHandle<Object> value,
    PropertyAttributes attributes, StoreOrigin store_origin) { … }

void LookupIterator::ApplyTransitionToDataProperty(
    Handle<JSReceiver> receiver) { … }

void LookupIterator::Delete() { … }

void LookupIterator::TransitionToAccessorProperty(
    DirectHandle<Object> getter, DirectHandle<Object> setter,
    PropertyAttributes attributes) { … }

void LookupIterator::TransitionToAccessorPair(Handle<Object> pair,
                                              PropertyAttributes attributes) { … }

bool LookupIterator::HolderIsReceiver() const { … }

bool LookupIterator::HolderIsReceiverOrHiddenPrototype() const { … }

Handle<Object> LookupIterator::FetchValue(
    AllocationPolicy allocation_policy) const { … }

bool LookupIterator::CanStayConst(Tagged<Object> value) const { … }

bool LookupIterator::DictCanStayConst(Tagged<Object> value) const { … }

int LookupIterator::GetFieldDescriptorIndex() const { … }

int LookupIterator::GetAccessorIndex() const { … }

FieldIndex LookupIterator::GetFieldIndex() const { … }

Handle<PropertyCell> LookupIterator::GetPropertyCell() const { … }

Handle<Object> LookupIterator::GetAccessors() const { … }

Handle<Object> LookupIterator::GetDataValue(
    AllocationPolicy allocation_policy) const { … }

Handle<Object> LookupIterator::GetDataValue(SeqCstAccessTag tag) const { … }

void LookupIterator::WriteDataValue(DirectHandle<Object> value,
                                    bool initializing_store) { … }

void LookupIterator::WriteDataValue(DirectHandle<Object> value,
                                    SeqCstAccessTag tag) { … }

Handle<Object> LookupIterator::SwapDataValue(DirectHandle<Object> value,
                                             SeqCstAccessTag tag) { … }

Handle<Object> LookupIterator::CompareAndSwapDataValue(
    DirectHandle<Object> expected, DirectHandle<Object> value,
    SeqCstAccessTag tag) { … }

template <bool is_element>
bool LookupIterator::SkipInterceptor(Tagged<JSObject> holder) { … }

Tagged<JSReceiver> LookupIterator::NextHolder(Tagged<Map> map) { … }

LookupIterator::State LookupIterator::NotFound(
    Tagged<JSReceiver> const holder) const { … }

namespace {

template <bool is_element>
bool HasInterceptor(Tagged<Map> map, size_t index) { … }

}  // namespace

template <bool is_element>
LookupIterator::State LookupIterator::LookupInSpecialHolder(
    Tagged<Map> const map, Tagged<JSReceiver> const holder) { … }

template <bool is_element>
LookupIterator::State LookupIterator::LookupInRegularHolder(
    Tagged<Map> const map, Tagged<JSReceiver> const holder) { … }

// This is a specialization of function LookupInRegularHolder above
// which is tailored to test whether an object has an internal marker
// property.
// static
bool LookupIterator::HasInternalMarkerProperty(Isolate* isolate,
                                               Tagged<JSReceiver> const holder,
                                               Handle<Symbol> const marker) { … }

Handle<InterceptorInfo> LookupIterator::GetInterceptorForFailedAccessCheck()
    const { … }

bool LookupIterator::TryLookupCachedProperty(
    DirectHandle<AccessorPair> accessor) { … }

bool LookupIterator::TryLookupCachedProperty() { … }

bool LookupIterator::LookupCachedProperty(
    DirectHandle<AccessorPair> accessor_pair) { … }

// static
std::optional<Tagged<Object>> ConcurrentLookupIterator::TryGetOwnCowElement(
    Isolate* isolate, Tagged<FixedArray> array_elements,
    ElementsKind elements_kind, int array_length, size_t index) { … }

// static
ConcurrentLookupIterator::Result
ConcurrentLookupIterator::TryGetOwnConstantElement(
    Tagged<Object>* result_out, Isolate* isolate, LocalIsolate* local_isolate,
    Tagged<JSObject> holder, Tagged<FixedArrayBase> elements,
    ElementsKind elements_kind, size_t index) { … }

// static
ConcurrentLookupIterator::Result ConcurrentLookupIterator::TryGetOwnChar(
    Tagged<String>* result_out, Isolate* isolate, LocalIsolate* local_isolate,
    Tagged<String> string, size_t index) { … }

// static
std::optional<Tagged<PropertyCell>>
ConcurrentLookupIterator::TryGetPropertyCell(
    Isolate* isolate, LocalIsolate* local_isolate,
    DirectHandle<JSGlobalObject> holder, DirectHandle<Name> name) { … }

}  // namespace v8::internal
chromium/v8/src/objects/lookup.cc
