// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

#include "node_buffer.h"

#include "node.h"

#include "node_blob.h"

#include "node_debug.h"

#include "node_errors.h"

#include "node_external_reference.h"

#include "node_i18n.h"

#include "node_internals.h"

#include "env-inl.h"

#include "simdutf.h"

#include "string_bytes.h"

#include "util-inl.h"

#include "v8-fast-api-calls.h"

#include "v8.h"

#include <stdint.h>

#include <climits>

#include <cstring>

#include "nbytes.h"

#define THROW_AND_RETURN_UNLESS_BUFFER(env, obj) \

THROW_AND_RETURN_IF_NOT_BUFFER(env, obj, "argument") \

#define THROW_AND_RETURN_IF_OOB(r) \

do { \

Maybe<bool> m = (r); \

if (m.IsNothing()) return; \

if (!m.FromJust()) \

return node::THROW_ERR_OUT_OF_RANGE(env, "Index out of range"); \

} while (0) \

namespace node {

namespace Buffer {

using v8::ArrayBuffer;

using v8::ArrayBufferView;

using v8::BackingStore;

using v8::BackingStoreInitializationMode;

using v8::BackingStoreOnFailureMode;

using v8::CFunction;

using v8::Context;

using v8::EscapableHandleScope;

using v8::FastApiCallbackOptions;

using v8::FastOneByteString;

using v8::FunctionCallbackInfo;

using v8::Global;

using v8::HandleScope;

using v8::Int32;

using v8::Integer;

using v8::Isolate;

using v8::Just;

using v8::Local;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Nothing;

using v8::Number;

using v8::Object;

using v8::SharedArrayBuffer;

using v8::String;

using v8::Uint32;

using v8::Uint8Array;

using v8::Value;

namespace {

class CallbackInfo : public Cleanable {

public:

static inline MaybeLocal<ArrayBuffer> CreateTrackedArrayBuffer(

Environment* env,

char* data,

size_t length,

FreeCallback callback,

void* hint);

CallbackInfo(const CallbackInfo&) = delete;

CallbackInfo& operator=(const CallbackInfo&) = delete;

private:

void Clean() override;

inline void OnBackingStoreFree();

inline void CallAndResetCallback();

inline CallbackInfo(Environment* env,

FreeCallback callback,

char* data,

void* hint);

Global<ArrayBuffer> persistent_;

Mutex mutex_; // Protects callback_.

FreeCallback callback_;

char* const data_;

void* const hint_;

Environment* const env_;

};

MaybeLocal<ArrayBuffer> CallbackInfo::CreateTrackedArrayBuffer(

Environment* env,

char* data,

size_t length,

FreeCallback callback,

void* hint) {

CHECK_NOT_NULL(callback);

CHECK_IMPLIES(data == nullptr, length == 0);

CallbackInfo* self = new CallbackInfo(env, callback, data, hint);

std::unique_ptr<BackingStore> bs = AdoptIntoBackingStore(

env->isolate(),

data,

length,

[](void*, size_t, void* arg) {

static_cast<CallbackInfo*>(arg)->OnBackingStoreFree();

},

self);

if (!bs) {

THROW_ERR_MEMORY_ALLOCATION_FAILED(env);

return MaybeLocal<ArrayBuffer>();

}

Local<ArrayBuffer> ab = ArrayBuffer::New(env->isolate(), std::move(bs));

// V8 simply ignores the BackingStore deleter callback if data == nullptr,

// but our API contract requires it being called.

if (data == nullptr) {

ab->Detach(Local<Value>()).Check();

self->OnBackingStoreFree(); // This calls `callback` asynchronously.

} else if (ab->Data() == data) {

// Store the ArrayBuffer so that we can detach it later.

self->persistent_.Reset(env->isolate(), ab);

self->persistent_.SetWeak();

}

return ab;

}

CallbackInfo::CallbackInfo(Environment* env,

FreeCallback callback,

char* data,

void* hint)

: callback_(callback),

data_(data),

hint_(hint),

env_(env) {

env->cleanable_queue()->PushFront(this);

env->external_memory_accounter()->Increase(env->isolate(), sizeof(*this));

}

void CallbackInfo::Clean() {

{

HandleScope handle_scope(env_->isolate());

Local<ArrayBuffer> ab = persistent_.Get(env_->isolate());

if (!ab.IsEmpty() && ab->IsDetachable()) {

ab->Detach(Local<Value>()).Check();

persistent_.Reset();

}

}

// Call the callback in this case, but don't delete `this` yet because the

// BackingStore deleter callback will do so later.

CallAndResetCallback();

}

void CallbackInfo::CallAndResetCallback() {

FreeCallback callback;

{

Mutex::ScopedLock lock(mutex_);

callback = callback_;

callback_ = nullptr;

}

if (callback != nullptr) {

// Clean up all Environment-related state and run the callback.

cleanable_queue_.Remove();

env_->external_memory_accounter()->Decrease(env_->isolate(), sizeof(*this));

callback(data_, hint_);

}

}

void CallbackInfo::OnBackingStoreFree() {

// This method should always release the memory for `this`.

std::unique_ptr<CallbackInfo> self { this };

Mutex::ScopedLock lock(mutex_);

// If callback_ == nullptr, that means that the callback has already run from

// the cleanup hook, and there is nothing left to do here besides to clean

// up the memory involved. In particular, the underlying `Environment` may

// be gone at this point, so don’t attempt to call SetImmediateThreadsafe().

if (callback_ == nullptr) return;

env_->SetImmediateThreadsafe([self = std::move(self)](Environment* env) {

CHECK_EQ(self->env_, env); // Consistency check.

self->CallAndResetCallback();

});

}

// Parse index for external array data. An empty Maybe indicates

// a pending exception. `false` indicates that the index is out-of-bounds.

inline MUST_USE_RESULT Maybe<bool> ParseArrayIndex(Environment* env,

Local<Value> arg,

size_t def,

size_t* ret) {

if (arg->IsUndefined()) {

*ret = def;

return Just(true);

}

int64_t tmp_i;

if (!arg->IntegerValue(env->context()).To(&tmp_i))

return Nothing<bool>();

if (tmp_i < 0)

return Just(false);

// Check that the result fits in a size_t.

// coverity[pointless_expression]

if (static_cast<uint64_t>(tmp_i) > std::numeric_limits<size_t>::max())

return Just(false);

*ret = static_cast<size_t>(tmp_i);

return Just(true);

}

} // anonymous namespace

// Buffer methods

bool HasInstance(Local<Value> val) {

return val->IsArrayBufferView();

}

bool HasInstance(Local<Object> obj) {

return obj->IsArrayBufferView();

}

char* Data(Local<Value> val) {

CHECK(val->IsArrayBufferView());

Local<ArrayBufferView> ui = val.As<ArrayBufferView>();

return static_cast<char*>(ui->Buffer()->Data()) + ui->ByteOffset();

}

char* Data(Local<Object> obj) {

return Data(obj.As<Value>());

}

size_t Length(Local<Value> val) {

CHECK(val->IsArrayBufferView());

Local<ArrayBufferView> ui = val.As<ArrayBufferView>();

return ui->ByteLength();

}

size_t Length(Local<Object> obj) {

CHECK(obj->IsArrayBufferView());

Local<ArrayBufferView> ui = obj.As<ArrayBufferView>();

return ui->ByteLength();

}

MaybeLocal<Uint8Array> New(Environment* env,

Local<ArrayBuffer> ab,

size_t byte_offset,

size_t length) {

CHECK(!env->buffer_prototype_object().IsEmpty());

Local<Uint8Array> ui = Uint8Array::New(ab, byte_offset, length);

if (ui->SetPrototype(env->context(), env->buffer_prototype_object())

.IsNothing()) {

return MaybeLocal<Uint8Array>();

}

return ui;

}

MaybeLocal<Uint8Array> New(Isolate* isolate,

Local<ArrayBuffer> ab,

size_t byte_offset,

size_t length) {

Environment* env = Environment::GetCurrent(isolate);

if (env == nullptr) {

THROW_ERR_BUFFER_CONTEXT_NOT_AVAILABLE(isolate);

return MaybeLocal<Uint8Array>();

}

return New(env, ab, byte_offset, length);

}

MaybeLocal<Object> New(Isolate* isolate,

Local<String> string,

enum encoding enc) {

EscapableHandleScope scope(isolate);

size_t length;

if (!StringBytes::Size(isolate, string, enc).To(&length)) return {};

size_t actual = 0;

std::unique_ptr<BackingStore> store;

if (length > 0) {

store = ArrayBuffer::NewBackingStore(

isolate,

length,

BackingStoreInitializationMode::kZeroInitialized,

BackingStoreOnFailureMode::kReturnNull);

if (!store) [[unlikely]] {

THROW_ERR_MEMORY_ALLOCATION_FAILED(isolate);

return {};

}

actual = StringBytes::Write(

isolate,

static_cast<char*>(store->Data()),

length,

string,

enc);

CHECK(actual <= length);

if (actual > 0) [[likely]] {

if (actual < length) {

std::unique_ptr<BackingStore> old_store = std::move(store);

store = ArrayBuffer::NewBackingStore(

isolate,

actual,

BackingStoreInitializationMode::kUninitialized,

BackingStoreOnFailureMode::kReturnNull);

if (!store) [[unlikely]] {

THROW_ERR_MEMORY_ALLOCATION_FAILED(isolate);

return {};

}

memcpy(store->Data(), old_store->Data(), actual);

}

Local<ArrayBuffer> buf = ArrayBuffer::New(isolate, std::move(store));

Local<Object> obj;

if (!New(isolate, buf, 0, actual).ToLocal(&obj)) [[unlikely]] {

return {};

}

return scope.Escape(obj);

}

}

return scope.EscapeMaybe(New(isolate, 0));

}

MaybeLocal<Object> New(Isolate* isolate, size_t length) {

EscapableHandleScope handle_scope(isolate);

Local<Object> obj;

Environment* env = Environment::GetCurrent(isolate);

if (env == nullptr) {

THROW_ERR_BUFFER_CONTEXT_NOT_AVAILABLE(isolate);

return MaybeLocal<Object>();

}

if (Buffer::New(env, length).ToLocal(&obj))

return handle_scope.Escape(obj);

return Local<Object>();

}

MaybeLocal<Object> New(Environment* env, size_t length) {

Isolate* isolate(env->isolate());

EscapableHandleScope scope(isolate);

// V8 currently only allows a maximum Typed Array index of max Smi.

if (length > kMaxLength) {

isolate->ThrowException(ERR_BUFFER_TOO_LARGE(isolate));

return Local<Object>();

}

Local<ArrayBuffer> ab;

{

std::unique_ptr<BackingStore> bs = ArrayBuffer::NewBackingStore(

isolate,

length,

BackingStoreInitializationMode::kUninitialized,

BackingStoreOnFailureMode::kReturnNull);

if (!bs) [[unlikely]] {

THROW_ERR_MEMORY_ALLOCATION_FAILED(isolate);

return {};

}

CHECK(bs);

ab = ArrayBuffer::New(isolate, std::move(bs));

}

MaybeLocal<Object> obj =

New(env, ab, 0, ab->ByteLength())

.FromMaybe(Local<Uint8Array>());

return scope.EscapeMaybe(obj);

}

MaybeLocal<Object> Copy(Isolate* isolate, const char* data, size_t length) {

EscapableHandleScope handle_scope(isolate);

Environment* env = Environment::GetCurrent(isolate);

if (env == nullptr) {

THROW_ERR_BUFFER_CONTEXT_NOT_AVAILABLE(isolate);

return MaybeLocal<Object>();

}

Local<Object> obj;

if (Buffer::Copy(env, data, length).ToLocal(&obj))

return handle_scope.Escape(obj);

return Local<Object>();

}

MaybeLocal<Object> Copy(Environment* env, const char* data, size_t length) {

Isolate* isolate(env->isolate());

EscapableHandleScope scope(isolate);

// V8 currently only allows a maximum Typed Array index of max Smi.

if (length > kMaxLength) {

isolate->ThrowException(ERR_BUFFER_TOO_LARGE(isolate));

return Local<Object>();

}

std::unique_ptr<BackingStore> bs = ArrayBuffer::NewBackingStore(

isolate,

length,

BackingStoreInitializationMode::kUninitialized,

BackingStoreOnFailureMode::kReturnNull);

if (!bs) [[unlikely]] {

THROW_ERR_MEMORY_ALLOCATION_FAILED(isolate);

return {};

}

if (length > 0) memcpy(bs->Data(), data, length);

Local<ArrayBuffer> ab = ArrayBuffer::New(isolate, std::move(bs));

MaybeLocal<Object> obj =

New(env, ab, 0, ab->ByteLength())

.FromMaybe(Local<Uint8Array>());

return scope.EscapeMaybe(obj);

}

MaybeLocal<Object> New(Isolate* isolate,

char* data,

size_t length,

FreeCallback callback,

void* hint) {

EscapableHandleScope handle_scope(isolate);

Environment* env = Environment::GetCurrent(isolate);

if (env == nullptr) {

callback(data, hint);

THROW_ERR_BUFFER_CONTEXT_NOT_AVAILABLE(isolate);

return MaybeLocal<Object>();

}

return handle_scope.EscapeMaybe(

Buffer::New(env, data, length, callback, hint));

}

MaybeLocal<Object> New(Environment* env,

char* data,

size_t length,

FreeCallback callback,

void* hint) {

EscapableHandleScope scope(env->isolate());

if (length > kMaxLength) {

env->isolate()->ThrowException(ERR_BUFFER_TOO_LARGE(env->isolate()));

callback(data, hint);

return Local<Object>();

}

Local<ArrayBuffer> ab;

if (!CallbackInfo::CreateTrackedArrayBuffer(env, data, length, callback, hint)

.ToLocal(&ab) ||

ab->SetPrivate(env->context(),

env->untransferable_object_private_symbol(),

True(env->isolate()))

.IsNothing()) {

return Local<Object>();

}

MaybeLocal<Uint8Array> maybe_ui = Buffer::New(env, ab, 0, length);

Local<Uint8Array> ui;

if (!maybe_ui.ToLocal(&ui))

return MaybeLocal<Object>();

return scope.Escape(ui);

}

// Warning: This function needs `data` to be allocated with malloc() and not

// necessarily isolate's ArrayBuffer::Allocator.

MaybeLocal<Object> New(Isolate* isolate, char* data, size_t length) {

EscapableHandleScope handle_scope(isolate);

Environment* env = Environment::GetCurrent(isolate);

if (env == nullptr) {

free(data);

THROW_ERR_BUFFER_CONTEXT_NOT_AVAILABLE(isolate);

return MaybeLocal<Object>();

}

Local<Object> obj;

if (Buffer::New(env, data, length).ToLocal(&obj))

return handle_scope.Escape(obj);

return Local<Object>();

}

// The contract for this function is that `data` is allocated with malloc()

// and not necessarily isolate's ArrayBuffer::Allocator.

MaybeLocal<Object> New(Environment* env,

char* data,

size_t length) {

if (length > 0) {

CHECK_NOT_NULL(data);

// V8 currently only allows a maximum Typed Array index of max Smi.

if (length > kMaxLength) {

Isolate* isolate(env->isolate());

isolate->ThrowException(ERR_BUFFER_TOO_LARGE(isolate));

free(data);

return Local<Object>();

}

}

EscapableHandleScope handle_scope(env->isolate());

std::unique_ptr<BackingStore> bs = AdoptIntoBackingStore(

env->isolate(),

data,

length,

[](void* data, size_t, void*) { free(data); },

nullptr);

if (!bs) {

THROW_ERR_MEMORY_ALLOCATION_FAILED(env);

return MaybeLocal<Object>();

}

Local<ArrayBuffer> ab = ArrayBuffer::New(env->isolate(), std::move(bs));

Local<Object> obj;

if (Buffer::New(env, ab, 0, length).ToLocal(&obj))

return handle_scope.Escape(obj);

return Local<Object>();

}

namespace {

template <encoding encoding>

void StringSlice(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

Isolate* isolate = env->isolate();

THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);

ArrayBufferViewContents<char> buffer(args[0]);

auto buffer_length = buffer.length();

const char* data_ptr = buffer.data();

Local<ArrayBufferView> view = args[0].As<ArrayBufferView>();

if (buffer_length == 0) return args.GetReturnValue().SetEmptyString();

size_t start = 0;

size_t end = 0;

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[1], 0, &start));

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[2], buffer_length, &end));

