chromium/v8/src/objects/fixed-array.cc

// Copyright 2023 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/fixed-array.h"

#include "src/objects/map-inl.h"

namespace v8 {
namespace internal {

int FixedArrayBase::GetMaxLengthForNewSpaceAllocation(ElementsKind kind) { … }

bool FixedArrayBase::IsCowArray() const { … }

Handle<FixedArray> FixedArray::SetAndGrow(Isolate* isolate,
                                          Handle<FixedArray> array, int index,
                                          DirectHandle<Object> value) { … }

void FixedArray::RightTrim(Isolate* isolate, int new_capacity) { … }

Handle<FixedArray> FixedArray::RightTrimOrEmpty(Isolate* isolate,
                                                Handle<FixedArray> array,
                                                int new_length) { … }

// static
Handle<ArrayList> ArrayList::Add(Isolate* isolate, Handle<ArrayList> array,
                                 Tagged<Smi> obj, AllocationType allocation) { … }

// static
Handle<ArrayList> ArrayList::Add(Isolate* isolate, Handle<ArrayList> array,
                                 DirectHandle<Object> obj,
                                 AllocationType allocation) { … }

// static
Handle<ArrayList> ArrayList::Add(Isolate* isolate, Handle<ArrayList> array,
                                 DirectHandle<Object> obj0,
                                 DirectHandle<Object> obj1,
                                 AllocationType allocation) { … }

// static
Handle<FixedArray> ArrayList::ToFixedArray(Isolate* isolate,
                                           DirectHandle<ArrayList> array,
                                           AllocationType allocation) { … }

void ArrayList::RightTrim(Isolate* isolate, int new_capacity) { … }

// static
Handle<ArrayList> ArrayList::EnsureSpace(Isolate* isolate,
                                         Handle<ArrayList> array, int length,
                                         AllocationType allocation) { … }

// static
Handle<WeakArrayList> WeakArrayList::AddToEnd(Isolate* isolate,
                                              Handle<WeakArrayList> array,
                                              MaybeObjectHandle value) { … }

Handle<WeakArrayList> WeakArrayList::AddToEnd(Isolate* isolate,
                                              Handle<WeakArrayList> array,
                                              MaybeObjectHandle value1,
                                              Tagged<Smi> value2) { … }

// static
Handle<WeakArrayList> WeakArrayList::Append(Isolate* isolate,
                                            Handle<WeakArrayList> array,
                                            MaybeObjectHandle value,
                                            AllocationType allocation) { … }

void WeakArrayList::Compact(Isolate* isolate) { … }

bool WeakArrayList::IsFull() const { … }

// static
Handle<WeakArrayList> WeakArrayList::EnsureSpace(Isolate* isolate,
                                                 Handle<WeakArrayList> array,
                                                 int length,
                                                 AllocationType allocation) { … }

int WeakArrayList::CountLiveWeakReferences() const { … }

int WeakArrayList::CountLiveElements() const { … }

bool WeakArrayList::RemoveOne(MaybeObjectHandle value) { … }

bool WeakArrayList::Contains(Tagged<MaybeObject> value) { … }

}  // namespace internal
}  // namespace v8