chromium/v8/src/objects/transitions-inl.h

// Copyright 2012 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_TRANSITIONS_INL_H_
#define V8_OBJECTS_TRANSITIONS_INL_H_

#include <type_traits>

#include "src/objects/fixed-array-inl.h"
#include "src/objects/maybe-object-inl.h"
#include "src/objects/slots.h"
#include "src/objects/smi.h"
#include "src/objects/transitions.h"

// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"

namespace v8 {
namespace internal {

// static
Tagged<TransitionArray> TransitionsAccessor::GetTransitionArray(
    Isolate* isolate, Tagged<MaybeObject> raw_transitions) { … }

// static
Tagged<TransitionArray> TransitionsAccessor::GetTransitionArray(
    Isolate* isolate, DirectHandle<Map> map) { … }

Tagged<TransitionArray> TransitionsAccessor::transitions() { … }

OBJECT_CONSTRUCTORS_IMPL(TransitionArray, WeakFixedArray)

bool TransitionArray::HasPrototypeTransitions() { … }

Tagged<WeakFixedArray> TransitionArray::GetPrototypeTransitions() { … }

bool TransitionArray::HasSideStepTransitions() { … }

bool TransitionsAccessor::HasSideStepTransitions() { … }

Tagged<Object> TransitionsAccessor::GetSideStepTransition(
    SideStepTransition::Kind kind) { … }

void TransitionsAccessor::SetSideStepTransition(SideStepTransition::Kind kind,
                                                Tagged<Object> object) { … }

Tagged<WeakFixedArray> TransitionArray::GetSideStepTransitions() { … }

HeapObjectSlot TransitionArray::GetKeySlot(int transition_number) { … }

void TransitionArray::SetPrototypeTransitions(
    Tagged<WeakFixedArray> transitions) { … }

int TransitionArray::NumberOfPrototypeTransitions(
    Tagged<WeakFixedArray> proto_transitions) { … }

Tagged<Name> TransitionArray::GetKey(int transition_number) { … }

Tagged<Name> TransitionArray::GetKey(InternalIndex index) { … }

Tagged<Name> TransitionsAccessor::GetKey(int transition_number) { … }

void TransitionArray::SetKey(int transition_number, Tagged<Name> key) { … }

HeapObjectSlot TransitionArray::GetTargetSlot(int transition_number) { … }

// static
PropertyDetails TransitionsAccessor::GetTargetDetails(Tagged<Name> name,
                                                      Tagged<Map> target) { … }

PropertyDetails TransitionsAccessor::GetSimpleTargetDetails(
    Tagged<Map> transition) { … }

// static
Tagged<Name> TransitionsAccessor::GetSimpleTransitionKey(
    Tagged<Map> transition) { … }

// static
Tagged<Map> TransitionsAccessor::GetTargetFromRaw(Tagged<MaybeObject> raw) { … }

Tagged<MaybeObject> TransitionArray::GetRawTarget(int transition_number) { … }

Tagged<Map> TransitionArray::GetTarget(int transition_number) { … }

Tagged<Map> TransitionsAccessor::GetTarget(int transition_number) { … }

void TransitionArray::SetRawTarget(int transition_number,
                                   Tagged<MaybeObject> value) { … }

bool TransitionArray::GetTargetIfExists(int transition_number, Isolate* isolate,
                                        Tagged<Map>* target) { … }

int TransitionArray::SearchNameForTesting(Tagged<Name> name,
                                          int* out_insertion_index) { … }

Tagged<Map> TransitionArray::SearchAndGetTargetForTesting(
    PropertyKind kind, Tagged<Name> name, PropertyAttributes attributes) { … }

int TransitionArray::SearchSpecial(Tagged<Symbol> symbol,
                                   bool concurrent_search,
                                   int* out_insertion_index) { … }

int TransitionArray::SearchName(Tagged<Name> name, bool concurrent_search,
                                int* out_insertion_index) { … }

TransitionsAccessor::TransitionsAccessor(Isolate* isolate, Tagged<Map> map,
                                         bool concurrent_access)
    : … { … }

int TransitionsAccessor::Capacity() { … }

// static
TransitionsAccessor::Encoding TransitionsAccessor::GetEncoding(
    Isolate* isolate, Tagged<MaybeObject> raw_transitions) { … }

// static
TransitionsAccessor::Encoding TransitionsAccessor::GetEncoding(
    Isolate* isolate, Tagged<TransitionArray> array) { … }

// static
TransitionsAccessor::Encoding TransitionsAccessor::GetEncoding(
    Isolate* isolate, DirectHandle<Map> map) { … }

// static
MaybeHandle<Map> TransitionsAccessor::SearchTransition(
    Isolate* isolate, DirectHandle<Map> map, Tagged<Name> name,
    PropertyKind kind, PropertyAttributes attributes) { … }

// static
MaybeHandle<Map> TransitionsAccessor::SearchSpecial(Isolate* isolate,
                                                    DirectHandle<Map> map,
                                                    Tagged<Symbol> name) { … }

int TransitionArray::number_of_transitions() const { … }

int TransitionArray::CompareKeys(Tagged<Name> key1, uint32_t hash1,
                                 PropertyKind kind1,
                                 PropertyAttributes attributes1,
                                 Tagged<Name> key2, uint32_t hash2,
                                 PropertyKind kind2,
                                 PropertyAttributes attributes2) { … }

int TransitionArray::CompareNames(Tagged<Name> key1, uint32_t hash1,
                                  Tagged<Name> key2, uint32_t hash2) { … }

int TransitionArray::CompareDetails(PropertyKind kind1,
                                    PropertyAttributes attributes1,
                                    PropertyKind kind2,
                                    PropertyAttributes attributes2) { … }

void TransitionArray::Set(int transition_number, Tagged<Name> key,
                          Tagged<MaybeObject> target) { … }

Tagged<Name> TransitionArray::GetSortedKey(int transition_number) { … }

int TransitionArray::number_of_entries() const { … }

int TransitionArray::Capacity() { … }

void TransitionArray::SetNumberOfTransitions(int number_of_transitions) { … }

template <typename Char>
bool TransitionsAccessor::IsExpectedTransition(
    Tagged<Name> transition_name, Tagged<Map> transition_target,
    base::Vector<const Char> key_chars) { … }

template <typename Char>
std::pair<Handle<String>, Handle<Map>> TransitionsAccessor::ExpectedTransition(
    base::Vector<const Char> key_chars) { … }

template <typename Callback, typename ProtoCallback, typename SideStepCallback,
          bool with_key>
void TransitionsAccessor::ForEachTransitionWithKey(
    DisallowGarbageCollection* no_gc, Callback callback,
    ProtoCallback proto_transition_callback,
    SideStepCallback side_step_transition_callback) { … }

}  // namespace internal
}  // namespace v8

#include "src/objects/object-macros-undef.h"

#endif  // V8_OBJECTS_TRANSITIONS_INL_H_