if (end <= start) return args.GetReturnValue().SetEmptyString();

THROW_AND_RETURN_IF_OOB(Just(end <= buffer_length));

size_t length = end - start;

std::unique_ptr<char[]> data_copy;

if (view->Buffer()->IsSharedArrayBuffer()) {

data_copy = std::make_unique_for_overwrite<char[]>(length);

memcpy(data_copy.get(), data_ptr + start, length);

data_ptr = data_copy.get();

start = 0;

}

Local<Value> ret;

if (StringBytes::Encode(isolate, data_ptr + start, length, encoding)

.ToLocal(&ret)) {

args.GetReturnValue().Set(ret);

}

}

// Returns the number of bytes actually copied. This is normally |to_copy|, but

// V8 copies nothing (and returns 0) when the target is backed by a detached or

// immutable ArrayBuffer.

size_t CopyImpl(Local<Value> source_obj,

Local<Value> target_obj,

const size_t target_start,

const size_t source_start,

const size_t to_copy) {

Local<ArrayBufferView> source = source_obj.As<ArrayBufferView>();

Local<ArrayBufferView> target = target_obj.As<ArrayBufferView>();

Local<ArrayBuffer> source_ab = source->Buffer();

Local<ArrayBuffer> target_ab = target->Buffer();

const size_t source_offset = source->ByteOffset() + source_start;

const size_t target_offset = target->ByteOffset() + target_start;

// Defer byte-range clamping and detached/immutable handling to V8. When both

// sides are backed by a SharedArrayBuffer the relaxed atomic overload is

// used, which honors the SharedArrayBuffer memory model. Any other

// combination (both regular, or one of each) goes through the ArrayBuffer

// overload: it operates on the underlying backing store regardless of

// shared-ness, so a plain memmove is performed (matching the historical

// behavior for SharedArrayBuffer-backed buffers). The V8 API has no overload

// that mixes ArrayBuffer and SharedArrayBuffer, so the two must never be

// cross-cast.

if (source_ab->IsSharedArrayBuffer() && target_ab->IsSharedArrayBuffer()) {

return source_ab.As<SharedArrayBuffer>()->CopyArrayBufferBytes(

source_offset,

to_copy,

target_ab.As<SharedArrayBuffer>(),

target_offset);

}

return source_ab->CopyArrayBufferBytes(

source_offset, to_copy, target_ab, target_offset);

}

