// 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 <memory>
#include "src/builtins/builtins-utils.h"
#include "src/builtins/builtins.h"
#include "src/builtins/superspread.h"
#include "src/common/message-template.h"
#include "src/compiler-dispatcher/optimizing-compile-dispatcher.h"
#include "src/execution/arguments-inl.h"
#include "src/execution/isolate-inl.h"
#include "src/execution/messages.h"
#include "src/execution/protectors-inl.h"
#include "src/execution/tiering-manager.h"
#include "src/handles/handle-scope-implementer-inl.h"
#include "src/handles/maybe-handles.h"
#include "src/logging/counters.h"
#include "src/numbers/conversions.h"
#include "src/objects/contexts.h"
#include "src/objects/template-objects-inl.h"
#include "src/runtime/runtime-utils.h"
#include "src/utils/ostreams.h"
namespace v8 {
namespace internal {
RUNTIME_FUNCTION(Runtime_AccessCheck) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<JSObject> object = args.at<JSObject>(0);
if (!isolate->MayAccess(isolate->native_context(), object)) {
RETURN_FAILURE_ON_EXCEPTION(isolate,
isolate->ReportFailedAccessCheck(object));
UNREACHABLE();
}
return ReadOnlyRoots(isolate).undefined_value();
}
RUNTIME_FUNCTION(Runtime_FatalProcessOutOfMemoryInAllocateRaw) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
isolate->heap()->FatalProcessOutOfMemory("CodeStubAssembler::AllocateRaw");
UNREACHABLE();
}
RUNTIME_FUNCTION(Runtime_FatalProcessOutOfMemoryInvalidArrayLength) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
isolate->heap()->FatalProcessOutOfMemory("invalid array length");
UNREACHABLE();
}
RUNTIME_FUNCTION(Runtime_FatalInvalidSize) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
FATAL("Invalid size");
UNREACHABLE();
}
RUNTIME_FUNCTION(Runtime_Throw) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
return isolate->Throw(args[0]);
}
RUNTIME_FUNCTION(Runtime_ReThrow) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
return isolate->ReThrow(args[0]);
}
RUNTIME_FUNCTION(Runtime_ReThrowWithMessage) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
return isolate->ReThrow(args[0], args[1]);
}
RUNTIME_FUNCTION(Runtime_ThrowStackOverflow) {
SealHandleScope shs(isolate);
DCHECK_LE(0, args.length());
return isolate->StackOverflow();
}
RUNTIME_FUNCTION(Runtime_VarargStackOverflow) {
HandleScope scope(isolate);
StackLimitCheck check(isolate);
if (check.JsHasOverflowed()) {
return isolate->StackOverflow();
}
int nargs = args.length();
if (nargs >= SuperSpreadArgs::kNumExtraArgs) {
auto maybe_receiver =
args.at<JSAny>(nargs - SuperSpreadArgs::kReceiverOffsetFromEnd);
auto maybe_target =
args.at<JSAny>(nargs - SuperSpreadArgs::kTargetOffsetFromEnd);
auto maybe_arglist =
args.at<Object>(nargs - SuperSpreadArgs::kArglistOffsetFromEnd);
int args_length =
args.smi_value_at(nargs - SuperSpreadArgs::kArglistLengthOffsetFromEnd);
if (v8_flags.superspreading) {
Handle<JSFunction> target;
Handle<FixedArray> arglist;
if (TryCast(maybe_target, &target) && Is<JSReceiver>(maybe_receiver) &&
TryCast(maybe_arglist, &arglist)) {
Handle<JSReceiver> receiver = Cast<JSReceiver>(maybe_receiver);
auto GetMergedArglist = [&]() {
int stack_arg_count = nargs - SuperSpreadArgs::kNumExtraArgs;
int total_args = stack_arg_count + args_length;
if (stack_arg_count == 0) {
return isolate->factory()->CopyFixedArrayUpTo(arglist, args_length);
}
Handle<FixedArray> merged =
isolate->factory()->NewFixedArray(total_args);
for (int i = 0; i < stack_arg_count; ++i) {
merged->set(i, *args.at(stack_arg_count - i - 1));
}
merged->CopyElements(isolate, stack_arg_count, *arglist, 0,
args_length, UPDATE_WRITE_BARRIER);
return merged;
};
#define CASE(Name, Handler) \
if (target->code(isolate)->builtin_id() == Builtin::k##Name) { \
return Handler(isolate, receiver, GetMergedArglist()); \
}
SUPERSPREAD_BUILTINS(CASE)
#undef CASE
}
}
}
return isolate->StackOverflow();
}
RUNTIME_FUNCTION(Runtime_ThrowSymbolAsyncIteratorInvalid) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kSymbolAsyncIteratorInvalid));
}
RUNTIME_FUNCTION(Runtime_TerminateExecution) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
return isolate->TerminateExecution();
}
namespace {
Tagged<Object> NewError(Isolate* isolate, RuntimeArguments args,
Handle<JSFunction> (Isolate::*constructor_fn)()) {
HandleScope scope(isolate);
DCHECK_LE(1, args.length());
int message_id_smi = args.smi_value_at(0);
constexpr int kMaxMessageArgs = 3;
DirectHandle<Object> message_args[kMaxMessageArgs];
int num_message_args = 0;
while (num_message_args < kMaxMessageArgs &&
args.length() > num_message_args + 1) {
message_args[num_message_args] = args.at(num_message_args + 1);
++num_message_args;
}
MessageTemplate message_id = MessageTemplateFromInt(message_id_smi);
return *isolate->factory()->NewError(
(isolate->*constructor_fn)(), message_id,
base::VectorOf(message_args, num_message_args));
}
Tagged<Object> ThrowError(Isolate* isolate, RuntimeArguments args,
Handle<JSFunction> (Isolate::*constructor_fn)()) {
return isolate->Throw(NewError(isolate, args, constructor_fn));
}
} // namespace
RUNTIME_FUNCTION(Runtime_ThrowRangeError) {
if (v8_flags.correctness_fuzzer_suppressions) {
DCHECK_LE(1, args.length());
int message_id_smi = args.smi_value_at(0);
// If the result of a BigInt computation is truncated to 64 bit, Turbofan
// can sometimes truncate intermediate results already, which can prevent
// those from exceeding the maximum length, effectively preventing a
// RangeError from being thrown. As this is a performance optimization, this
// behavior is accepted. To prevent the correctness fuzzer from detecting
// this difference, we crash the program.
if (MessageTemplateFromInt(message_id_smi) ==
MessageTemplate::kBigIntTooBig) {
FATAL("Aborting on invalid BigInt length");
}
}
return ThrowError(isolate, args, &Isolate::range_error_function);
}
RUNTIME_FUNCTION(Runtime_ThrowTypeError) {
return ThrowError(isolate, args, &Isolate::type_error_function);
}
RUNTIME_FUNCTION(Runtime_ThrowTypeErrorIfStrict) {
if (GetShouldThrow(isolate, Nothing<ShouldThrow>()) ==
ShouldThrow::kDontThrow) {
return ReadOnlyRoots(isolate).undefined_value();
}
return ThrowError(isolate, args, &Isolate::type_error_function);
}
namespace {
const char* ElementsKindToType(ElementsKind fixed_elements_kind) {
switch (fixed_elements_kind) {
#define ELEMENTS_KIND_CASE(Type, type, TYPE, ctype) \
case TYPE##_ELEMENTS: \
return #Type "Array";
TYPED_ARRAYS(ELEMENTS_KIND_CASE)
RAB_GSAB_TYPED_ARRAYS_WITH_TYPED_ARRAY_TYPE(ELEMENTS_KIND_CASE)
#undef ELEMENTS_KIND_CASE
default:
UNREACHABLE();
}
}
} // namespace
RUNTIME_FUNCTION(Runtime_ThrowInvalidTypedArrayAlignment) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
DirectHandle<Map> map = args.at<Map>(0);
Handle<String> problem_string = args.at<String>(1);
ElementsKind kind = map->elements_kind();
Handle<String> type =
isolate->factory()->NewStringFromAsciiChecked(ElementsKindToType(kind));
ExternalArrayType external_type;
size_t size;
Factory::TypeAndSizeForElementsKind(kind, &external_type, &size);
Handle<Object> element_size =
handle(Smi::FromInt(static_cast<int>(size)), isolate);
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewRangeError(MessageTemplate::kInvalidTypedArrayAlignment,
problem_string, type, element_size));
}
RUNTIME_FUNCTION(Runtime_UnwindAndFindExceptionHandler) {
SealHandleScope shs(isolate);
DCHECK_EQ(0, args.length());
return isolate->UnwindAndFindHandler();
}
RUNTIME_FUNCTION(Runtime_PropagateException) {
SealHandleScope shs(isolate);
DCHECK_EQ(0, args.length());
DCHECK(isolate->has_exception());
return ReadOnlyRoots(isolate).exception();
}
RUNTIME_FUNCTION(Runtime_ThrowReferenceError) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
Handle<Object> name = args.at(0);
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewReferenceError(MessageTemplate::kNotDefined, name));
}
RUNTIME_FUNCTION(Runtime_ThrowAccessedUninitializedVariable) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
Handle<Object> name = args.at(0);
THROW_NEW_ERROR_RETURN_FAILURE(
isolate,
NewReferenceError(MessageTemplate::kAccessedUninitializedVariable, name));
}
RUNTIME_FUNCTION(Runtime_NewError) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
int template_index = args.smi_value_at(0);
Handle<Object> arg0 = args.at(1);
MessageTemplate message_template = MessageTemplateFromInt(template_index);
return *isolate->factory()->NewError(message_template, arg0);
}
RUNTIME_FUNCTION(Runtime_NewTypeError) {
return NewError(isolate, args, &Isolate::type_error_function);
}
RUNTIME_FUNCTION(Runtime_NewReferenceError) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
int template_index = args.smi_value_at(0);
Handle<Object> arg0 = args.at(1);
MessageTemplate message_template = MessageTemplateFromInt(template_index);
return *isolate->factory()->NewReferenceError(message_template, arg0);
}
RUNTIME_FUNCTION(Runtime_ThrowInvalidStringLength) {
HandleScope scope(isolate);
THROW_NEW_ERROR_RETURN_FAILURE(isolate, NewInvalidStringLengthError());
}
RUNTIME_FUNCTION(Runtime_ThrowIteratorResultNotAnObject) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
Handle<Object> value = args.at(0);
THROW_NEW_ERROR_RETURN_FAILURE(
isolate,
NewTypeError(MessageTemplate::kIteratorResultNotAnObject, value));
}
RUNTIME_FUNCTION(Runtime_ThrowThrowMethodMissing) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kThrowMethodMissing));
}
RUNTIME_FUNCTION(Runtime_ThrowSymbolIteratorInvalid) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kSymbolIteratorInvalid));
}
RUNTIME_FUNCTION(Runtime_ThrowNoAccess) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
// TODO(verwaest): We would like to throw using the calling context instead
// of the entered context but we don't currently have access to that.
HandleScopeImplementer* impl = isolate->handle_scope_implementer();
SaveAndSwitchContext save(isolate,
impl->LastEnteredContext()->native_context());
THROW_NEW_ERROR_RETURN_FAILURE(isolate,
NewTypeError(MessageTemplate::kNoAccess));
}
RUNTIME_FUNCTION(Runtime_ThrowNotConstructor) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
Handle<Object> object = args.at(0);
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kNotConstructor, object));
}
RUNTIME_FUNCTION(Runtime_ThrowTargetNonFunction) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
Handle<Object> object = args.at(0);
Handle<String> target = args.at<String>(1);
Handle<String> type = Object::TypeOf(isolate, object);
Handle<String> msg;
if (IsNull(*object)) {
// "which is null"
msg = isolate->factory()->null_string();
} else if (IsUndefined(*object)) {
// "which is undefined"
msg = isolate->factory()->undefined_string();
} else if (isolate->factory()->object_string()->Equals(*type)) {
// "which is an object"
msg = isolate->factory()->NewStringFromAsciiChecked("an object");
} else {
// "which is a typeof arg"
msg = isolate->factory()
->NewConsString(
isolate->factory()->NewStringFromAsciiChecked("a "), type)
.ToHandleChecked();
}
THROW_NEW_ERROR_RETURN_FAILURE(
isolate,
NewTypeError(MessageTemplate::kTargetNonFunction, target, object, msg));
}
RUNTIME_FUNCTION(Runtime_StackGuard) {
SealHandleScope shs(isolate);
DCHECK_EQ(0, args.length());
TRACE_EVENT("v8.execute", "V8.StackGuard");
// First check if this is a real stack overflow.
StackLimitCheck check(isolate);
if (check.JsHasOverflowed()) {
return isolate->StackOverflow();
}
return isolate->stack_guard()->HandleInterrupts(
StackGuard::InterruptLevel::kAnyEffect);
}
RUNTIME_FUNCTION(Runtime_HandleNoHeapWritesInterrupts) {
SealHandleScope shs(isolate);
DCHECK_EQ(0, args.length());
TRACE_EVENT("v8.execute", "V8.StackGuard");
// First check if this is a real stack overflow.
StackLimitCheck check(isolate);
if (check.JsHasOverflowed()) {
return isolate->StackOverflow();
}
return isolate->stack_guard()->HandleInterrupts(
StackGuard::InterruptLevel::kNoHeapWrites);
}
RUNTIME_FUNCTION(Runtime_StackGuardWithGap) {
SealHandleScope shs(isolate);
DCHECK_EQ(args.length(), 1);
uint32_t gap = args.positive_smi_value_at(0);
TRACE_EVENT("v8.execute", "V8.StackGuard");
// First check if this is a real stack overflow.
StackLimitCheck check(isolate);
if (check.JsHasOverflowed(gap)) {
return isolate->StackOverflow();
}
return isolate->stack_guard()->HandleInterrupts(
StackGuard::InterruptLevel::kAnyEffect);
}
namespace {
Tagged<Object> BytecodeBudgetInterruptWithStackCheck(Isolate* isolate,
RuntimeArguments& args,
CodeKind code_kind) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<JSFunction> function = args.at<JSFunction>(0);
TRACE_EVENT("v8.execute", "V8.BytecodeBudgetInterruptWithStackCheck");
// Check for stack interrupts here so that we can fold the interrupt check
// into bytecode budget interrupts.
StackLimitCheck check(isolate);
if (check.JsHasOverflowed()) {
// We ideally wouldn't actually get StackOverflows here, since we stack
// check on bytecode entry, but it's possible that this check fires due to
// the runtime function call being what overflows the stack.
return isolate->StackOverflow();
} else if (check.InterruptRequested()) {
Tagged<Object> return_value = isolate->stack_guard()->HandleInterrupts();
if (!IsUndefined(return_value)) {
return return_value;
}
}
isolate->tiering_manager()->OnInterruptTick(function, code_kind);
return ReadOnlyRoots(isolate).undefined_value();
}
Tagged<Object> BytecodeBudgetInterrupt(Isolate* isolate, RuntimeArguments& args,
CodeKind code_kind) {
HandleScope scope(isolate);
DCHECK(args.length() == 1 ||
(code_kind == CodeKind::MAGLEV && args.length() == 2));
DirectHandle<JSFunction> function = args.at<JSFunction>(0);
function->TraceOptimizationStatus("budget from %s",
CodeKindToString(code_kind));
TRACE_EVENT("v8.execute", "V8.BytecodeBudgetInterrupt");
isolate->tiering_manager()->OnInterruptTick(function, code_kind);
return ReadOnlyRoots(isolate).undefined_value();
}
} // namespace
RUNTIME_FUNCTION(Runtime_BytecodeBudgetInterruptWithStackCheck_Ignition) {
return BytecodeBudgetInterruptWithStackCheck(isolate, args,
CodeKind::INTERPRETED_FUNCTION);
}
RUNTIME_FUNCTION(Runtime_BytecodeBudgetInterrupt_Ignition) {
return BytecodeBudgetInterrupt(isolate, args, CodeKind::INTERPRETED_FUNCTION);
}
RUNTIME_FUNCTION(Runtime_BytecodeBudgetInterruptWithStackCheck_Sparkplug) {
return BytecodeBudgetInterruptWithStackCheck(isolate, args,
CodeKind::BASELINE);
}
RUNTIME_FUNCTION(Runtime_BytecodeBudgetInterrupt_Sparkplug) {
return BytecodeBudgetInterrupt(isolate, args, CodeKind::BASELINE);
}
RUNTIME_FUNCTION(Runtime_BytecodeBudgetInterrupt_Maglev) {
DCHECK_EQ(1, args.length());
return BytecodeBudgetInterrupt(isolate, args, CodeKind::MAGLEV);
}
RUNTIME_FUNCTION(Runtime_BytecodeBudgetLoopInterrupt_Maglev) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
DirectHandle<JSFunction> function = args.at<JSFunction>(0);
BytecodeOffset osr_offset = BytecodeOffset(args.smi_value_at(1));
// Check for stack interrupts here so that we can fold the interrupt check
// into bytecode budget interrupts.
StackLimitCheck check(isolate);
if (check.JsHasOverflowed()) {
return isolate->StackOverflow();
} else if (check.InterruptRequested(
StackGuard::InterruptLevel::kNoHeapWrites)) {
Tagged<Object> return_value = isolate->stack_guard()->HandleInterrupts(
StackGuard::InterruptLevel::kNoHeapWrites);
if (!IsUndefined(return_value)) {
return return_value;
}
}
if (!osr_offset.IsNone() && isolate->concurrent_recompilation_enabled() &&
isolate->stack_guard()->CheckInstallCode()) {
isolate->optimizing_compile_dispatcher()->InstallOptimizedFunctionsIfReady(
function, osr_offset);
}
return BytecodeBudgetInterrupt(isolate, args, CodeKind::MAGLEV);
}
RUNTIME_FUNCTION(Runtime_AllocateInYoungGeneration) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
// TODO(v8:13070): Align allocations in the builtins that call this.
int size = ALIGN_TO_ALLOCATION_ALIGNMENT(args.smi_value_at(0));
int flags = args.smi_value_at(1);
AllocationAlignment alignment = static_cast<AllocationAlignment>(flags);
CHECK(IsAligned(size, kTaggedSize));
CHECK_GT(size, 0);
// TODO(v8:9472): Until double-aligned allocation is fixed for new-space
// allocations, don't request it.
alignment = kTaggedAligned;
return *isolate->factory()->NewFillerObject(size, alignment,
AllocationType::kYoung,
AllocationOrigin::kGeneratedCode);
}
RUNTIME_FUNCTION(Runtime_AllocateInOldGeneration) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
// TODO(v8:13070): Align allocations in the builtins that call this.
int size = ALIGN_TO_ALLOCATION_ALIGNMENT(args.smi_value_at(0));
int flags = args.smi_value_at(1);
AllocationAlignment alignment = static_cast<AllocationAlignment>(flags);
CHECK(IsAligned(size, kTaggedSize));
CHECK_GT(size, 0);
return *isolate->factory()->NewFillerObject(
size, alignment, AllocationType::kOld, AllocationOrigin::kGeneratedCode);
}
RUNTIME_FUNCTION(Runtime_AllocateInSharedHeap) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
// TODO(v8:13070): Align allocations in the builtins that call this.
int size = ALIGN_TO_ALLOCATION_ALIGNMENT(args.smi_value_at(0));
int flags = args.smi_value_at(1);
AllocationAlignment alignment = static_cast<AllocationAlignment>(flags);
CHECK(IsAligned(size, kTaggedSize));
CHECK_GT(size, 0);
Tagged<HeapObject> result = *isolate->factory()->NewFillerObject(
size, alignment, AllocationType::kSharedOld,
AllocationOrigin::kGeneratedCode);
DCHECK(IsAligned(result->address(),
alignment == kDoubleAligned ? kDoubleSize : kTaggedSize));
return result;
}
RUNTIME_FUNCTION(Runtime_AllocateByteArray) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
uint32_t length = args.positive_smi_value_at(0);
DCHECK_LT(0u, length);
return *isolate->factory()->NewByteArray(length);
}
RUNTIME_FUNCTION(Runtime_ThrowIteratorError) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<Object> object = args.at(0);
return isolate->Throw(*ErrorUtils::NewIteratorError(isolate, object));
}
RUNTIME_FUNCTION(Runtime_ThrowSpreadArgError) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
int message_id_smi = args.smi_value_at(0);
MessageTemplate message_id = MessageTemplateFromInt(message_id_smi);
DirectHandle<Object> object = args.at(1);
return ErrorUtils::ThrowSpreadArgError(isolate, message_id, object);
}
RUNTIME_FUNCTION(Runtime_ThrowCalledNonCallable) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<Object> object = args.at(0);
return isolate->Throw(
*ErrorUtils::NewCalledNonCallableError(isolate, object));
}
RUNTIME_FUNCTION(Runtime_ThrowConstructedNonConstructable) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<Object> object = args.at(0);
return isolate->Throw(
*ErrorUtils::NewConstructedNonConstructable(isolate, object));
}
RUNTIME_FUNCTION(Runtime_ThrowPatternAssignmentNonCoercible) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<Object> object = args.at(0);
return ErrorUtils::ThrowLoadFromNullOrUndefined(isolate, object,
MaybeDirectHandle<Object>());
}
RUNTIME_FUNCTION(Runtime_ThrowConstructorReturnedNonObject) {
HandleScope scope(isolate);
DCHECK_EQ(0, args.length());
THROW_NEW_ERROR_RETURN_FAILURE(
isolate,
NewTypeError(MessageTemplate::kDerivedConstructorReturnedNonObject));
}
// ES6 section 7.3.17 CreateListFromArrayLike (obj)
RUNTIME_FUNCTION(Runtime_CreateListFromArrayLike) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<Object> object = args.at(0);
RETURN_RESULT_OR_FAILURE(isolate, Object::CreateListFromArrayLike(
isolate, object, ElementTypes::kAll));
}
RUNTIME_FUNCTION(Runtime_IncrementUseCounter) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
int counter = args.smi_value_at(0);
isolate->CountUsage(static_cast<v8::Isolate::UseCounterFeature>(counter));
return ReadOnlyRoots(isolate).undefined_value();
}
RUNTIME_FUNCTION(Runtime_GetAndResetTurboProfilingData) {
HandleScope scope(isolate);
DCHECK_LE(args.length(), 2);
if (!BasicBlockProfiler::Get()->HasData(isolate)) {
THROW_NEW_ERROR_RETURN_FAILURE(
isolate,
NewTypeError(
MessageTemplate::kInvalid,
isolate->factory()->NewStringFromAsciiChecked("Runtime Call"),
isolate->factory()->NewStringFromAsciiChecked(
"V8 was not built with v8_enable_builtins_profiling=true")));
}
std::stringstream stats_stream;
BasicBlockProfiler::Get()->Log(isolate, stats_stream);
DirectHandle<String> result =
isolate->factory()->NewStringFromAsciiChecked(stats_stream.str().c_str());
BasicBlockProfiler::Get()->ResetCounts(isolate);
return *result;
}
RUNTIME_FUNCTION(Runtime_GetAndResetRuntimeCallStats) {
HandleScope scope(isolate);
DCHECK_LE(args.length(), 2);
#ifdef V8_RUNTIME_CALL_STATS
if (!v8_flags.runtime_call_stats) {
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kInvalid,
isolate->factory()->NewStringFromAsciiChecked(
"Runtime Call"),
isolate->factory()->NewStringFromAsciiChecked(
"--runtime-call-stats is not set")));
}
// Append any worker thread runtime call stats to the main table before
// printing.
isolate->counters()->worker_thread_runtime_call_stats()->AddToMainTable(
isolate->counters()->runtime_call_stats());
if (args.length() == 0) {
// Without arguments, the result is returned as a string.
std::stringstream stats_stream;
isolate->counters()->runtime_call_stats()->Print(stats_stream);
DirectHandle<String> result = isolate->factory()->NewStringFromAsciiChecked(
stats_stream.str().c_str());
isolate->counters()->runtime_call_stats()->Reset();
return *result;
}
std::FILE* f;
if (IsString(args[0])) {
// With a string argument, the results are appended to that file.
DirectHandle<String> filename = args.at<String>(0);
f = std::fopen(filename->ToCString().get(), "a");
DCHECK_NOT_NULL(f);
} else {
// With an integer argument, the results are written to stdout/stderr.
int fd = args.smi_value_at(0);
DCHECK(fd == 1 || fd == 2);
f = fd == 1 ? stdout : stderr;
}
// The second argument (if any) is a message header to be printed.
if (args.length() >= 2) {
DirectHandle<String> message = args.at<String>(1);
message->PrintOn(f);
std::fputc('\n', f);
std::fflush(f);
}
OFStream stats_stream(f);
isolate->counters()->runtime_call_stats()->Print(stats_stream);
isolate->counters()->runtime_call_stats()->Reset();
if (IsString(args[0])) {
std::fclose(f);
} else {
std::fflush(f);
}
return ReadOnlyRoots(isolate).undefined_value();
#else // V8_RUNTIME_CALL_STATS
// RCS has to be enabled with v8_enable_runtime_call_stats = true.
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kInvalid,
isolate->factory()->NewStringFromAsciiChecked(
"Runtime Call"),
isolate->factory()->NewStringFromAsciiChecked(
"RCS was disabled at compile-time.")));
#endif // V8_RUNTIME_CALL_STATS
}
RUNTIME_FUNCTION(Runtime_OrdinaryHasInstance) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
DirectHandle<JSAny> callable = args.at<JSAny>(0);
DirectHandle<JSAny> object = args.at<JSAny>(1);
RETURN_RESULT_OR_FAILURE(
isolate, Object::OrdinaryHasInstance(isolate, callable, object));
}
RUNTIME_FUNCTION(Runtime_Typeof) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<Object> object = args.at(0);
return *Object::TypeOf(isolate, object);
}
RUNTIME_FUNCTION(Runtime_AllowDynamicFunction) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<JSFunction> target = args.at<JSFunction>(0);
DirectHandle<JSObject> global_proxy(target->global_proxy(), isolate);
return *isolate->factory()->ToBoolean(
Builtins::AllowDynamicFunction(isolate, target, global_proxy));
}
RUNTIME_FUNCTION(Runtime_CreateAsyncFromSyncIterator) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<JSAny> sync_iterator_any = args.at<JSAny>(0);
DirectHandle<JSReceiver> sync_iterator;
if (!TryCast<JSReceiver>(sync_iterator_any, &sync_iterator)) {
THROW_NEW_ERROR_RETURN_FAILURE(
isolate, NewTypeError(MessageTemplate::kSymbolIteratorInvalid));
}
DirectHandle<Object> next;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, next,
Object::GetProperty(isolate, sync_iterator,
isolate->factory()->next_string()));
return *isolate->factory()->NewJSAsyncFromSyncIterator(sync_iterator, next);
}
RUNTIME_FUNCTION(Runtime_GetTemplateObject) {
HandleScope scope(isolate);
DCHECK_EQ(3, args.length());
DirectHandle<TemplateObjectDescription> description =
args.at<TemplateObjectDescription>(0);
DirectHandle<SharedFunctionInfo> shared_info = args.at<SharedFunctionInfo>(1);
int slot_id = args.smi_value_at(2);
DirectHandle<NativeContext> native_context(
isolate->context()->native_context(), isolate);
return *TemplateObjectDescription::GetTemplateObject(
isolate, native_context, description, shared_info, slot_id);
}
RUNTIME_FUNCTION(Runtime_ReportMessageFromMicrotask) {
// Helper to report messages and continue JS execution. This is intended to
// behave similarly to reporting exceptions which reach the top-level, but
// allow the JS code to continue.
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
// Valid context is required for reporting an unhandled exception.
DCHECK(!isolate->context().is_null());
DirectHandle<Object> exception = args.at(0);
DCHECK(!isolate->has_exception());
isolate->set_exception(*exception);
MessageLocation* no_location = nullptr;
DirectHandle<JSMessageObject> message =
isolate->CreateMessageOrAbort(exception, no_location);
MessageHandler::ReportMessage(isolate, no_location, message);
isolate->clear_exception();
return ReadOnlyRoots(isolate).undefined_value();
}
RUNTIME_FUNCTION(Runtime_GetInitializerFunction) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
DirectHandle<JSReceiver> constructor = args.at<JSReceiver>(0);
DirectHandle<Symbol> key = isolate->factory()->class_fields_symbol();
DirectHandle<Object> initializer =
JSReceiver::GetDataProperty(isolate, constructor, key);
return *initializer;
}
RUNTIME_FUNCTION(Runtime_DoubleToStringWithRadix) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
double number = args.number_value_at(0);
int32_t radix = 0;
CHECK(Object::ToInt32(args[1], &radix));
char chars[kDoubleToRadixMaxChars];
base::Vector<char> buffer = base::ArrayVector(chars);
std::string_view str = DoubleToRadixStringView(number, radix, buffer);
DirectHandle<String> result =
isolate->factory()->NewStringFromAsciiChecked(str);
return *result;
}
RUNTIME_FUNCTION(Runtime_SharedValueBarrierSlow) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
Handle<HeapObject> value = args.at<HeapObject>(0);
DirectHandle<Object> shared_value;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, shared_value, Object::ShareSlow(isolate, value, kThrowOnError));
return *shared_value;
}
RUNTIME_FUNCTION(Runtime_NotifyContextCellStateWillChange) {
HandleScope scope(isolate);
DCHECK_EQ(1, args.length());
auto cell = Cast<ContextCell>(args.at<HeapObject>(0));
DependentCode::DeoptimizeDependencyGroups(
isolate, *cell, DependentCode::kContextCellChangedGroup);
return ReadOnlyRoots(isolate).undefined_value();
}
RUNTIME_FUNCTION(Runtime_InvalidateStringWrapperToPrimitiveProtector) {
DCHECK_EQ(0, args.length());
Protectors::InvalidateStringWrapperToPrimitive(isolate);
return ReadOnlyRoots(isolate).undefined_value();
}
RUNTIME_FUNCTION(Runtime_AddLhsIsStringConstantInternalize) {
UNREACHABLE(); // Lowered to a builtin call instead.
}
RUNTIME_FUNCTION(Runtime_AddRhsIsStringConstantInternalize) {
UNREACHABLE(); // Lowered to a builtin call instead.
}
} // namespace internal
} // namespace v8