js-array-buffer.cc | Explore in Territory

// Copyright 2018 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/js-array-buffer.h"

#include "src/execution/protectors-inl.h"
#include "src/logging/counters.h"
#include "src/objects/js-array-buffer-inl.h"
#include "src/objects/property-descriptor.h"

namespace v8 {
namespace internal {

namespace {

// ES#sec-canonicalnumericindexstring
// Returns true if the lookup_key represents a valid index string.
bool CanonicalNumericIndexString(Isolate* isolate,
                                 const PropertyKey& lookup_key,
                                 bool* is_minus_zero) { … }
}  // anonymous namespace

void JSArrayBuffer::Setup(SharedFlag shared, ResizableFlag resizable,
                          std::shared_ptr<BackingStore> backing_store,
                          Isolate* isolate) { … }

void JSArrayBuffer::Attach(std::shared_ptr<BackingStore> backing_store) { … }

Maybe<bool> JSArrayBuffer::Detach(DirectHandle<JSArrayBuffer> buffer,
                                  bool force_for_wasm_memory,
                                  Handle<Object> maybe_key) { … }

void JSArrayBuffer::DetachInternal(bool force_for_wasm_memory,
                                   Isolate* isolate) { … }

size_t JSArrayBuffer::GsabByteLength(Isolate* isolate,
                                     Address raw_array_buffer) { … }

// static
Maybe<bool> JSArrayBuffer::GetResizableBackingStorePageConfiguration(
    Isolate* isolate, size_t byte_length, size_t max_byte_length,
    ShouldThrow should_throw, size_t* page_size, size_t* initial_pages,
    size_t* max_pages) { … }

ArrayBufferExtension* JSArrayBuffer::EnsureExtension() { … }

std::shared_ptr<BackingStore> JSArrayBuffer::RemoveExtension() { … }

void JSArrayBuffer::MarkExtension() { … }

void JSArrayBuffer::YoungMarkExtension() { … }

void JSArrayBuffer::YoungMarkExtensionPromoted() { … }

Handle<JSArrayBuffer> JSTypedArray::GetBuffer() { … }

// ES#sec-integer-indexed-exotic-objects-defineownproperty-p-desc
// static
Maybe<bool> JSTypedArray::DefineOwnProperty(Isolate* isolate,
                                            Handle<JSTypedArray> o,
                                            Handle<Object> key,
                                            PropertyDescriptor* desc,
                                            Maybe<ShouldThrow> should_throw) { … }

ExternalArrayType JSTypedArray::type() { … }

size_t JSTypedArray::element_size() const { … }

size_t JSTypedArray::LengthTrackingGsabBackedTypedArrayLength(
    Isolate* isolate, Address raw_array) { … }

size_t JSTypedArray::GetVariableLengthOrOutOfBounds(bool& out_of_bounds) const { … }

}  // namespace internal
}  // namespace v8
chromium/v8/src/objects/js-array-buffer.cc