// Assume caller has properly validated args.

void SlowCopy(const FunctionCallbackInfo<Value>& args) {

Local<Value> source_obj = args[0];

Local<Value> target_obj = args[1];

// Byte offsets and lengths can exceed uint32 for buffers larger than 4 GiB,

// so they are passed and returned as doubles (exact for integers < 2^53).

const size_t target_start =

static_cast<size_t>(args[2].As<Number>()->Value());

const size_t source_start =

static_cast<size_t>(args[3].As<Number>()->Value());

const size_t to_copy = static_cast<size_t>(args[4].As<Number>()->Value());

const size_t copied =

CopyImpl(source_obj, target_obj, target_start, source_start, to_copy);

args.GetReturnValue().Set(static_cast<double>(copied));

}

// Assume caller has properly validated args.

double FastCopy(Local<Value> receiver,

Local<Value> source_obj,

Local<Value> target_obj,

double target_start,

double source_start,

double to_copy,

// NOLINTNEXTLINE(runtime/references)

FastApiCallbackOptions& options) {

TRACK_V8_FAST_API_CALL("buffer.copy");

HandleScope scope(options.isolate);

return static_cast<double>(CopyImpl(source_obj,

target_obj,

static_cast<size_t>(target_start),

static_cast<size_t>(source_start),

static_cast<size_t>(to_copy)));

}

static CFunction fast_copy(CFunction::Make(FastCopy));

void Fill(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

Local<Context> ctx = env->context();

THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);

SPREAD_BUFFER_ARG(args[0], ts_obj);

size_t start = 0;

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[2], 0, &start));

size_t end;

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[3], 0, &end));

size_t fill_length = end - start;

Local<String> str_obj;

size_t str_length;

enum encoding enc;

// OOB Check. Throw the error in JS.

if (start > end || fill_length + start > ts_obj_length)

return args.GetReturnValue().Set(-2);

// First check if Buffer has been passed.

if (Buffer::HasInstance(args[1])) {

SPREAD_BUFFER_ARG(args[1], fill_obj);

str_length = fill_obj_length;

memcpy(

ts_obj_data + start, fill_obj_data, std::min(str_length, fill_length));

goto start_fill;

}

// Then coerce everything that's not a string.

if (!args[1]->IsString()) {

uint32_t val;

if (!args[1]->Uint32Value(ctx).To(&val)) return;

int value = val & 255;

memset(ts_obj_data + start, value, fill_length);

return;

}

if (!args[1]->ToString(env->context()).ToLocal(&str_obj)) {

return;

}

enc = ParseEncoding(env->isolate(), args[4], UTF8);

// Can't use StringBytes::Write() in all cases. For example if attempting

// to write a two byte character into a one byte Buffer.

if (enc == UTF8) {

str_length = str_obj->Utf8LengthV2(env->isolate());

node::Utf8Value str(env->isolate(), args[1]);

memcpy(ts_obj_data + start, *str, std::min(str_length, fill_length));

} else if (enc == UCS2) {

str_length = str_obj->Length() * sizeof(uint16_t);

node::TwoByteValue str(env->isolate(), args[1]);

if constexpr (IsBigEndian())

CHECK(nbytes::SwapBytes16(reinterpret_cast<char*>(&str[0]), str_length));

memcpy(ts_obj_data + start, *str, std::min(str_length, fill_length));

} else {

// Write initial String to Buffer, then use that memory to copy remainder

// of string. Correct the string length for cases like HEX where less than

// the total string length is written.

str_length = StringBytes::Write(

env->isolate(), ts_obj_data + start, fill_length, str_obj, enc);

}

start_fill:

if (str_length >= fill_length)

return;

// If str_length is zero, then either an empty buffer was provided, or Write()

// indicated that no bytes could be written. If no bytes could be written,

// then return -1 because the fill value is invalid. This will trigger a throw

// in JavaScript. Silently failing should be avoided because it can lead to

// buffers with unexpected contents.

if (str_length == 0)

return args.GetReturnValue().Set(-1);

size_t in_there = str_length;

char* ptr = ts_obj_data + start + str_length;

while (in_there < fill_length - in_there) {

memcpy(ptr, ts_obj_data + start, in_there);

ptr += in_there;

in_there *= 2;

}

if (in_there < fill_length) {

memcpy(ptr, ts_obj_data + start, fill_length - in_there);

}

}

template <encoding encoding>

void StringWrite(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);

SPREAD_BUFFER_ARG(args[0], ts_obj);

THROW_AND_RETURN_IF_NOT_STRING(env, args[1], "argument");

Local<String> str;

if (!args[1]->ToString(env->context()).ToLocal(&str)) {

return;

}

size_t offset = 0;

size_t max_length = 0;

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[2], 0, &offset));

if (offset > ts_obj_length) {

return node::THROW_ERR_BUFFER_OUT_OF_BOUNDS(

env, "\"offset\" is outside of buffer bounds");

}

THROW_AND_RETURN_IF_OOB(

ParseArrayIndex(env, args[3], ts_obj_length - offset, &max_length));

max_length = std::min(ts_obj_length - offset, max_length);

if (max_length == 0)

return args.GetReturnValue().Set(0);

uint32_t written = StringBytes::Write(

env->isolate(), ts_obj_data + offset, max_length, str, encoding);

args.GetReturnValue().Set(written);

}

void SlowByteLengthUtf8(const FunctionCallbackInfo<Value>& args) {

CHECK(args[0]->IsString());

Isolate* isolate = args.GetIsolate();

Local<String> str = args[0].As<String>();

// Below ~512 units, or for one-byte, V8's Utf8LengthV2 is faster.

if (str->Length() >= 512 && !str->IsOneByte()) {

String::ValueView view(isolate, str);

if (!view.is_one_byte()) {

// with_replacement matches Buffer.from's U+FFFD for lone surrogates.

size_t result =

simdutf::utf8_length_from_utf16_with_replacement(

reinterpret_cast<const char16_t*>(view.data16()), view.length())

.count;

args.GetReturnValue().Set(static_cast<uint64_t>(result));

return;

}

}

args.GetReturnValue().Set(static_cast<uint64_t>(str->Utf8LengthV2(isolate)));

}

uint32_t FastByteLengthUtf8(

Local<Value> receiver,

Local<Value> sourceValue,

FastApiCallbackOptions& options) { // NOLINT(runtime/references)

TRACK_V8_FAST_API_CALL("Buffer::FastByteLengthUtf8");

auto isolate = options.isolate;

HandleScope handleScope(isolate);

CHECK(sourceValue->IsString());

Local<String> sourceStr = sourceValue.As<String>();

if (!sourceStr->IsExternalOneByte()) {

// Below ~512 units, or for one-byte, V8's Utf8LengthV2 is faster.

if (sourceStr->Length() >= 512 && !sourceStr->IsOneByte()) {

String::ValueView view(isolate, sourceStr);

if (!view.is_one_byte()) {

// with_replacement matches Buffer.from's U+FFFD for lone surrogates.

return simdutf::utf8_length_from_utf16_with_replacement(

reinterpret_cast<const char16_t*>(view.data16()),

view.length())

.count;

}

}

return sourceStr->Utf8LengthV2(isolate);

}

auto source = sourceStr->GetExternalOneByteStringResource();

// For short inputs, the function call overhead to simdutf is maybe

// not worth it, reserve simdutf for long strings.

if (source->length() > 128) {

return simdutf::utf8_length_from_latin1(source->data(), source->length());

}

uint32_t length = source->length();

const auto input = reinterpret_cast<const uint8_t*>(source->data());

uint32_t answer = length;

uint32_t i = 0;

auto pop = [](uint64_t v) {

return static_cast<size_t>(((v >> 7) & UINT64_C(0x0101010101010101)) *

UINT64_C(0x0101010101010101) >>

56);

};

for (; i + 32 <= length; i += 32) {

uint64_t v;

memcpy(&v, input + i, 8);

answer += pop(v);

memcpy(&v, input + i + 8, 8);

answer += pop(v);

memcpy(&v, input + i + 16, 8);

answer += pop(v);

memcpy(&v, input + i + 24, 8);

answer += pop(v);

}

for (; i + 8 <= length; i += 8) {

uint64_t v;

memcpy(&v, input + i, 8);

answer += pop(v);

}

for (; i + 1 <= length; i += 1) {

answer += input[i] >> 7;

}

return answer;

}

static CFunction fast_byte_length_utf8(CFunction::Make(FastByteLengthUtf8));

// Normalize val to be an integer in the range of [1, -1] since

// implementations of memcmp() can vary by platform.

static int normalizeCompareVal(int val, size_t a_length, size_t b_length) {

if (val == 0) {

if (a_length > b_length)

return 1;

else if (a_length < b_length)

return -1;

} else {

if (val > 0)

return 1;

else

return -1;

}

return val;

}

void CompareOffset(const FunctionCallbackInfo<Value> &args) {

Environment* env = Environment::GetCurrent(args);

THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);

THROW_AND_RETURN_UNLESS_BUFFER(env, args[1]);

ArrayBufferViewContents<char> source(args[0]);

ArrayBufferViewContents<char> target(args[1]);

size_t target_start = 0;

size_t source_start = 0;

size_t source_end = 0;

size_t target_end = 0;

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[2], 0, &target_start));

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[3], 0, &source_start));

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[4], target.length(),

&target_end));

THROW_AND_RETURN_IF_OOB(ParseArrayIndex(env, args[5], source.length(),

&source_end));

if (source_start > source.length())

return THROW_ERR_OUT_OF_RANGE(

env, "The value of \"sourceStart\" is out of range.");

if (target_start > target.length())

return THROW_ERR_OUT_OF_RANGE(

env, "The value of \"targetStart\" is out of range.");

CHECK_LE(source_start, source_end);

CHECK_LE(target_start, target_end);

size_t to_cmp =

std::min(std::min(source_end - source_start, target_end - target_start),

source.length() - source_start);

int val = normalizeCompareVal(to_cmp > 0 ?

memcmp(source.data() + source_start,

target.data() + target_start,

to_cmp) : 0,

source_end - source_start,

target_end - target_start);

args.GetReturnValue().Set(val);

}

int32_t CompareImpl(Local<Value> a_obj, Local<Value> b_obj) {

ArrayBufferViewContents<char> a(a_obj);

ArrayBufferViewContents<char> b(b_obj);

size_t cmp_length = std::min(a.length(), b.length());

return normalizeCompareVal(

cmp_length > 0 ? memcmp(a.data(), b.data(), cmp_length) : 0,

a.length(),

b.length());

}

void Compare(const FunctionCallbackInfo<Value> &args) {

Environment* env = Environment::GetCurrent(args);

THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);

THROW_AND_RETURN_UNLESS_BUFFER(env, args[1]);

int val = CompareImpl(args[0], args[1]);

args.GetReturnValue().Set(val);

}

int32_t FastCompare(Local<Value>,

Local<Value> a_obj,

Local<Value> b_obj,

// NOLINTNEXTLINE(runtime/references)

FastApiCallbackOptions& options) {

HandleScope scope(options.isolate);

return CompareImpl(a_obj, b_obj);

}

static CFunction fast_compare(CFunction::Make(FastCompare));

// Computes the offset for starting an indexOf or lastIndexOf search.

// Returns either a valid offset in [0...<length - 1>], ie inside the Buffer,

// or -1 to signal that there is no possible match.

int64_t IndexOfOffset(size_t length,

int64_t offset_i64,

int64_t needle_length,

bool is_forward) {

int64_t length_i64 = static_cast<int64_t>(length);

if (offset_i64 < 0) {