Line data Source code
1 : // Copyright 2012 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "src/api.h"
6 :
7 : #include <string.h> // For memcpy, strlen.
8 : #ifdef V8_USE_ADDRESS_SANITIZER
9 : #include <sanitizer/asan_interface.h>
10 : #endif // V8_USE_ADDRESS_SANITIZER
11 : #include <cmath> // For isnan.
12 : #include <limits>
13 : #include <vector>
14 : #include "include/v8-debug.h"
15 : #include "include/v8-profiler.h"
16 : #include "include/v8-testing.h"
17 : #include "include/v8-util.h"
18 : #include "src/accessors.h"
19 : #include "src/api-natives.h"
20 : #include "src/assert-scope.h"
21 : #include "src/background-parsing-task.h"
22 : #include "src/base/functional.h"
23 : #include "src/base/platform/platform.h"
24 : #include "src/base/platform/time.h"
25 : #include "src/base/safe_conversions.h"
26 : #include "src/base/utils/random-number-generator.h"
27 : #include "src/bootstrapper.h"
28 : #include "src/builtins/builtins-utils.h"
29 : #include "src/char-predicates-inl.h"
30 : #include "src/code-stubs.h"
31 : #include "src/compiler-dispatcher/compiler-dispatcher.h"
32 : #include "src/compiler.h"
33 : #include "src/contexts.h"
34 : #include "src/conversions-inl.h"
35 : #include "src/counters.h"
36 : #include "src/debug/debug-coverage.h"
37 : #include "src/debug/debug.h"
38 : #include "src/deoptimizer.h"
39 : #include "src/execution.h"
40 : #include "src/frames-inl.h"
41 : #include "src/gdb-jit.h"
42 : #include "src/global-handles.h"
43 : #include "src/globals.h"
44 : #include "src/icu_util.h"
45 : #include "src/isolate-inl.h"
46 : #include "src/json-parser.h"
47 : #include "src/json-stringifier.h"
48 : #include "src/messages.h"
49 : #include "src/objects-inl.h"
50 : #include "src/parsing/parser.h"
51 : #include "src/parsing/scanner-character-streams.h"
52 : #include "src/pending-compilation-error-handler.h"
53 : #include "src/profiler/cpu-profiler.h"
54 : #include "src/profiler/heap-profiler.h"
55 : #include "src/profiler/heap-snapshot-generator-inl.h"
56 : #include "src/profiler/profile-generator-inl.h"
57 : #include "src/profiler/tick-sample.h"
58 : #include "src/property-descriptor.h"
59 : #include "src/property-details.h"
60 : #include "src/property.h"
61 : #include "src/prototype.h"
62 : #include "src/runtime-profiler.h"
63 : #include "src/runtime/runtime.h"
64 : #include "src/simulator.h"
65 : #include "src/snapshot/code-serializer.h"
66 : #include "src/snapshot/natives.h"
67 : #include "src/snapshot/snapshot.h"
68 : #include "src/startup-data-util.h"
69 : #include "src/tracing/trace-event.h"
70 : #include "src/trap-handler/trap-handler.h"
71 : #include "src/unicode-inl.h"
72 : #include "src/v8.h"
73 : #include "src/v8threads.h"
74 : #include "src/value-serializer.h"
75 : #include "src/version.h"
76 : #include "src/vm-state-inl.h"
77 : #include "src/wasm/wasm-module.h"
78 : #include "src/wasm/wasm-objects.h"
79 : #include "src/wasm/wasm-result.h"
80 :
81 : namespace v8 {
82 :
83 : #define LOG_API(isolate, class_name, function_name) \
84 : i::RuntimeCallTimerScope _runtime_timer( \
85 : isolate, &i::RuntimeCallStats::API_##class_name##_##function_name); \
86 : LOG(isolate, ApiEntryCall("v8::" #class_name "::" #function_name))
87 :
88 : #define ENTER_V8(isolate) i::VMState<v8::OTHER> __state__((isolate))
89 :
90 : #define PREPARE_FOR_EXECUTION_GENERIC(isolate, context, class_name, \
91 : function_name, bailout_value, \
92 : HandleScopeClass, do_callback) \
93 : if (IsExecutionTerminatingCheck(isolate)) { \
94 : return bailout_value; \
95 : } \
96 : HandleScopeClass handle_scope(isolate); \
97 : CallDepthScope<do_callback> call_depth_scope(isolate, context); \
98 : LOG_API(isolate, class_name, function_name); \
99 : ENTER_V8(isolate); \
100 : bool has_pending_exception = false
101 :
102 : #define PREPARE_FOR_DEBUG_INTERFACE_EXECUTION_WITH_ISOLATE(isolate, T) \
103 : if (IsExecutionTerminatingCheck(isolate)) { \
104 : return MaybeLocal<T>(); \
105 : } \
106 : InternalEscapableScope handle_scope(isolate); \
107 : CallDepthScope<false> call_depth_scope(isolate, v8::Local<v8::Context>()); \
108 : ENTER_V8(isolate); \
109 : bool has_pending_exception = false
110 :
111 : #define PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \
112 : bailout_value, HandleScopeClass, \
113 : do_callback) \
114 : auto isolate = context.IsEmpty() \
115 : ? i::Isolate::Current() \
116 : : reinterpret_cast<i::Isolate*>(context->GetIsolate()); \
117 : PREPARE_FOR_EXECUTION_GENERIC(isolate, context, class_name, function_name, \
118 : bailout_value, HandleScopeClass, do_callback);
119 :
120 : #define PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE( \
121 : category, name, context, class_name, function_name, bailout_value, \
122 : HandleScopeClass, do_callback) \
123 : auto isolate = context.IsEmpty() \
124 : ? i::Isolate::Current() \
125 : : reinterpret_cast<i::Isolate*>(context->GetIsolate()); \
126 : TRACE_EVENT_CALL_STATS_SCOPED(isolate, category, name); \
127 : PREPARE_FOR_EXECUTION_GENERIC(isolate, context, class_name, function_name, \
128 : bailout_value, HandleScopeClass, do_callback);
129 :
130 : #define PREPARE_FOR_EXECUTION_WITH_ISOLATE(isolate, class_name, function_name, \
131 : T) \
132 : PREPARE_FOR_EXECUTION_GENERIC(isolate, Local<Context>(), class_name, \
133 : function_name, MaybeLocal<T>(), \
134 : InternalEscapableScope, false);
135 :
136 : #define PREPARE_FOR_EXECUTION(context, class_name, function_name, T) \
137 : PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \
138 : MaybeLocal<T>(), InternalEscapableScope, \
139 : false)
140 :
141 : #define PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, class_name, \
142 : function_name, T) \
143 : PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \
144 : MaybeLocal<T>(), InternalEscapableScope, \
145 : true)
146 :
147 : #define PREPARE_FOR_EXECUTION_PRIMITIVE(context, class_name, function_name, T) \
148 : PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \
149 : Nothing<T>(), i::HandleScope, false)
150 :
151 : #define PREPARE_FOR_EXECUTION_BOOL(context, class_name, function_name) \
152 : PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, class_name, function_name, \
153 : false, i::HandleScope, false)
154 :
155 : #ifdef DEBUG
156 : #define ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate) \
157 : i::VMState<v8::OTHER> __state__((isolate)); \
158 : i::DisallowJavascriptExecutionDebugOnly __no_script__((isolate)); \
159 : i::DisallowExceptions __no_exceptions__((isolate))
160 :
161 : #define ENTER_V8_FOR_NEW_CONTEXT(isolate) \
162 : i::VMState<v8::OTHER> __state__((isolate)); \
163 : i::DisallowExceptions __no_exceptions__((isolate))
164 : #else
165 : #define ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate) \
166 : i::VMState<v8::OTHER> __state__((isolate));
167 :
168 : #define ENTER_V8_FOR_NEW_CONTEXT(isolate) \
169 : i::VMState<v8::OTHER> __state__((isolate));
170 : #endif // DEBUG
171 :
172 : #define EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, value) \
173 : do { \
174 : if (has_pending_exception) { \
175 : call_depth_scope.Escape(); \
176 : return value; \
177 : } \
178 : } while (false)
179 :
180 :
181 : #define RETURN_ON_FAILED_EXECUTION(T) \
182 : EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, MaybeLocal<T>())
183 :
184 :
185 : #define RETURN_ON_FAILED_EXECUTION_PRIMITIVE(T) \
186 : EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, Nothing<T>())
187 :
188 : #define RETURN_ON_FAILED_EXECUTION_BOOL() \
189 : EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, false)
190 :
191 : #define RETURN_TO_LOCAL_UNCHECKED(maybe_local, T) \
192 : return maybe_local.FromMaybe(Local<T>());
193 :
194 :
195 : #define RETURN_ESCAPED(value) return handle_scope.Escape(value);
196 :
197 :
198 : namespace {
199 :
200 : Local<Context> ContextFromHeapObject(i::Handle<i::Object> obj) {
201 : return reinterpret_cast<v8::Isolate*>(i::HeapObject::cast(*obj)->GetIsolate())
202 0 : ->GetCurrentContext();
203 : }
204 :
205 : class InternalEscapableScope : public v8::EscapableHandleScope {
206 : public:
207 : explicit inline InternalEscapableScope(i::Isolate* isolate)
208 160335829 : : v8::EscapableHandleScope(reinterpret_cast<v8::Isolate*>(isolate)) {}
209 : };
210 :
211 :
212 : #ifdef DEBUG
213 : void CheckMicrotasksScopesConsistency(i::Isolate* isolate) {
214 : auto handle_scope_implementer = isolate->handle_scope_implementer();
215 : if (handle_scope_implementer->microtasks_policy() ==
216 : v8::MicrotasksPolicy::kScoped) {
217 : DCHECK(handle_scope_implementer->GetMicrotasksScopeDepth() ||
218 : !handle_scope_implementer->DebugMicrotasksScopeDepthIsZero());
219 : }
220 : }
221 : #endif
222 :
223 : template <bool do_callback>
224 : class CallDepthScope {
225 : public:
226 484589483 : explicit CallDepthScope(i::Isolate* isolate, Local<Context> context)
227 242457749 : : isolate_(isolate), context_(context), escaped_(false) {
228 : // TODO(dcarney): remove this when blink stops crashing.
229 : DCHECK(!isolate_->external_caught_exception());
230 242457749 : isolate_->handle_scope_implementer()->IncrementCallDepth();
231 242457749 : if (!context.IsEmpty()) {
232 : i::Handle<i::Context> env = Utils::OpenHandle(*context);
233 : i::HandleScopeImplementer* impl = isolate->handle_scope_implementer();
234 724526146 : if (isolate->context() != nullptr &&
235 : isolate->context()->native_context() == env->native_context() &&
236 : impl->LastEnteredContextWas(env)) {
237 239892901 : context_ = Local<Context>();
238 : } else {
239 2238833 : context_->Enter();
240 : }
241 : }
242 30038486 : if (do_callback) isolate_->FireBeforeCallEnteredCallback();
243 242457751 : }
244 242457721 : ~CallDepthScope() {
245 242457721 : if (!context_.IsEmpty()) context_->Exit();
246 242457727 : if (!escaped_) isolate_->handle_scope_implementer()->DecrementCallDepth();
247 30038485 : if (do_callback) isolate_->FireCallCompletedCallback();
248 : #ifdef DEBUG
249 : if (do_callback) CheckMicrotasksScopesConsistency(isolate_);
250 : #endif
251 242457728 : }
252 :
253 : void Escape() {
254 : DCHECK(!escaped_);
255 19710 : escaped_ = true;
256 19710 : auto handle_scope_implementer = isolate_->handle_scope_implementer();
257 : handle_scope_implementer->DecrementCallDepth();
258 : bool call_depth_is_zero = handle_scope_implementer->CallDepthIsZero();
259 19710 : isolate_->OptionalRescheduleException(call_depth_is_zero);
260 : }
261 :
262 : private:
263 : i::Isolate* const isolate_;
264 : Local<Context> context_;
265 : bool escaped_;
266 : bool do_callback_;
267 : };
268 :
269 : } // namespace
270 :
271 :
272 25576 : static ScriptOrigin GetScriptOriginForScript(i::Isolate* isolate,
273 : i::Handle<i::Script> script) {
274 25576 : i::Handle<i::Object> scriptName(script->GetNameOrSourceURL(), isolate);
275 : i::Handle<i::Object> source_map_url(script->source_mapping_url(), isolate);
276 : v8::Isolate* v8_isolate =
277 : reinterpret_cast<v8::Isolate*>(script->GetIsolate());
278 : ScriptOriginOptions options(script->origin_options());
279 : v8::ScriptOrigin origin(
280 : Utils::ToLocal(scriptName),
281 : v8::Integer::New(v8_isolate, script->line_offset()),
282 : v8::Integer::New(v8_isolate, script->column_offset()),
283 : v8::Boolean::New(v8_isolate, options.IsSharedCrossOrigin()),
284 : v8::Integer::New(v8_isolate, script->id()),
285 : Utils::ToLocal(source_map_url),
286 : v8::Boolean::New(v8_isolate, options.IsOpaque()),
287 : v8::Boolean::New(v8_isolate, script->type() == i::Script::TYPE_WASM),
288 76728 : v8::Boolean::New(v8_isolate, options.IsModule()));
289 25576 : return origin;
290 : }
291 :
292 :
293 : // --- E x c e p t i o n B e h a v i o r ---
294 :
295 :
296 0 : void i::FatalProcessOutOfMemory(const char* location) {
297 0 : i::V8::FatalProcessOutOfMemory(location, false);
298 : }
299 :
300 : // When V8 cannot allocate memory FatalProcessOutOfMemory is called. The default
301 : // OOM error handler is called and execution is stopped.
302 0 : void i::V8::FatalProcessOutOfMemory(const char* location, bool is_heap_oom) {
303 : i::Isolate* isolate = i::Isolate::Current();
304 : char last_few_messages[Heap::kTraceRingBufferSize + 1];
305 : char js_stacktrace[Heap::kStacktraceBufferSize + 1];
306 : i::HeapStats heap_stats;
307 :
308 0 : if (isolate == nullptr) {
309 : // On a background thread -> we cannot retrieve memory information from the
310 : // Isolate. Write easy-to-recognize values on the stack.
311 : memset(last_few_messages, 0x0badc0de, Heap::kTraceRingBufferSize + 1);
312 : memset(js_stacktrace, 0x0badc0de, Heap::kStacktraceBufferSize + 1);
313 : memset(&heap_stats, 0xbadc0de, sizeof(heap_stats));
314 : // Note that the embedder's oom handler won't be called in this case. We
315 : // just crash.
316 0 : FATAL("API fatal error handler returned after process out of memory");
317 : return;
318 : }
319 :
320 : memset(last_few_messages, 0, Heap::kTraceRingBufferSize + 1);
321 : memset(js_stacktrace, 0, Heap::kStacktraceBufferSize + 1);
322 :
323 : intptr_t start_marker;
324 0 : heap_stats.start_marker = &start_marker;
325 : size_t new_space_size;
326 0 : heap_stats.new_space_size = &new_space_size;
327 : size_t new_space_capacity;
328 0 : heap_stats.new_space_capacity = &new_space_capacity;
329 : size_t old_space_size;
330 0 : heap_stats.old_space_size = &old_space_size;
331 : size_t old_space_capacity;
332 0 : heap_stats.old_space_capacity = &old_space_capacity;
333 : size_t code_space_size;
334 0 : heap_stats.code_space_size = &code_space_size;
335 : size_t code_space_capacity;
336 0 : heap_stats.code_space_capacity = &code_space_capacity;
337 : size_t map_space_size;
338 0 : heap_stats.map_space_size = &map_space_size;
339 : size_t map_space_capacity;
340 0 : heap_stats.map_space_capacity = &map_space_capacity;
341 : size_t lo_space_size;
342 0 : heap_stats.lo_space_size = &lo_space_size;
343 : size_t global_handle_count;
344 0 : heap_stats.global_handle_count = &global_handle_count;
345 : size_t weak_global_handle_count;
346 0 : heap_stats.weak_global_handle_count = &weak_global_handle_count;
347 : size_t pending_global_handle_count;
348 0 : heap_stats.pending_global_handle_count = &pending_global_handle_count;
349 : size_t near_death_global_handle_count;
350 0 : heap_stats.near_death_global_handle_count = &near_death_global_handle_count;
351 : size_t free_global_handle_count;
352 0 : heap_stats.free_global_handle_count = &free_global_handle_count;
353 : size_t memory_allocator_size;
354 0 : heap_stats.memory_allocator_size = &memory_allocator_size;
355 : size_t memory_allocator_capacity;
356 0 : heap_stats.memory_allocator_capacity = &memory_allocator_capacity;
357 : size_t malloced_memory;
358 0 : heap_stats.malloced_memory = &malloced_memory;
359 : size_t malloced_peak_memory;
360 0 : heap_stats.malloced_peak_memory = &malloced_peak_memory;
361 0 : size_t objects_per_type[LAST_TYPE + 1] = {0};
362 0 : heap_stats.objects_per_type = objects_per_type;
363 0 : size_t size_per_type[LAST_TYPE + 1] = {0};
364 0 : heap_stats.size_per_type = size_per_type;
365 : int os_error;
366 0 : heap_stats.os_error = &os_error;
367 0 : heap_stats.last_few_messages = last_few_messages;
368 0 : heap_stats.js_stacktrace = js_stacktrace;
369 : intptr_t end_marker;
370 0 : heap_stats.end_marker = &end_marker;
371 0 : if (isolate->heap()->HasBeenSetUp()) {
372 : // BUG(1718): Don't use the take_snapshot since we don't support
373 : // HeapIterator here without doing a special GC.
374 0 : isolate->heap()->RecordStats(&heap_stats, false);
375 : char* first_newline = strchr(last_few_messages, '\n');
376 0 : if (first_newline == NULL || first_newline[1] == '\0')
377 : first_newline = last_few_messages;
378 0 : PrintF("\n<--- Last few GCs --->\n%s\n", first_newline);
379 0 : PrintF("\n<--- JS stacktrace --->\n%s\n", js_stacktrace);
380 : }
381 0 : Utils::ReportOOMFailure(location, is_heap_oom);
382 : // If the fatal error handler returns, we stop execution.
383 0 : FATAL("API fatal error handler returned after process out of memory");
384 : }
385 :
386 :
387 12 : void Utils::ReportApiFailure(const char* location, const char* message) {
388 12 : i::Isolate* isolate = i::Isolate::Current();
389 : FatalErrorCallback callback = isolate->exception_behavior();
390 12 : if (callback == nullptr) {
391 : base::OS::PrintError("\n#\n# Fatal error in %s\n# %s\n#\n\n", location,
392 0 : message);
393 0 : base::OS::Abort();
394 : } else {
395 12 : callback(location, message);
396 : }
397 : isolate->SignalFatalError();
398 12 : }
399 :
400 0 : void Utils::ReportOOMFailure(const char* location, bool is_heap_oom) {
401 0 : i::Isolate* isolate = i::Isolate::Current();
402 : OOMErrorCallback oom_callback = isolate->oom_behavior();
403 0 : if (oom_callback == nullptr) {
404 : // TODO(wfh): Remove this fallback once Blink is setting OOM handler. See
405 : // crbug.com/614440.
406 : FatalErrorCallback fatal_callback = isolate->exception_behavior();
407 0 : if (fatal_callback == nullptr) {
408 : base::OS::PrintError("\n#\n# Fatal %s OOM in %s\n#\n\n",
409 0 : is_heap_oom ? "javascript" : "process", location);
410 0 : base::OS::Abort();
411 : } else {
412 : fatal_callback(location,
413 : is_heap_oom
414 : ? "Allocation failed - JavaScript heap out of memory"
415 0 : : "Allocation failed - process out of memory");
416 : }
417 : } else {
418 0 : oom_callback(location, is_heap_oom);
419 : }
420 : isolate->SignalFatalError();
421 0 : }
422 :
423 : static inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) {
424 242507927 : if (isolate->has_scheduled_exception()) {
425 : return isolate->scheduled_exception() ==
426 357 : isolate->heap()->termination_exception();
427 : }
428 : return false;
429 : }
430 :
431 :
432 59466 : void V8::SetNativesDataBlob(StartupData* natives_blob) {
433 59466 : i::V8::SetNativesBlob(natives_blob);
434 59466 : }
435 :
436 :
437 59466 : void V8::SetSnapshotDataBlob(StartupData* snapshot_blob) {
438 59466 : i::V8::SetSnapshotBlob(snapshot_blob);
439 59466 : }
440 :
441 : namespace {
442 :
443 8716 : class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
444 : public:
445 706 : virtual void* Allocate(size_t length) {
446 706 : void* data = AllocateUninitialized(length);
447 1412 : return data == NULL ? data : memset(data, 0, length);
448 : }
449 755 : virtual void* AllocateUninitialized(size_t length) { return malloc(length); }
450 683 : virtual void Free(void* data, size_t) { free(data); }
451 : };
452 :
453 60 : bool RunExtraCode(Isolate* isolate, Local<Context> context,
454 : const char* utf8_source, const char* name) {
455 : base::ElapsedTimer timer;
456 : timer.Start();
457 : Context::Scope context_scope(context);
458 120 : TryCatch try_catch(isolate);
459 : Local<String> source_string;
460 60 : if (!String::NewFromUtf8(isolate, utf8_source, NewStringType::kNormal)
461 120 : .ToLocal(&source_string)) {
462 : return false;
463 : }
464 : Local<String> resource_name =
465 : String::NewFromUtf8(isolate, name, NewStringType::kNormal)
466 60 : .ToLocalChecked();
467 : ScriptOrigin origin(resource_name);
468 : ScriptCompiler::Source source(source_string, origin);
469 : Local<Script> script;
470 120 : if (!ScriptCompiler::Compile(context, &source).ToLocal(&script)) return false;
471 120 : if (script->Run(context).IsEmpty()) return false;
472 60 : if (i::FLAG_profile_deserialization) {
473 : i::PrintF("Executing custom snapshot script %s took %0.3f ms\n", name,
474 0 : timer.Elapsed().InMillisecondsF());
475 : }
476 : timer.Stop();
477 60 : CHECK(!try_catch.HasCaught());
478 : return true;
479 : }
480 :
481 291 : struct SnapshotCreatorData {
482 : explicit SnapshotCreatorData(Isolate* isolate)
483 : : isolate_(isolate),
484 : default_context_(),
485 : contexts_(isolate),
486 : templates_(isolate),
487 194 : created_(false) {}
488 :
489 : static SnapshotCreatorData* cast(void* data) {
490 : return reinterpret_cast<SnapshotCreatorData*>(data);
491 : }
492 :
493 : ArrayBufferAllocator allocator_;
494 : Isolate* isolate_;
495 : Persistent<Context> default_context_;
496 : PersistentValueVector<Context> contexts_;
497 : PersistentValueVector<Template> templates_;
498 : std::vector<SerializeInternalFieldsCallback> embedder_fields_serializers_;
499 : bool created_;
500 : };
501 :
502 : } // namespace
503 :
504 97 : SnapshotCreator::SnapshotCreator(intptr_t* external_references,
505 : StartupData* existing_snapshot) {
506 97 : i::Isolate* internal_isolate = new i::Isolate(true);
507 : Isolate* isolate = reinterpret_cast<Isolate*>(internal_isolate);
508 97 : SnapshotCreatorData* data = new SnapshotCreatorData(isolate);
509 : data->isolate_ = isolate;
510 97 : internal_isolate->set_array_buffer_allocator(&data->allocator_);
511 : internal_isolate->set_api_external_references(external_references);
512 : isolate->Enter();
513 : const StartupData* blob = existing_snapshot
514 : ? existing_snapshot
515 97 : : i::Snapshot::DefaultSnapshotBlob();
516 97 : if (blob && blob->raw_size > 0) {
517 : internal_isolate->set_snapshot_blob(blob);
518 96 : i::Snapshot::Initialize(internal_isolate);
519 : } else {
520 1 : internal_isolate->Init(nullptr);
521 : }
522 97 : data_ = data;
523 97 : }
524 :
525 97 : SnapshotCreator::~SnapshotCreator() {
526 97 : SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
527 : DCHECK(data->created_);
528 97 : Isolate* isolate = data->isolate_;
529 : isolate->Exit();
530 97 : isolate->Dispose();
531 97 : delete data;
532 97 : }
533 :
534 24 : Isolate* SnapshotCreator::GetIsolate() {
535 97 : return SnapshotCreatorData::cast(data_)->isolate_;
536 : }
537 :
538 97 : void SnapshotCreator::SetDefaultContext(Local<Context> context) {
539 : DCHECK(!context.IsEmpty());
540 97 : SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
541 : DCHECK(!data->created_);
542 : DCHECK(data->default_context_.IsEmpty());
543 97 : Isolate* isolate = data->isolate_;
544 97 : CHECK_EQ(isolate, context->GetIsolate());
545 : data->default_context_.Reset(isolate, context);
546 97 : }
547 :
548 24 : size_t SnapshotCreator::AddContext(Local<Context> context,
549 : SerializeInternalFieldsCallback callback) {
550 : DCHECK(!context.IsEmpty());
551 24 : SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
552 : DCHECK(!data->created_);
553 24 : Isolate* isolate = data->isolate_;
554 24 : CHECK_EQ(isolate, context->GetIsolate());
555 24 : size_t index = static_cast<int>(data->contexts_.Size());
556 24 : data->contexts_.Append(context);
557 24 : data->embedder_fields_serializers_.push_back(callback);
558 24 : return index;
559 : }
560 :
561 12 : size_t SnapshotCreator::AddTemplate(Local<Template> template_obj) {
562 : DCHECK(!template_obj.IsEmpty());
563 12 : SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
564 : DCHECK(!data->created_);
565 : DCHECK_EQ(reinterpret_cast<i::Isolate*>(data->isolate_),
566 : Utils::OpenHandle(*template_obj)->GetIsolate());
567 12 : size_t index = static_cast<int>(data->templates_.Size());
568 12 : data->templates_.Append(template_obj);
569 12 : return index;
570 : }
571 :
572 97 : StartupData SnapshotCreator::CreateBlob(
573 : SnapshotCreator::FunctionCodeHandling function_code_handling) {
574 97 : SnapshotCreatorData* data = SnapshotCreatorData::cast(data_);
575 97 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(data->isolate_);
576 : DCHECK(!data->created_);
577 : DCHECK(!data->default_context_.IsEmpty());
578 :
579 97 : int num_additional_contexts = static_cast<int>(data->contexts_.Size());
580 :
581 : {
582 97 : int num_templates = static_cast<int>(data->templates_.Size());
583 : i::HandleScope scope(isolate);
584 : i::Handle<i::FixedArray> templates =
585 97 : isolate->factory()->NewFixedArray(num_templates, i::TENURED);
586 109 : for (int i = 0; i < num_templates; i++) {
587 24 : templates->set(i, *v8::Utils::OpenHandle(*data->templates_.Get(i)));
588 : }
589 : isolate->heap()->SetSerializedTemplates(*templates);
590 97 : data->templates_.Clear();
591 :
592 : // We need to store the global proxy size upfront in case we need the
593 : // bootstrapper to create a global proxy before we deserialize the context.
594 : i::Handle<i::FixedArray> global_proxy_sizes =
595 97 : isolate->factory()->NewFixedArray(num_additional_contexts, i::TENURED);
596 121 : for (int i = 0; i < num_additional_contexts; i++) {
597 : i::Handle<i::Context> context =
598 48 : v8::Utils::OpenHandle(*data->contexts_.Get(i));
599 : global_proxy_sizes->set(i,
600 24 : i::Smi::FromInt(context->global_proxy()->Size()));
601 : }
602 : isolate->heap()->SetSerializedGlobalProxySizes(*global_proxy_sizes);
603 : }
604 :
605 : // If we don't do this then we end up with a stray root pointing at the
606 : // context even after we have disposed of the context.
607 : isolate->heap()->CollectAllAvailableGarbage(
608 97 : i::GarbageCollectionReason::kSnapshotCreator);
609 97 : isolate->heap()->CompactWeakFixedArrays();
610 :
611 : i::DisallowHeapAllocation no_gc_from_here_on;
612 :
613 : i::List<i::Object*> contexts(num_additional_contexts);
614 : i::Object* default_context;
615 : {
616 : i::HandleScope scope(isolate);
617 : default_context =
618 194 : *v8::Utils::OpenHandle(*data->default_context_.Get(data->isolate_));
619 : data->default_context_.Reset();
620 24 : for (int i = 0; i < num_additional_contexts; i++) {
621 : i::Handle<i::Context> context =
622 48 : v8::Utils::OpenHandle(*data->contexts_.Get(i));
623 24 : contexts.Add(*context);
624 : }
625 97 : data->contexts_.Clear();
626 : }
627 :
628 : // Complete in-object slack tracking for all functions.
629 194 : i::HeapIterator heap_iterator(isolate->heap());
630 1273116 : while (i::HeapObject* current_obj = heap_iterator.next()) {
631 1273019 : if (!current_obj->IsJSFunction()) continue;
632 : i::JSFunction* fun = i::JSFunction::cast(current_obj);
633 151075 : fun->CompleteInobjectSlackTrackingIfActive();
634 : }
635 :
636 : #ifdef DEBUG
637 : i::ExternalReferenceTable::instance(isolate)->ResetCount();
638 : #endif // DEBUG
639 :
640 194 : i::StartupSerializer startup_serializer(isolate, function_code_handling);
641 97 : startup_serializer.SerializeStrongReferences();
642 :
643 : // Serialize each context with a new partial serializer.
644 97 : i::List<i::SnapshotData*> context_snapshots(num_additional_contexts + 1);
645 :
646 : {
647 : // The default snapshot does not support embedder fields.
648 : i::PartialSerializer partial_serializer(
649 97 : isolate, &startup_serializer, v8::SerializeInternalFieldsCallback());
650 97 : partial_serializer.Serialize(&default_context, false);
651 97 : context_snapshots.Add(new i::SnapshotData(&partial_serializer));
652 : }
653 :
654 121 : for (int i = 0; i < num_additional_contexts; i++) {
655 : i::PartialSerializer partial_serializer(
656 48 : isolate, &startup_serializer, data->embedder_fields_serializers_[i]);
657 48 : partial_serializer.Serialize(&contexts[i], true);
658 24 : context_snapshots.Add(new i::SnapshotData(&partial_serializer));
659 24 : }
660 :
661 97 : startup_serializer.SerializeWeakReferencesAndDeferred();
662 :
663 : #ifdef DEBUG
664 : if (i::FLAG_external_reference_stats) {
665 : i::ExternalReferenceTable::instance(isolate)->PrintCount();
666 : }
667 : #endif // DEBUG
668 :
669 97 : i::SnapshotData startup_snapshot(&startup_serializer);
670 : StartupData result =
671 97 : i::Snapshot::CreateSnapshotBlob(&startup_snapshot, &context_snapshots);
672 :
673 : // Delete heap-allocated context snapshot instances.
674 315 : for (const auto& context_snapshot : context_snapshots) {
675 242 : delete context_snapshot;
676 : }
677 97 : data->created_ = true;
678 194 : return result;
679 : }
680 :
681 61 : StartupData V8::CreateSnapshotDataBlob(const char* embedded_source) {
682 : // Create a new isolate and a new context from scratch, optionally run
683 : // a script to embed, and serialize to create a snapshot blob.
684 : StartupData result = {nullptr, 0};
685 : base::ElapsedTimer timer;
686 : timer.Start();
687 : {
688 61 : SnapshotCreator snapshot_creator;
689 : Isolate* isolate = snapshot_creator.GetIsolate();
690 : {
691 : HandleScope scope(isolate);
692 61 : Local<Context> context = Context::New(isolate);
693 109 : if (embedded_source != NULL &&
694 48 : !RunExtraCode(isolate, context, embedded_source, "<embedded>")) {
695 0 : return result;
696 : }
697 61 : snapshot_creator.SetDefaultContext(context);
698 : }
699 : result = snapshot_creator.CreateBlob(
700 61 : SnapshotCreator::FunctionCodeHandling::kClear);
701 : }
702 :
703 61 : if (i::FLAG_profile_deserialization) {
704 : i::PrintF("Creating snapshot took %0.3f ms\n",
705 6 : timer.Elapsed().InMillisecondsF());
706 : }
707 : timer.Stop();
708 61 : return result;
709 : }
710 :
711 12 : StartupData V8::WarmUpSnapshotDataBlob(StartupData cold_snapshot_blob,
712 : const char* warmup_source) {
713 12 : CHECK(cold_snapshot_blob.raw_size > 0 && cold_snapshot_blob.data != NULL);
714 12 : CHECK(warmup_source != NULL);
715 : // Use following steps to create a warmed up snapshot blob from a cold one:
716 : // - Create a new isolate from the cold snapshot.
717 : // - Create a new context to run the warmup script. This will trigger
718 : // compilation of executed functions.
719 : // - Create a new context. This context will be unpolluted.
720 : // - Serialize the isolate and the second context into a new snapshot blob.
721 : StartupData result = {nullptr, 0};
722 : base::ElapsedTimer timer;
723 : timer.Start();
724 : {
725 12 : SnapshotCreator snapshot_creator(nullptr, &cold_snapshot_blob);
726 : Isolate* isolate = snapshot_creator.GetIsolate();
727 : {
728 : HandleScope scope(isolate);
729 12 : Local<Context> context = Context::New(isolate);
730 12 : if (!RunExtraCode(isolate, context, warmup_source, "<warm-up>")) {
731 0 : return result;
732 : }
733 : }
734 : {
735 : HandleScope handle_scope(isolate);
736 : isolate->ContextDisposedNotification(false);
737 12 : Local<Context> context = Context::New(isolate);
738 12 : snapshot_creator.SetDefaultContext(context);
739 : }
740 : result = snapshot_creator.CreateBlob(
741 12 : SnapshotCreator::FunctionCodeHandling::kKeep);
742 : }
743 :
744 12 : if (i::FLAG_profile_deserialization) {
745 : i::PrintF("Warming up snapshot took %0.3f ms\n",
746 0 : timer.Elapsed().InMillisecondsF());
747 : }
748 : timer.Stop();
749 12 : return result;
750 : }
751 :
752 :
753 114472 : void V8::SetFlagsFromString(const char* str, int length) {
754 146710 : i::FlagList::SetFlagsFromString(str, length);
755 146710 : i::FlagList::EnforceFlagImplications();
756 114472 : }
757 :
758 :
759 33158 : void V8::SetFlagsFromCommandLine(int* argc, char** argv, bool remove_flags) {
760 33158 : i::FlagList::SetFlagsFromCommandLine(argc, argv, remove_flags);
761 33158 : }
762 :
763 :
764 : RegisteredExtension* RegisteredExtension::first_extension_ = NULL;
765 :
766 :
767 0 : RegisteredExtension::RegisteredExtension(Extension* extension)
768 435922 : : extension_(extension) { }
769 :
770 :
771 0 : void RegisteredExtension::Register(RegisteredExtension* that) {
772 435922 : that->next_ = first_extension_;
773 435922 : first_extension_ = that;
774 0 : }
775 :
776 :
777 32496 : void RegisteredExtension::UnregisterAll() {
778 227220 : RegisteredExtension* re = first_extension_;
779 259716 : while (re != NULL) {
780 : RegisteredExtension* next = re->next();
781 194724 : delete re;
782 : re = next;
783 : }
784 32496 : first_extension_ = NULL;
785 32496 : }
786 :
787 :
788 435922 : void RegisterExtension(Extension* that) {
789 435922 : RegisteredExtension* extension = new RegisteredExtension(that);
790 : RegisteredExtension::Register(extension);
791 435922 : }
792 :
793 :
794 435923 : Extension::Extension(const char* name,
795 : const char* source,
796 : int dep_count,
797 : const char** deps,
798 : int source_length)
799 : : name_(name),
800 : source_length_(source_length >= 0 ?
801 : source_length :
802 435899 : (source ? static_cast<int>(strlen(source)) : 0)),
803 : source_(source, source_length_),
804 : dep_count_(dep_count),
805 : deps_(deps),
806 1307745 : auto_enable_(false) {
807 435923 : CHECK(source != NULL || source_length_ == 0);
808 435923 : }
809 :
810 60565 : ResourceConstraints::ResourceConstraints()
811 : : max_semi_space_size_(0),
812 : max_old_space_size_(0),
813 : max_executable_size_(0),
814 : stack_limit_(NULL),
815 : code_range_size_(0),
816 60565 : max_zone_pool_size_(0) {}
817 :
818 28618 : void ResourceConstraints::ConfigureDefaults(uint64_t physical_memory,
819 : uint64_t virtual_memory_limit) {
820 : #if V8_OS_ANDROID
821 : // Android has higher physical memory requirements before raising the maximum
822 : // heap size limits since it has no swap space.
823 : const uint64_t low_limit = 512ul * i::MB;
824 : const uint64_t medium_limit = 1ul * i::GB;
825 : const uint64_t high_limit = 2ul * i::GB;
826 : #else
827 : const uint64_t low_limit = 512ul * i::MB;
828 : const uint64_t medium_limit = 768ul * i::MB;
829 : const uint64_t high_limit = 1ul * i::GB;
830 : #endif
831 :
832 28618 : if (physical_memory <= low_limit) {
833 : set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeLowMemoryDevice);
834 : set_max_old_space_size(i::Heap::kMaxOldSpaceSizeLowMemoryDevice);
835 : set_max_executable_size(i::Heap::kMaxExecutableSizeLowMemoryDevice);
836 : set_max_zone_pool_size(i::AccountingAllocator::kMaxPoolSizeLowMemoryDevice);
837 28618 : } else if (physical_memory <= medium_limit) {
838 : set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeMediumMemoryDevice);
839 : set_max_old_space_size(i::Heap::kMaxOldSpaceSizeMediumMemoryDevice);
840 : set_max_executable_size(i::Heap::kMaxExecutableSizeMediumMemoryDevice);
841 : set_max_zone_pool_size(
842 : i::AccountingAllocator::kMaxPoolSizeMediumMemoryDevice);
843 28618 : } else if (physical_memory <= high_limit) {
844 : set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeHighMemoryDevice);
845 : set_max_old_space_size(i::Heap::kMaxOldSpaceSizeHighMemoryDevice);
846 : set_max_executable_size(i::Heap::kMaxExecutableSizeHighMemoryDevice);
847 : set_max_zone_pool_size(
848 : i::AccountingAllocator::kMaxPoolSizeHighMemoryDevice);
849 : } else {
850 : set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeHugeMemoryDevice);
851 : set_max_old_space_size(i::Heap::kMaxOldSpaceSizeHugeMemoryDevice);
852 : set_max_executable_size(i::Heap::kMaxExecutableSizeHugeMemoryDevice);
853 : set_max_zone_pool_size(
854 : i::AccountingAllocator::kMaxPoolSizeHugeMemoryDevice);
855 : }
856 :
857 28618 : if (virtual_memory_limit > 0 && i::kRequiresCodeRange) {
858 : // Reserve no more than 1/8 of the memory for the code range, but at most
859 : // kMaximalCodeRangeSize.
860 : set_code_range_size(
861 : i::Min(i::kMaximalCodeRangeSize / i::MB,
862 0 : static_cast<size_t>((virtual_memory_limit >> 3) / i::MB)));
863 : }
864 28618 : }
865 :
866 :
867 121202 : void SetResourceConstraints(i::Isolate* isolate,
868 121202 : const ResourceConstraints& constraints) {
869 : int semi_space_size = constraints.max_semi_space_size();
870 : int old_space_size = constraints.max_old_space_size();
871 : int max_executable_size = constraints.max_executable_size();
872 : size_t code_range_size = constraints.code_range_size();
873 : size_t max_pool_size = constraints.max_zone_pool_size();
874 60601 : if (semi_space_size != 0 || old_space_size != 0 ||
875 31953 : max_executable_size != 0 || code_range_size != 0) {
876 : isolate->heap()->ConfigureHeap(semi_space_size, old_space_size,
877 28648 : max_executable_size, code_range_size);
878 : }
879 60601 : isolate->allocator()->ConfigureSegmentPool(max_pool_size);
880 :
881 60601 : if (constraints.stack_limit() != NULL) {
882 0 : uintptr_t limit = reinterpret_cast<uintptr_t>(constraints.stack_limit());
883 0 : isolate->stack_guard()->SetStackLimit(limit);
884 : }
885 60601 : }
886 :
887 :
888 13126536 : i::Object** V8::GlobalizeReference(i::Isolate* isolate, i::Object** obj) {
889 8751024 : LOG_API(isolate, Persistent, New);
890 8751024 : i::Handle<i::Object> result = isolate->global_handles()->Create(*obj);
891 : #ifdef VERIFY_HEAP
892 : if (i::FLAG_verify_heap) {
893 : (*obj)->ObjectVerify();
894 : }
895 : #endif // VERIFY_HEAP
896 4375512 : return result.location();
897 : }
898 :
899 :
900 12 : i::Object** V8::CopyPersistent(i::Object** obj) {
901 12 : i::Handle<i::Object> result = i::GlobalHandles::CopyGlobal(obj);
902 : #ifdef VERIFY_HEAP
903 : if (i::FLAG_verify_heap) {
904 : (*obj)->ObjectVerify();
905 : }
906 : #endif // VERIFY_HEAP
907 12 : return result.location();
908 : }
909 :
910 0 : void V8::RegisterExternallyReferencedObject(i::Object** object,
911 : i::Isolate* isolate) {
912 0 : isolate->heap()->RegisterExternallyReferencedObject(object);
913 0 : }
914 :
915 0 : void V8::MakeWeak(i::Object** location, void* parameter,
916 : int embedder_field_index1, int embedder_field_index2,
917 : WeakCallbackInfo<void>::Callback weak_callback) {
918 : WeakCallbackType type = WeakCallbackType::kParameter;
919 0 : if (embedder_field_index1 == 0) {
920 : if (embedder_field_index2 == 1) {
921 : type = WeakCallbackType::kInternalFields;
922 : } else {
923 : DCHECK_EQ(embedder_field_index2, -1);
924 : type = WeakCallbackType::kInternalFields;
925 : }
926 : } else {
927 : DCHECK_EQ(embedder_field_index1, -1);
928 : DCHECK_EQ(embedder_field_index2, -1);
929 : }
930 0 : i::GlobalHandles::MakeWeak(location, parameter, weak_callback, type);
931 0 : }
932 :
933 41665 : void V8::MakeWeak(i::Object** location, void* parameter,
934 : WeakCallbackInfo<void>::Callback weak_callback,
935 : WeakCallbackType type) {
936 41665 : i::GlobalHandles::MakeWeak(location, parameter, weak_callback, type);
937 41665 : }
938 :
939 13 : void V8::MakeWeak(i::Object*** location_addr) {
940 13 : i::GlobalHandles::MakeWeak(location_addr);
941 13 : }
942 :
943 30 : void* V8::ClearWeak(i::Object** location) {
944 30 : return i::GlobalHandles::ClearWeakness(location);
945 : }
946 :
947 4372648 : void V8::DisposeGlobal(i::Object** location) {
948 4372648 : i::GlobalHandles::Destroy(location);
949 4372648 : }
950 :
951 12288 : Value* V8::Eternalize(Isolate* v8_isolate, Value* value) {
952 24576 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
953 : i::Object* object = *Utils::OpenHandle(value);
954 12288 : int index = -1;
955 12288 : isolate->eternal_handles()->Create(isolate, object, &index);
956 : return reinterpret_cast<Value*>(
957 24576 : isolate->eternal_handles()->Get(index).location());
958 : }
959 :
960 :
961 0 : void V8::FromJustIsNothing() {
962 : Utils::ApiCheck(false, "v8::FromJust", "Maybe value is Nothing.");
963 0 : }
964 :
965 :
966 0 : void V8::ToLocalEmpty() {
967 : Utils::ApiCheck(false, "v8::ToLocalChecked", "Empty MaybeLocal.");
968 0 : }
969 :
970 0 : void V8::InternalFieldOutOfBounds(int index) {
971 : Utils::ApiCheck(0 <= index && index < kInternalFieldsInWeakCallback,
972 : "WeakCallbackInfo::GetInternalField",
973 0 : "Internal field out of bounds.");
974 0 : }
975 :
976 :
977 : // --- H a n d l e s ---
978 :
979 :
980 584756236 : HandleScope::HandleScope(Isolate* isolate) {
981 584756464 : Initialize(isolate);
982 584756230 : }
983 :
984 :
985 745348388 : void HandleScope::Initialize(Isolate* isolate) {
986 41349 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
987 : // We do not want to check the correct usage of the Locker class all over the
988 : // place, so we do it only here: Without a HandleScope, an embedder can do
989 : // almost nothing, so it is enough to check in this central place.
990 : // We make an exception if the serializer is enabled, which means that the
991 : // Isolate is exclusively used to create a snapshot.
992 : Utils::ApiCheck(
993 745389719 : !v8::Locker::IsActive() ||
994 745389733 : internal_isolate->thread_manager()->IsLockedByCurrentThread() ||
995 : internal_isolate->serializer_enabled(),
996 : "HandleScope::HandleScope",
997 : "Entering the V8 API without proper locking in place");
998 : i::HandleScopeData* current = internal_isolate->handle_scope_data();
999 745348384 : isolate_ = internal_isolate;
1000 745348384 : prev_next_ = current->next;
1001 745348384 : prev_limit_ = current->limit;
1002 745348384 : current->level++;
1003 745348384 : }
1004 :
1005 :
1006 745348134 : HandleScope::~HandleScope() {
1007 745348350 : i::HandleScope::CloseScope(isolate_, prev_next_, prev_limit_);
1008 745348148 : }
1009 :
1010 0 : V8_NORETURN void* HandleScope::operator new(size_t) {
1011 0 : base::OS::Abort();
1012 : abort();
1013 : }
1014 :
1015 0 : void HandleScope::operator delete(void*, size_t) { base::OS::Abort(); }
1016 :
1017 7042 : int HandleScope::NumberOfHandles(Isolate* isolate) {
1018 : return i::HandleScope::NumberOfHandles(
1019 7042 : reinterpret_cast<i::Isolate*>(isolate));
1020 : }
1021 :
1022 :
1023 164451669 : i::Object** HandleScope::CreateHandle(i::Isolate* isolate, i::Object* value) {
1024 164451666 : return i::HandleScope::CreateHandle(isolate, value);
1025 : }
1026 :
1027 :
1028 190 : i::Object** HandleScope::CreateHandle(i::HeapObject* heap_object,
1029 : i::Object* value) {
1030 : DCHECK(heap_object->IsHeapObject());
1031 190 : return i::HandleScope::CreateHandle(heap_object->GetIsolate(), value);
1032 : }
1033 :
1034 :
1035 160591991 : EscapableHandleScope::EscapableHandleScope(Isolate* v8_isolate) {
1036 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
1037 160591991 : escape_slot_ = CreateHandle(isolate, isolate->heap()->the_hole_value());
1038 160591984 : Initialize(v8_isolate);
1039 160591977 : }
1040 :
1041 :
1042 160531632 : i::Object** EscapableHandleScope::Escape(i::Object** escape_value) {
1043 160531638 : i::Heap* heap = reinterpret_cast<i::Isolate*>(GetIsolate())->heap();
1044 160531632 : Utils::ApiCheck((*escape_slot_)->IsTheHole(heap->isolate()),
1045 : "EscapableHandleScope::Escape", "Escape value set twice");
1046 160531631 : if (escape_value == NULL) {
1047 12 : *escape_slot_ = heap->undefined_value();
1048 6 : return NULL;
1049 : }
1050 160531625 : *escape_slot_ = *escape_value;
1051 160531625 : return escape_slot_;
1052 : }
1053 :
1054 0 : V8_NORETURN void* EscapableHandleScope::operator new(size_t) {
1055 0 : base::OS::Abort();
1056 : abort();
1057 : }
1058 :
1059 0 : void EscapableHandleScope::operator delete(void*, size_t) { base::OS::Abort(); }
1060 :
1061 6 : SealHandleScope::SealHandleScope(Isolate* isolate)
1062 6 : : isolate_(reinterpret_cast<i::Isolate*>(isolate)) {
1063 : i::HandleScopeData* current = isolate_->handle_scope_data();
1064 6 : prev_limit_ = current->limit;
1065 6 : current->limit = current->next;
1066 6 : prev_sealed_level_ = current->sealed_level;
1067 6 : current->sealed_level = current->level;
1068 6 : }
1069 :
1070 :
1071 6 : SealHandleScope::~SealHandleScope() {
1072 6 : i::HandleScopeData* current = isolate_->handle_scope_data();
1073 : DCHECK_EQ(current->next, current->limit);
1074 6 : current->limit = prev_limit_;
1075 : DCHECK_EQ(current->level, current->sealed_level);
1076 6 : current->sealed_level = prev_sealed_level_;
1077 6 : }
1078 :
1079 0 : V8_NORETURN void* SealHandleScope::operator new(size_t) {
1080 0 : base::OS::Abort();
1081 : abort();
1082 : }
1083 :
1084 0 : void SealHandleScope::operator delete(void*, size_t) { base::OS::Abort(); }
1085 :
1086 3232139 : void Context::Enter() {
1087 : i::Handle<i::Context> env = Utils::OpenHandle(this);
1088 6464290 : i::Isolate* isolate = env->GetIsolate();
1089 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1090 : i::HandleScopeImplementer* impl = isolate->handle_scope_implementer();
1091 : impl->EnterContext(env);
1092 : impl->SaveContext(isolate->context());
1093 : isolate->set_context(*env);
1094 3232141 : }
1095 :
1096 :
1097 3215952 : void Context::Exit() {
1098 : i::Handle<i::Context> env = Utils::OpenHandle(this);
1099 3215952 : i::Isolate* isolate = env->GetIsolate();
1100 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1101 : i::HandleScopeImplementer* impl = isolate->handle_scope_implementer();
1102 3215959 : if (!Utils::ApiCheck(impl->LastEnteredContextWas(env),
1103 : "v8::Context::Exit()",
1104 : "Cannot exit non-entered context")) {
1105 3215968 : return;
1106 : }
1107 : impl->LeaveContext();
1108 : isolate->set_context(impl->RestoreContext());
1109 : }
1110 :
1111 :
1112 : static void* DecodeSmiToAligned(i::Object* value, const char* location) {
1113 : Utils::ApiCheck(value->IsSmi(), location, "Not a Smi");
1114 : return reinterpret_cast<void*>(value);
1115 : }
1116 :
1117 :
1118 : static i::Smi* EncodeAlignedAsSmi(void* value, const char* location) {
1119 : i::Smi* smi = reinterpret_cast<i::Smi*>(value);
1120 : Utils::ApiCheck(smi->IsSmi(), location, "Pointer is not aligned");
1121 : return smi;
1122 : }
1123 :
1124 :
1125 133191 : static i::Handle<i::FixedArray> EmbedderDataFor(Context* context,
1126 : int index,
1127 : bool can_grow,
1128 : const char* location) {
1129 : i::Handle<i::Context> env = Utils::OpenHandle(context);
1130 : i::Isolate* isolate = env->GetIsolate();
1131 : bool ok =
1132 133191 : Utils::ApiCheck(env->IsNativeContext(),
1133 : location,
1134 266382 : "Not a native context") &&
1135 133191 : Utils::ApiCheck(index >= 0, location, "Negative index");
1136 133191 : if (!ok) return i::Handle<i::FixedArray>();
1137 : i::Handle<i::FixedArray> data(env->embedder_data());
1138 133191 : if (index < data->length()) return data;
1139 1500 : if (!Utils::ApiCheck(can_grow, location, "Index too large")) {
1140 0 : return i::Handle<i::FixedArray>();
1141 : }
1142 3000 : int new_size = i::Max(index, data->length() << 1) + 1;
1143 1500 : int grow_by = new_size - data->length();
1144 1500 : data = isolate->factory()->CopyFixedArrayAndGrow(data, grow_by);
1145 : env->set_embedder_data(*data);
1146 1500 : return data;
1147 : }
1148 :
1149 :
1150 0 : v8::Local<v8::Value> Context::SlowGetEmbedderData(int index) {
1151 : const char* location = "v8::Context::GetEmbedderData()";
1152 0 : i::Handle<i::FixedArray> data = EmbedderDataFor(this, index, false, location);
1153 0 : if (data.is_null()) return Local<Value>();
1154 : i::Handle<i::Object> result(data->get(index), data->GetIsolate());
1155 : return Utils::ToLocal(result);
1156 : }
1157 :
1158 :
1159 52 : void Context::SetEmbedderData(int index, v8::Local<Value> value) {
1160 : const char* location = "v8::Context::SetEmbedderData()";
1161 52 : i::Handle<i::FixedArray> data = EmbedderDataFor(this, index, true, location);
1162 104 : if (data.is_null()) return;
1163 : i::Handle<i::Object> val = Utils::OpenHandle(*value);
1164 52 : data->set(index, *val);
1165 : DCHECK_EQ(*Utils::OpenHandle(*value),
1166 : *Utils::OpenHandle(*GetEmbedderData(index)));
1167 : }
1168 :
1169 :
1170 0 : void* Context::SlowGetAlignedPointerFromEmbedderData(int index) {
1171 : const char* location = "v8::Context::GetAlignedPointerFromEmbedderData()";
1172 0 : i::Handle<i::FixedArray> data = EmbedderDataFor(this, index, false, location);
1173 0 : if (data.is_null()) return NULL;
1174 0 : return DecodeSmiToAligned(data->get(index), location);
1175 : }
1176 :
1177 :
1178 133139 : void Context::SetAlignedPointerInEmbedderData(int index, void* value) {
1179 : const char* location = "v8::Context::SetAlignedPointerInEmbedderData()";
1180 133139 : i::Handle<i::FixedArray> data = EmbedderDataFor(this, index, true, location);
1181 : data->set(index, EncodeAlignedAsSmi(value, location));
1182 : DCHECK_EQ(value, GetAlignedPointerFromEmbedderData(index));
1183 133139 : }
1184 :
1185 :
1186 : // --- T e m p l a t e ---
1187 :
1188 :
1189 : static void InitializeTemplate(i::Handle<i::TemplateInfo> that, int type) {
1190 : that->set_number_of_properties(0);
1191 4212637 : that->set_tag(i::Smi::FromInt(type));
1192 : }
1193 :
1194 :
1195 2160766 : void Template::Set(v8::Local<Name> name, v8::Local<Data> value,
1196 : v8::PropertyAttribute attribute) {
1197 : auto templ = Utils::OpenHandle(this);
1198 : i::Isolate* isolate = templ->GetIsolate();
1199 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1200 : i::HandleScope scope(isolate);
1201 : auto value_obj = Utils::OpenHandle(*value);
1202 2160766 : CHECK(!value_obj->IsJSReceiver() || value_obj->IsTemplateInfo());
1203 2160766 : if (value_obj->IsObjectTemplateInfo()) {
1204 188951 : templ->set_serial_number(i::Smi::kZero);
1205 188951 : if (templ->IsFunctionTemplateInfo()) {
1206 : i::Handle<i::FunctionTemplateInfo>::cast(templ)->set_do_not_cache(true);
1207 : }
1208 : }
1209 : i::ApiNatives::AddDataProperty(isolate, templ, Utils::OpenHandle(*name),
1210 : value_obj,
1211 2160766 : static_cast<i::PropertyAttributes>(attribute));
1212 2160766 : }
1213 :
1214 0 : void Template::SetPrivate(v8::Local<Private> name, v8::Local<Data> value,
1215 : v8::PropertyAttribute attribute) {
1216 : Set(Utils::ToLocal(Utils::OpenHandle(reinterpret_cast<Name*>(*name))), value,
1217 0 : attribute);
1218 0 : }
1219 :
1220 107 : void Template::SetAccessorProperty(
1221 : v8::Local<v8::Name> name,
1222 : v8::Local<FunctionTemplate> getter,
1223 : v8::Local<FunctionTemplate> setter,
1224 : v8::PropertyAttribute attribute,
1225 : v8::AccessControl access_control) {
1226 : // TODO(verwaest): Remove |access_control|.
1227 : DCHECK_EQ(v8::DEFAULT, access_control);
1228 : auto templ = Utils::OpenHandle(this);
1229 : auto isolate = templ->GetIsolate();
1230 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1231 : DCHECK(!name.IsEmpty());
1232 : DCHECK(!getter.IsEmpty() || !setter.IsEmpty());
1233 : i::HandleScope scope(isolate);
1234 : i::ApiNatives::AddAccessorProperty(
1235 : isolate, templ, Utils::OpenHandle(*name),
1236 : Utils::OpenHandle(*getter, true), Utils::OpenHandle(*setter, true),
1237 107 : static_cast<i::PropertyAttributes>(attribute));
1238 107 : }
1239 :
1240 :
1241 : // --- F u n c t i o n T e m p l a t e ---
1242 3763083 : static void InitializeFunctionTemplate(
1243 : i::Handle<i::FunctionTemplateInfo> info) {
1244 : InitializeTemplate(info, Consts::FUNCTION_TEMPLATE);
1245 : info->set_flag(0);
1246 3763085 : }
1247 :
1248 : static Local<ObjectTemplate> ObjectTemplateNew(
1249 : i::Isolate* isolate, v8::Local<FunctionTemplate> constructor,
1250 : bool do_not_cache);
1251 :
1252 187898 : Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate() {
1253 : i::Isolate* i_isolate = Utils::OpenHandle(this)->GetIsolate();
1254 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
1255 : i::Handle<i::Object> result(Utils::OpenHandle(this)->prototype_template(),
1256 : i_isolate);
1257 187898 : if (result->IsUndefined(i_isolate)) {
1258 : // Do not cache prototype objects.
1259 : result = Utils::OpenHandle(
1260 125818 : *ObjectTemplateNew(i_isolate, Local<FunctionTemplate>(), true));
1261 62909 : Utils::OpenHandle(this)->set_prototype_template(*result);
1262 : }
1263 187898 : return ToApiHandle<ObjectTemplate>(result);
1264 : }
1265 :
1266 6 : void FunctionTemplate::SetPrototypeProviderTemplate(
1267 : Local<FunctionTemplate> prototype_provider) {
1268 : i::Isolate* i_isolate = Utils::OpenHandle(this)->GetIsolate();
1269 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
1270 : i::Handle<i::Object> result = Utils::OpenHandle(*prototype_provider);
1271 : auto info = Utils::OpenHandle(this);
1272 6 : CHECK(info->prototype_template()->IsUndefined(i_isolate));
1273 6 : CHECK(info->parent_template()->IsUndefined(i_isolate));
1274 6 : info->set_prototype_provider_template(*result);
1275 6 : }
1276 :
1277 5486241 : static void EnsureNotInstantiated(i::Handle<i::FunctionTemplateInfo> info,
1278 : const char* func) {
1279 5486241 : Utils::ApiCheck(!info->instantiated(), func,
1280 : "FunctionTemplate already instantiated");
1281 5486244 : }
1282 :
1283 :
1284 275 : void FunctionTemplate::Inherit(v8::Local<FunctionTemplate> value) {
1285 : auto info = Utils::OpenHandle(this);
1286 275 : EnsureNotInstantiated(info, "v8::FunctionTemplate::Inherit");
1287 : i::Isolate* i_isolate = info->GetIsolate();
1288 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
1289 275 : CHECK(info->prototype_provider_template()->IsUndefined(i_isolate));
1290 275 : info->set_parent_template(*Utils::OpenHandle(*value));
1291 275 : }
1292 :
1293 3763086 : static Local<FunctionTemplate> FunctionTemplateNew(
1294 : i::Isolate* isolate, FunctionCallback callback, v8::Local<Value> data,
1295 : v8::Local<Signature> signature, int length, bool do_not_cache,
1296 : v8::Local<Private> cached_property_name = v8::Local<Private>()) {
1297 : i::Handle<i::Struct> struct_obj =
1298 3763086 : isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE);
1299 : i::Handle<i::FunctionTemplateInfo> obj =
1300 : i::Handle<i::FunctionTemplateInfo>::cast(struct_obj);
1301 3763083 : InitializeFunctionTemplate(obj);
1302 : obj->set_do_not_cache(do_not_cache);
1303 : int next_serial_number = i::FunctionTemplateInfo::kInvalidSerialNumber;
1304 3763086 : if (!do_not_cache) {
1305 : next_serial_number = isolate->heap()->GetNextTemplateSerialNumber();
1306 : }
1307 3763086 : obj->set_serial_number(i::Smi::FromInt(next_serial_number));
1308 3763087 : if (callback != 0) {
1309 3631058 : if (data.IsEmpty()) {
1310 : data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1311 : }
1312 3631058 : Utils::ToLocal(obj)->SetCallHandler(callback, data);
1313 : }
1314 : obj->set_length(length);
1315 : obj->set_undetectable(false);
1316 : obj->set_needs_access_check(false);
1317 : obj->set_accept_any_receiver(true);
1318 3763089 : if (!signature.IsEmpty())
1319 187670 : obj->set_signature(*Utils::OpenHandle(*signature));
1320 : obj->set_cached_property_name(
1321 : cached_property_name.IsEmpty()
1322 3763062 : ? isolate->heap()->the_hole_value()
1323 7526178 : : *Utils::OpenHandle(*cached_property_name));
1324 3763088 : return Utils::ToLocal(obj);
1325 : }
1326 :
1327 3720162 : Local<FunctionTemplate> FunctionTemplate::New(
1328 : Isolate* isolate, FunctionCallback callback, v8::Local<Value> data,
1329 : v8::Local<Signature> signature, int length, ConstructorBehavior behavior) {
1330 3720167 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
1331 : // Changes to the environment cannot be captured in the snapshot. Expect no
1332 : // function templates when the isolate is created for serialization.
1333 7440329 : LOG_API(i_isolate, FunctionTemplate, New);
1334 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
1335 : auto templ =
1336 3720167 : FunctionTemplateNew(i_isolate, callback, data, signature, length, false);
1337 3720167 : if (behavior == ConstructorBehavior::kThrow) templ->RemovePrototype();
1338 7440336 : return templ;
1339 : }
1340 :
1341 12 : MaybeLocal<FunctionTemplate> FunctionTemplate::FromSnapshot(Isolate* isolate,
1342 : size_t index) {
1343 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
1344 12 : i::FixedArray* templates = i_isolate->heap()->serialized_templates();
1345 12 : int int_index = static_cast<int>(index);
1346 12 : if (int_index < templates->length()) {
1347 : i::Object* info = templates->get(int_index);
1348 6 : if (info->IsFunctionTemplateInfo()) {
1349 : return Utils::ToLocal(i::Handle<i::FunctionTemplateInfo>(
1350 6 : i::FunctionTemplateInfo::cast(info)));
1351 : }
1352 : }
1353 6 : return Local<FunctionTemplate>();
1354 : }
1355 :
1356 27 : Local<FunctionTemplate> FunctionTemplate::NewWithCache(
1357 : Isolate* isolate, FunctionCallback callback, Local<Private> cache_property,
1358 : Local<Value> data, Local<Signature> signature, int length) {
1359 27 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
1360 54 : LOG_API(i_isolate, FunctionTemplate, NewWithCache);
1361 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
1362 : return FunctionTemplateNew(i_isolate, callback, data, signature, length,
1363 54 : false, cache_property);
1364 : }
1365 :
1366 62688 : Local<Signature> Signature::New(Isolate* isolate,
1367 : Local<FunctionTemplate> receiver) {
1368 62688 : return Utils::SignatureToLocal(Utils::OpenHandle(*receiver));
1369 : }
1370 :
1371 :
1372 21 : Local<AccessorSignature> AccessorSignature::New(
1373 : Isolate* isolate, Local<FunctionTemplate> receiver) {
1374 21 : return Utils::AccessorSignatureToLocal(Utils::OpenHandle(*receiver));
1375 : }
1376 :
1377 :
1378 : #define SET_FIELD_WRAPPED(obj, setter, cdata) do { \
1379 : i::Handle<i::Object> foreign = FromCData(obj->GetIsolate(), cdata); \
1380 : (obj)->setter(*foreign); \
1381 : } while (false)
1382 :
1383 3631083 : void FunctionTemplate::SetCallHandler(FunctionCallback callback,
1384 : v8::Local<Value> data) {
1385 : auto info = Utils::OpenHandle(this);
1386 3631083 : EnsureNotInstantiated(info, "v8::FunctionTemplate::SetCallHandler");
1387 : i::Isolate* isolate = info->GetIsolate();
1388 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1389 : i::HandleScope scope(isolate);
1390 : i::Handle<i::Struct> struct_obj =
1391 3631086 : isolate->factory()->NewStruct(i::TUPLE2_TYPE);
1392 : i::Handle<i::CallHandlerInfo> obj =
1393 : i::Handle<i::CallHandlerInfo>::cast(struct_obj);
1394 7262171 : SET_FIELD_WRAPPED(obj, set_callback, callback);
1395 3631086 : if (data.IsEmpty()) {
1396 : data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1397 : }
1398 3631086 : obj->set_data(*Utils::OpenHandle(*data));
1399 3631087 : info->set_call_code(*obj);
1400 3631086 : }
1401 :
1402 :
1403 70546 : static i::Handle<i::AccessorInfo> SetAccessorInfoProperties(
1404 : i::Handle<i::AccessorInfo> obj, v8::Local<Name> name,
1405 : v8::AccessControl settings, v8::PropertyAttribute attributes,
1406 : v8::Local<AccessorSignature> signature) {
1407 70546 : obj->set_name(*Utils::OpenHandle(*name));
1408 70546 : if (settings & ALL_CAN_READ) obj->set_all_can_read(true);
1409 70546 : if (settings & ALL_CAN_WRITE) obj->set_all_can_write(true);
1410 : obj->set_property_attributes(static_cast<i::PropertyAttributes>(attributes));
1411 70546 : if (!signature.IsEmpty()) {
1412 21 : obj->set_expected_receiver_type(*Utils::OpenHandle(*signature));
1413 : }
1414 70546 : return obj;
1415 : }
1416 :
1417 : namespace {
1418 :
1419 : template <typename Getter, typename Setter>
1420 70546 : i::Handle<i::AccessorInfo> MakeAccessorInfo(
1421 : v8::Local<Name> name, Getter getter, Setter setter, v8::Local<Value> data,
1422 : v8::AccessControl settings, v8::PropertyAttribute attributes,
1423 : v8::Local<AccessorSignature> signature, bool is_special_data_property,
1424 : bool replace_on_access) {
1425 : i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate();
1426 70546 : i::Handle<i::AccessorInfo> obj = isolate->factory()->NewAccessorInfo();
1427 141092 : SET_FIELD_WRAPPED(obj, set_getter, getter);
1428 : DCHECK_IMPLIES(replace_on_access,
1429 : is_special_data_property && setter == nullptr);
1430 70546 : if (is_special_data_property && setter == nullptr) {
1431 : setter = reinterpret_cast<Setter>(&i::Accessors::ReconfigureToDataProperty);
1432 : }
1433 141092 : SET_FIELD_WRAPPED(obj, set_setter, setter);
1434 70546 : i::Address redirected = obj->redirected_getter();
1435 211584 : if (redirected != nullptr) SET_FIELD_WRAPPED(obj, set_js_getter, redirected);
1436 70546 : if (data.IsEmpty()) {
1437 : data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1438 : }
1439 70546 : obj->set_data(*Utils::OpenHandle(*data));
1440 : obj->set_is_special_data_property(is_special_data_property);
1441 : obj->set_replace_on_access(replace_on_access);
1442 70546 : return SetAccessorInfoProperties(obj, name, settings, attributes, signature);
1443 : }
1444 :
1445 : } // namespace
1446 :
1447 71240 : Local<ObjectTemplate> FunctionTemplate::InstanceTemplate() {
1448 : i::Handle<i::FunctionTemplateInfo> handle = Utils::OpenHandle(this, true);
1449 142480 : if (!Utils::ApiCheck(!handle.is_null(),
1450 : "v8::FunctionTemplate::InstanceTemplate()",
1451 : "Reading from empty handle")) {
1452 0 : return Local<ObjectTemplate>();
1453 : }
1454 : i::Isolate* isolate = handle->GetIsolate();
1455 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1456 71240 : if (handle->instance_template()->IsUndefined(isolate)) {
1457 : Local<ObjectTemplate> templ =
1458 : ObjectTemplate::New(isolate, ToApiHandle<FunctionTemplate>(handle));
1459 63836 : handle->set_instance_template(*Utils::OpenHandle(*templ));
1460 : }
1461 : i::Handle<i::ObjectTemplateInfo> result(
1462 : i::ObjectTemplateInfo::cast(handle->instance_template()));
1463 : return Utils::ToLocal(result);
1464 : }
1465 :
1466 :
1467 14 : void FunctionTemplate::SetLength(int length) {
1468 : auto info = Utils::OpenHandle(this);
1469 14 : EnsureNotInstantiated(info, "v8::FunctionTemplate::SetLength");
1470 : auto isolate = info->GetIsolate();
1471 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1472 : info->set_length(length);
1473 14 : }
1474 :
1475 :
1476 62710 : void FunctionTemplate::SetClassName(Local<String> name) {
1477 : auto info = Utils::OpenHandle(this);
1478 62710 : EnsureNotInstantiated(info, "v8::FunctionTemplate::SetClassName");
1479 : auto isolate = info->GetIsolate();
1480 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1481 62710 : info->set_class_name(*Utils::OpenHandle(*name));
1482 62710 : }
1483 :
1484 :
1485 8 : void FunctionTemplate::SetAcceptAnyReceiver(bool value) {
1486 : auto info = Utils::OpenHandle(this);
1487 8 : EnsureNotInstantiated(info, "v8::FunctionTemplate::SetAcceptAnyReceiver");
1488 : auto isolate = info->GetIsolate();
1489 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1490 : info->set_accept_any_receiver(value);
1491 8 : }
1492 :
1493 :
1494 299 : void FunctionTemplate::SetHiddenPrototype(bool value) {
1495 : auto info = Utils::OpenHandle(this);
1496 299 : EnsureNotInstantiated(info, "v8::FunctionTemplate::SetHiddenPrototype");
1497 : auto isolate = info->GetIsolate();
1498 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1499 : info->set_hidden_prototype(value);
1500 299 : }
1501 :
1502 :
1503 1748625 : void FunctionTemplate::ReadOnlyPrototype() {
1504 : auto info = Utils::OpenHandle(this);
1505 1748625 : EnsureNotInstantiated(info, "v8::FunctionTemplate::ReadOnlyPrototype");
1506 : auto isolate = info->GetIsolate();
1507 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1508 : info->set_read_only_prototype(true);
1509 1748625 : }
1510 :
1511 :
1512 41188 : void FunctionTemplate::RemovePrototype() {
1513 : auto info = Utils::OpenHandle(this);
1514 41188 : EnsureNotInstantiated(info, "v8::FunctionTemplate::RemovePrototype");
1515 : auto isolate = info->GetIsolate();
1516 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1517 : info->set_remove_prototype(true);
1518 41188 : }
1519 :
1520 :
1521 : // --- O b j e c t T e m p l a t e ---
1522 :
1523 :
1524 258010 : Local<ObjectTemplate> ObjectTemplate::New(
1525 : Isolate* isolate, v8::Local<FunctionTemplate> constructor) {
1526 258010 : return New(reinterpret_cast<i::Isolate*>(isolate), constructor);
1527 : }
1528 :
1529 :
1530 0 : Local<ObjectTemplate> ObjectTemplate::New() {
1531 0 : return New(i::Isolate::Current(), Local<FunctionTemplate>());
1532 : }
1533 :
1534 449554 : static Local<ObjectTemplate> ObjectTemplateNew(
1535 449554 : i::Isolate* isolate, v8::Local<FunctionTemplate> constructor,
1536 : bool do_not_cache) {
1537 899108 : LOG_API(isolate, ObjectTemplate, New);
1538 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1539 : i::Handle<i::Struct> struct_obj =
1540 449554 : isolate->factory()->NewStruct(i::OBJECT_TEMPLATE_INFO_TYPE);
1541 : i::Handle<i::ObjectTemplateInfo> obj =
1542 : i::Handle<i::ObjectTemplateInfo>::cast(struct_obj);
1543 : InitializeTemplate(obj, Consts::OBJECT_TEMPLATE);
1544 : int next_serial_number = 0;
1545 449554 : if (!do_not_cache) {
1546 : next_serial_number = isolate->heap()->GetNextTemplateSerialNumber();
1547 : }
1548 449554 : obj->set_serial_number(i::Smi::FromInt(next_serial_number));
1549 449554 : if (!constructor.IsEmpty())
1550 66554 : obj->set_constructor(*Utils::OpenHandle(*constructor));
1551 449554 : obj->set_data(i::Smi::kZero);
1552 449554 : return Utils::ToLocal(obj);
1553 : }
1554 :
1555 0 : Local<ObjectTemplate> ObjectTemplate::New(
1556 : i::Isolate* isolate, v8::Local<FunctionTemplate> constructor) {
1557 386645 : return ObjectTemplateNew(isolate, constructor, false);
1558 : }
1559 :
1560 12 : MaybeLocal<ObjectTemplate> ObjectTemplate::FromSnapshot(Isolate* isolate,
1561 : size_t index) {
1562 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
1563 12 : i::FixedArray* templates = i_isolate->heap()->serialized_templates();
1564 12 : int int_index = static_cast<int>(index);
1565 12 : if (int_index < templates->length()) {
1566 : i::Object* info = templates->get(int_index);
1567 6 : if (info->IsObjectTemplateInfo()) {
1568 : return Utils::ToLocal(
1569 6 : i::Handle<i::ObjectTemplateInfo>(i::ObjectTemplateInfo::cast(info)));
1570 : }
1571 : }
1572 6 : return Local<ObjectTemplate>();
1573 : }
1574 :
1575 : // Ensure that the object template has a constructor. If no
1576 : // constructor is available we create one.
1577 194399 : static i::Handle<i::FunctionTemplateInfo> EnsureConstructor(
1578 : i::Isolate* isolate,
1579 : ObjectTemplate* object_template) {
1580 : i::Object* obj = Utils::OpenHandle(object_template)->constructor();
1581 194399 : if (!obj->IsUndefined(isolate)) {
1582 : i::FunctionTemplateInfo* info = i::FunctionTemplateInfo::cast(obj);
1583 64143 : return i::Handle<i::FunctionTemplateInfo>(info, isolate);
1584 : }
1585 : Local<FunctionTemplate> templ =
1586 130256 : FunctionTemplate::New(reinterpret_cast<Isolate*>(isolate));
1587 : i::Handle<i::FunctionTemplateInfo> constructor = Utils::OpenHandle(*templ);
1588 130256 : constructor->set_instance_template(*Utils::OpenHandle(object_template));
1589 130256 : Utils::OpenHandle(object_template)->set_constructor(*constructor);
1590 130256 : return constructor;
1591 : }
1592 :
1593 : template <typename Getter, typename Setter, typename Data, typename Template>
1594 63481 : static bool TemplateSetAccessor(Template* template_obj, v8::Local<Name> name,
1595 : Getter getter, Setter setter, Data data,
1596 : AccessControl settings,
1597 : PropertyAttribute attribute,
1598 : v8::Local<AccessorSignature> signature,
1599 : bool is_special_data_property,
1600 : bool replace_on_access) {
1601 : auto info = Utils::OpenHandle(template_obj);
1602 : auto isolate = info->GetIsolate();
1603 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1604 : i::HandleScope scope(isolate);
1605 : auto obj =
1606 : MakeAccessorInfo(name, getter, setter, data, settings, attribute,
1607 63481 : signature, is_special_data_property, replace_on_access);
1608 63481 : if (obj.is_null()) return false;
1609 63481 : i::ApiNatives::AddNativeDataProperty(isolate, info, obj);
1610 63481 : return true;
1611 : }
1612 :
1613 :
1614 215 : void Template::SetNativeDataProperty(v8::Local<String> name,
1615 : AccessorGetterCallback getter,
1616 : AccessorSetterCallback setter,
1617 : v8::Local<Value> data,
1618 : PropertyAttribute attribute,
1619 : v8::Local<AccessorSignature> signature,
1620 : AccessControl settings) {
1621 : TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1622 215 : signature, true, false);
1623 215 : }
1624 :
1625 :
1626 0 : void Template::SetNativeDataProperty(v8::Local<Name> name,
1627 : AccessorNameGetterCallback getter,
1628 : AccessorNameSetterCallback setter,
1629 : v8::Local<Value> data,
1630 : PropertyAttribute attribute,
1631 : v8::Local<AccessorSignature> signature,
1632 : AccessControl settings) {
1633 : TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1634 0 : signature, true, false);
1635 0 : }
1636 :
1637 0 : void Template::SetLazyDataProperty(v8::Local<Name> name,
1638 : AccessorNameGetterCallback getter,
1639 : v8::Local<Value> data,
1640 : PropertyAttribute attribute) {
1641 : TemplateSetAccessor(
1642 : this, name, getter, static_cast<AccessorNameSetterCallback>(nullptr),
1643 0 : data, DEFAULT, attribute, Local<AccessorSignature>(), true, true);
1644 0 : }
1645 :
1646 48 : void Template::SetIntrinsicDataProperty(Local<Name> name, Intrinsic intrinsic,
1647 : PropertyAttribute attribute) {
1648 : auto templ = Utils::OpenHandle(this);
1649 : i::Isolate* isolate = templ->GetIsolate();
1650 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1651 : i::HandleScope scope(isolate);
1652 : i::ApiNatives::AddDataProperty(isolate, templ, Utils::OpenHandle(*name),
1653 : intrinsic,
1654 48 : static_cast<i::PropertyAttributes>(attribute));
1655 48 : }
1656 :
1657 :
1658 63175 : void ObjectTemplate::SetAccessor(v8::Local<String> name,
1659 : AccessorGetterCallback getter,
1660 : AccessorSetterCallback setter,
1661 : v8::Local<Value> data, AccessControl settings,
1662 : PropertyAttribute attribute,
1663 : v8::Local<AccessorSignature> signature) {
1664 : TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1665 126350 : signature, i::FLAG_disable_old_api_accessors, false);
1666 63175 : }
1667 :
1668 :
1669 91 : void ObjectTemplate::SetAccessor(v8::Local<Name> name,
1670 : AccessorNameGetterCallback getter,
1671 : AccessorNameSetterCallback setter,
1672 : v8::Local<Value> data, AccessControl settings,
1673 : PropertyAttribute attribute,
1674 : v8::Local<AccessorSignature> signature) {
1675 : TemplateSetAccessor(this, name, getter, setter, data, settings, attribute,
1676 91 : signature, i::FLAG_disable_old_api_accessors, false);
1677 91 : }
1678 :
1679 : template <typename Getter, typename Setter, typename Query, typename Descriptor,
1680 : typename Deleter, typename Enumerator, typename Definer>
1681 1389 : static i::Handle<i::InterceptorInfo> CreateInterceptorInfo(
1682 : i::Isolate* isolate, Getter getter, Setter setter, Query query,
1683 : Descriptor descriptor, Deleter remover, Enumerator enumerator,
1684 : Definer definer, Local<Value> data, PropertyHandlerFlags flags) {
1685 : DCHECK(query == nullptr ||
1686 : descriptor == nullptr); // Either intercept attributes or descriptor.
1687 : DCHECK(query == nullptr ||
1688 : definer ==
1689 : nullptr); // Only use descriptor callback with definer callback.
1690 : auto obj = i::Handle<i::InterceptorInfo>::cast(
1691 1389 : isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE));
1692 : obj->set_flags(0);
1693 :
1694 3727 : if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter);
1695 2399 : if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter);
1696 1809 : if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query);
1697 1441 : if (descriptor != 0) SET_FIELD_WRAPPED(obj, set_descriptor, descriptor);
1698 1567 : if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover);
1699 1725 : if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator);
1700 1581 : if (definer != 0) SET_FIELD_WRAPPED(obj, set_definer, definer);
1701 : obj->set_can_intercept_symbols(
1702 : !(static_cast<int>(flags) &
1703 1389 : static_cast<int>(PropertyHandlerFlags::kOnlyInterceptStrings)));
1704 : obj->set_all_can_read(static_cast<int>(flags) &
1705 1389 : static_cast<int>(PropertyHandlerFlags::kAllCanRead));
1706 : obj->set_non_masking(static_cast<int>(flags) &
1707 1389 : static_cast<int>(PropertyHandlerFlags::kNonMasking));
1708 :
1709 1389 : if (data.IsEmpty()) {
1710 : data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1711 : }
1712 1389 : obj->set_data(*Utils::OpenHandle(*data));
1713 1389 : return obj;
1714 : }
1715 :
1716 : template <typename Getter, typename Setter, typename Query, typename Descriptor,
1717 : typename Deleter, typename Enumerator, typename Definer>
1718 1098 : static void ObjectTemplateSetNamedPropertyHandler(
1719 : ObjectTemplate* templ, Getter getter, Setter setter, Query query,
1720 : Descriptor descriptor, Deleter remover, Enumerator enumerator,
1721 : Definer definer, Local<Value> data, PropertyHandlerFlags flags) {
1722 : i::Isolate* isolate = Utils::OpenHandle(templ)->GetIsolate();
1723 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1724 : i::HandleScope scope(isolate);
1725 1098 : auto cons = EnsureConstructor(isolate, templ);
1726 1098 : EnsureNotInstantiated(cons, "ObjectTemplateSetNamedPropertyHandler");
1727 : auto obj = CreateInterceptorInfo(isolate, getter, setter, query, descriptor,
1728 1098 : remover, enumerator, definer, data, flags);
1729 1098 : cons->set_named_property_handler(*obj);
1730 1098 : }
1731 :
1732 14 : void ObjectTemplate::SetNamedPropertyHandler(
1733 : NamedPropertyGetterCallback getter, NamedPropertySetterCallback setter,
1734 : NamedPropertyQueryCallback query, NamedPropertyDeleterCallback remover,
1735 : NamedPropertyEnumeratorCallback enumerator, Local<Value> data) {
1736 : ObjectTemplateSetNamedPropertyHandler(
1737 : this, getter, setter, query, nullptr, remover, enumerator, nullptr, data,
1738 14 : PropertyHandlerFlags::kOnlyInterceptStrings);
1739 14 : }
1740 :
1741 1084 : void ObjectTemplate::SetHandler(
1742 : const NamedPropertyHandlerConfiguration& config) {
1743 : ObjectTemplateSetNamedPropertyHandler(
1744 : this, config.getter, config.setter, config.query, config.descriptor,
1745 : config.deleter, config.enumerator, config.definer, config.data,
1746 1084 : config.flags);
1747 1084 : }
1748 :
1749 :
1750 223 : void ObjectTemplate::MarkAsUndetectable() {
1751 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1752 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1753 : i::HandleScope scope(isolate);
1754 223 : auto cons = EnsureConstructor(isolate, this);
1755 223 : EnsureNotInstantiated(cons, "v8::ObjectTemplate::MarkAsUndetectable");
1756 : cons->set_undetectable(true);
1757 223 : }
1758 :
1759 :
1760 180 : void ObjectTemplate::SetAccessCheckCallback(AccessCheckCallback callback,
1761 : Local<Value> data) {
1762 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1763 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1764 : i::HandleScope scope(isolate);
1765 180 : auto cons = EnsureConstructor(isolate, this);
1766 180 : EnsureNotInstantiated(cons, "v8::ObjectTemplate::SetAccessCheckCallback");
1767 :
1768 : i::Handle<i::Struct> struct_info =
1769 180 : isolate->factory()->NewStruct(i::ACCESS_CHECK_INFO_TYPE);
1770 : i::Handle<i::AccessCheckInfo> info =
1771 : i::Handle<i::AccessCheckInfo>::cast(struct_info);
1772 :
1773 360 : SET_FIELD_WRAPPED(info, set_callback, callback);
1774 180 : info->set_named_interceptor(nullptr);
1775 180 : info->set_indexed_interceptor(nullptr);
1776 :
1777 180 : if (data.IsEmpty()) {
1778 : data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1779 : }
1780 180 : info->set_data(*Utils::OpenHandle(*data));
1781 :
1782 180 : cons->set_access_check_info(*info);
1783 : cons->set_needs_access_check(true);
1784 180 : }
1785 :
1786 41 : void ObjectTemplate::SetAccessCheckCallbackAndHandler(
1787 : AccessCheckCallback callback,
1788 : const NamedPropertyHandlerConfiguration& named_handler,
1789 : const IndexedPropertyHandlerConfiguration& indexed_handler,
1790 : Local<Value> data) {
1791 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1792 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1793 : i::HandleScope scope(isolate);
1794 41 : auto cons = EnsureConstructor(isolate, this);
1795 : EnsureNotInstantiated(
1796 41 : cons, "v8::ObjectTemplate::SetAccessCheckCallbackWithHandler");
1797 :
1798 : i::Handle<i::Struct> struct_info =
1799 41 : isolate->factory()->NewStruct(i::ACCESS_CHECK_INFO_TYPE);
1800 : i::Handle<i::AccessCheckInfo> info =
1801 : i::Handle<i::AccessCheckInfo>::cast(struct_info);
1802 :
1803 82 : SET_FIELD_WRAPPED(info, set_callback, callback);
1804 : auto named_interceptor = CreateInterceptorInfo(
1805 : isolate, named_handler.getter, named_handler.setter, named_handler.query,
1806 : named_handler.descriptor, named_handler.deleter, named_handler.enumerator,
1807 41 : named_handler.definer, named_handler.data, named_handler.flags);
1808 41 : info->set_named_interceptor(*named_interceptor);
1809 : auto indexed_interceptor = CreateInterceptorInfo(
1810 : isolate, indexed_handler.getter, indexed_handler.setter,
1811 : indexed_handler.query, indexed_handler.descriptor,
1812 : indexed_handler.deleter, indexed_handler.enumerator,
1813 41 : indexed_handler.definer, indexed_handler.data, indexed_handler.flags);
1814 41 : info->set_indexed_interceptor(*indexed_interceptor);
1815 :
1816 41 : if (data.IsEmpty()) {
1817 : data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1818 : }
1819 41 : info->set_data(*Utils::OpenHandle(*data));
1820 :
1821 41 : cons->set_access_check_info(*info);
1822 : cons->set_needs_access_check(true);
1823 41 : }
1824 :
1825 209 : void ObjectTemplate::SetHandler(
1826 : const IndexedPropertyHandlerConfiguration& config) {
1827 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1828 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1829 : i::HandleScope scope(isolate);
1830 209 : auto cons = EnsureConstructor(isolate, this);
1831 209 : EnsureNotInstantiated(cons, "v8::ObjectTemplate::SetHandler");
1832 : auto obj = CreateInterceptorInfo(isolate, config.getter, config.setter,
1833 : config.query, config.descriptor,
1834 : config.deleter, config.enumerator,
1835 209 : config.definer, config.data, config.flags);
1836 209 : cons->set_indexed_property_handler(*obj);
1837 209 : }
1838 :
1839 :
1840 287 : void ObjectTemplate::SetCallAsFunctionHandler(FunctionCallback callback,
1841 : Local<Value> data) {
1842 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1843 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1844 : i::HandleScope scope(isolate);
1845 287 : auto cons = EnsureConstructor(isolate, this);
1846 287 : EnsureNotInstantiated(cons, "v8::ObjectTemplate::SetCallAsFunctionHandler");
1847 : i::Handle<i::Struct> struct_obj =
1848 287 : isolate->factory()->NewStruct(i::TUPLE2_TYPE);
1849 : i::Handle<i::CallHandlerInfo> obj =
1850 : i::Handle<i::CallHandlerInfo>::cast(struct_obj);
1851 574 : SET_FIELD_WRAPPED(obj, set_callback, callback);
1852 287 : if (data.IsEmpty()) {
1853 : data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
1854 : }
1855 287 : obj->set_data(*Utils::OpenHandle(*data));
1856 287 : cons->set_instance_call_handler(*obj);
1857 287 : }
1858 :
1859 64719 : int ObjectTemplate::InternalFieldCount() {
1860 64719 : return Utils::OpenHandle(this)->embedder_field_count();
1861 : }
1862 :
1863 127497 : void ObjectTemplate::SetInternalFieldCount(int value) {
1864 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1865 : if (!Utils::ApiCheck(i::Smi::IsValid(value),
1866 : "v8::ObjectTemplate::SetInternalFieldCount()",
1867 : "Invalid embedder field count")) {
1868 127497 : return;
1869 : }
1870 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1871 127497 : if (value > 0) {
1872 : // The embedder field count is set by the constructor function's
1873 : // construct code, so we ensure that there is a constructor
1874 : // function to do the setting.
1875 62729 : EnsureConstructor(isolate, this);
1876 : }
1877 127497 : Utils::OpenHandle(this)->set_embedder_field_count(value);
1878 : }
1879 :
1880 0 : bool ObjectTemplate::IsImmutableProto() {
1881 0 : return Utils::OpenHandle(this)->immutable_proto();
1882 : }
1883 :
1884 21 : void ObjectTemplate::SetImmutableProto() {
1885 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
1886 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
1887 21 : Utils::OpenHandle(this)->set_immutable_proto(true);
1888 21 : }
1889 :
1890 : // --- S c r i p t s ---
1891 :
1892 :
1893 : // Internally, UnboundScript is a SharedFunctionInfo, and Script is a
1894 : // JSFunction.
1895 :
1896 419 : ScriptCompiler::CachedData::CachedData(const uint8_t* data_, int length_,
1897 : BufferPolicy buffer_policy_)
1898 : : data(data_),
1899 : length(length_),
1900 : rejected(false),
1901 850 : buffer_policy(buffer_policy_) {}
1902 :
1903 :
1904 844 : ScriptCompiler::CachedData::~CachedData() {
1905 850 : if (buffer_policy == BufferOwned) {
1906 766 : delete[] data;
1907 : }
1908 844 : }
1909 :
1910 :
1911 0 : bool ScriptCompiler::ExternalSourceStream::SetBookmark() { return false; }
1912 :
1913 :
1914 0 : void ScriptCompiler::ExternalSourceStream::ResetToBookmark() { UNREACHABLE(); }
1915 :
1916 :
1917 132 : ScriptCompiler::StreamedSource::StreamedSource(ExternalSourceStream* stream,
1918 : Encoding encoding)
1919 264 : : impl_(new i::StreamedSource(stream, encoding)) {}
1920 :
1921 :
1922 132 : ScriptCompiler::StreamedSource::~StreamedSource() { delete impl_; }
1923 :
1924 :
1925 : const ScriptCompiler::CachedData*
1926 6 : ScriptCompiler::StreamedSource::GetCachedData() const {
1927 12 : return impl_->cached_data.get();
1928 : }
1929 :
1930 :
1931 322318 : Local<Script> UnboundScript::BindToCurrentContext() {
1932 : i::Handle<i::HeapObject> obj =
1933 : i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
1934 : i::Isolate* isolate = obj->GetIsolate();
1935 : i::Handle<i::SharedFunctionInfo> function_info(
1936 : i::SharedFunctionInfo::cast(*obj), isolate);
1937 : i::Handle<i::JSFunction> function =
1938 : isolate->factory()->NewFunctionFromSharedFunctionInfo(
1939 322318 : function_info, isolate->native_context());
1940 322317 : return ToApiHandle<Script>(function);
1941 : }
1942 :
1943 :
1944 214 : int UnboundScript::GetId() {
1945 : i::Handle<i::HeapObject> obj =
1946 : i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
1947 214 : i::Isolate* isolate = obj->GetIsolate();
1948 428 : LOG_API(isolate, UnboundScript, GetId);
1949 : i::HandleScope scope(isolate);
1950 : i::Handle<i::SharedFunctionInfo> function_info(
1951 : i::SharedFunctionInfo::cast(*obj));
1952 : i::Handle<i::Script> script(i::Script::cast(function_info->script()));
1953 214 : return script->id();
1954 : }
1955 :
1956 :
1957 6 : int UnboundScript::GetLineNumber(int code_pos) {
1958 : i::Handle<i::SharedFunctionInfo> obj =
1959 : i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
1960 6 : i::Isolate* isolate = obj->GetIsolate();
1961 12 : LOG_API(isolate, UnboundScript, GetLineNumber);
1962 6 : if (obj->script()->IsScript()) {
1963 : i::Handle<i::Script> script(i::Script::cast(obj->script()));
1964 6 : return i::Script::GetLineNumber(script, code_pos);
1965 : } else {
1966 : return -1;
1967 : }
1968 : }
1969 :
1970 :
1971 6 : Local<Value> UnboundScript::GetScriptName() {
1972 : i::Handle<i::SharedFunctionInfo> obj =
1973 : i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
1974 6 : i::Isolate* isolate = obj->GetIsolate();
1975 12 : LOG_API(isolate, UnboundScript, GetName);
1976 6 : if (obj->script()->IsScript()) {
1977 : i::Object* name = i::Script::cast(obj->script())->name();
1978 : return Utils::ToLocal(i::Handle<i::Object>(name, isolate));
1979 : } else {
1980 0 : return Local<String>();
1981 : }
1982 : }
1983 :
1984 :
1985 186 : Local<Value> UnboundScript::GetSourceURL() {
1986 : i::Handle<i::SharedFunctionInfo> obj =
1987 : i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
1988 186 : i::Isolate* isolate = obj->GetIsolate();
1989 372 : LOG_API(isolate, UnboundScript, GetSourceURL);
1990 186 : if (obj->script()->IsScript()) {
1991 : i::Object* url = i::Script::cast(obj->script())->source_url();
1992 : return Utils::ToLocal(i::Handle<i::Object>(url, isolate));
1993 : } else {
1994 0 : return Local<String>();
1995 : }
1996 : }
1997 :
1998 :
1999 186 : Local<Value> UnboundScript::GetSourceMappingURL() {
2000 : i::Handle<i::SharedFunctionInfo> obj =
2001 : i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
2002 186 : i::Isolate* isolate = obj->GetIsolate();
2003 372 : LOG_API(isolate, UnboundScript, GetSourceMappingURL);
2004 186 : if (obj->script()->IsScript()) {
2005 : i::Object* url = i::Script::cast(obj->script())->source_mapping_url();
2006 : return Utils::ToLocal(i::Handle<i::Object>(url, isolate));
2007 : } else {
2008 0 : return Local<String>();
2009 : }
2010 : }
2011 :
2012 :
2013 334956 : MaybeLocal<Value> Script::Run(Local<Context> context) {
2014 2679648 : PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE(
2015 : "v8", "V8.Execute", context, Script, Run, MaybeLocal<Value>(),
2016 : InternalEscapableScope, true);
2017 334956 : i::HistogramTimerScope execute_timer(isolate->counters()->execute(), true);
2018 334956 : i::AggregatingHistogramTimerScope timer(isolate->counters()->compile_lazy());
2019 : i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
2020 : auto fun = i::Handle<i::JSFunction>::cast(Utils::OpenHandle(this));
2021 :
2022 334955 : i::Handle<i::Object> receiver = isolate->global_proxy();
2023 : Local<Value> result;
2024 : has_pending_exception = !ToLocal<Value>(
2025 669910 : i::Execution::Call(isolate, fun, receiver, 0, nullptr), &result);
2026 :
2027 350306 : RETURN_ON_FAILED_EXECUTION(Value);
2028 654561 : RETURN_ESCAPED(result);
2029 : }
2030 :
2031 :
2032 0 : Local<Value> Script::Run() {
2033 : auto self = Utils::OpenHandle(this, true);
2034 : // If execution is terminating, Compile(..)->Run() requires this
2035 : // check.
2036 0 : if (self.is_null()) return Local<Value>();
2037 0 : auto context = ContextFromHeapObject(self);
2038 0 : RETURN_TO_LOCAL_UNCHECKED(Run(context), Value);
2039 : }
2040 :
2041 :
2042 610 : Local<UnboundScript> Script::GetUnboundScript() {
2043 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
2044 : return ToApiHandle<UnboundScript>(
2045 610 : i::Handle<i::SharedFunctionInfo>(i::JSFunction::cast(*obj)->shared()));
2046 : }
2047 :
2048 252 : bool DynamicImportResult::FinishDynamicImportSuccess(Local<Context> context,
2049 : Local<Module> module) {
2050 1008 : PREPARE_FOR_EXECUTION_BOOL(context, Module, FinishDynamicImportSuccess);
2051 : auto promise = Utils::OpenHandle(this);
2052 252 : i::Handle<i::Module> module_obj = Utils::OpenHandle(*module);
2053 : i::Handle<i::JSModuleNamespace> module_namespace =
2054 252 : i::Module::GetModuleNamespace(module_obj);
2055 : i::Handle<i::Object> argv[] = {promise, module_namespace};
2056 : has_pending_exception =
2057 : i::Execution::Call(isolate, isolate->promise_resolve(),
2058 : isolate->factory()->undefined_value(), arraysize(argv),
2059 : argv)
2060 756 : .is_null();
2061 252 : RETURN_ON_FAILED_EXECUTION_BOOL();
2062 : return true;
2063 : }
2064 :
2065 70 : bool DynamicImportResult::FinishDynamicImportFailure(Local<Context> context,
2066 : Local<Value> exception) {
2067 280 : PREPARE_FOR_EXECUTION_BOOL(context, Module, FinishDynamicImportFailure);
2068 : auto promise = Utils::OpenHandle(this);
2069 : // We pass true to trigger the debugger's on exception handler.
2070 : i::Handle<i::Object> argv[] = {promise, Utils::OpenHandle(*exception),
2071 70 : isolate->factory()->ToBoolean(true)};
2072 : has_pending_exception =
2073 : i::Execution::Call(isolate, isolate->promise_internal_reject(),
2074 : isolate->factory()->undefined_value(), arraysize(argv),
2075 : argv)
2076 210 : .is_null();
2077 70 : RETURN_ON_FAILED_EXECUTION_BOOL();
2078 : return true;
2079 : }
2080 :
2081 1574 : int Module::GetModuleRequestsLength() const {
2082 : i::Handle<i::Module> self = Utils::OpenHandle(this);
2083 3148 : return self->info()->module_requests()->length();
2084 : }
2085 :
2086 1086 : Local<String> Module::GetModuleRequest(int i) const {
2087 1086 : CHECK_GE(i, 0);
2088 : i::Handle<i::Module> self = Utils::OpenHandle(this);
2089 : i::Isolate* isolate = self->GetIsolate();
2090 : i::Handle<i::FixedArray> module_requests(self->info()->module_requests(),
2091 1086 : isolate);
2092 1086 : CHECK_LT(i, module_requests->length());
2093 1086 : return ToApiHandle<String>(i::handle(module_requests->get(i), isolate));
2094 : }
2095 :
2096 5278 : int Module::GetIdentityHash() const { return Utils::OpenHandle(this)->hash(); }
2097 :
2098 1216 : bool Module::Instantiate(Local<Context> context,
2099 : Module::ResolveCallback callback) {
2100 4864 : PREPARE_FOR_EXECUTION_BOOL(context, Module, Instantiate);
2101 : has_pending_exception =
2102 1216 : !i::Module::Instantiate(Utils::OpenHandle(this), context, callback);
2103 1244 : RETURN_ON_FAILED_EXECUTION_BOOL();
2104 : return true;
2105 : }
2106 :
2107 1188 : MaybeLocal<Value> Module::Evaluate(Local<Context> context) {
2108 9504 : PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE(
2109 : "v8", "V8.Execute", context, Module, Evaluate, MaybeLocal<Value>(),
2110 : InternalEscapableScope, true);
2111 1188 : i::HistogramTimerScope execute_timer(isolate->counters()->execute(), true);
2112 1188 : i::AggregatingHistogramTimerScope timer(isolate->counters()->compile_lazy());
2113 : i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
2114 :
2115 : i::Handle<i::Module> self = Utils::OpenHandle(this);
2116 : // It's an API error to call Evaluate before Instantiate.
2117 1188 : CHECK(self->instantiated());
2118 :
2119 : Local<Value> result;
2120 2376 : has_pending_exception = !ToLocal(i::Module::Evaluate(self), &result);
2121 1216 : RETURN_ON_FAILED_EXECUTION(Value);
2122 2348 : RETURN_ESCAPED(result);
2123 : }
2124 :
2125 317452 : MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundInternal(
2126 : Isolate* v8_isolate, Source* source, CompileOptions options) {
2127 952335 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
2128 1269787 : PREPARE_FOR_EXECUTION_WITH_ISOLATE(isolate, ScriptCompiler, CompileUnbound,
2129 : UnboundScript);
2130 952335 : TRACE_EVENT_CALL_STATS_SCOPED(isolate, "v8", "V8.ScriptCompiler");
2131 :
2132 : // Don't try to produce any kind of cache when the debugger is loaded.
2133 325735 : if (isolate->debug()->is_loaded() &&
2134 8290 : (options == kProduceParserCache || options == kProduceCodeCache)) {
2135 : options = kNoCompileOptions;
2136 : }
2137 :
2138 317445 : i::ScriptData* script_data = NULL;
2139 317445 : if (options == kConsumeParserCache || options == kConsumeCodeCache) {
2140 : DCHECK(source->cached_data);
2141 : // ScriptData takes care of pointer-aligning the data.
2142 : script_data = new i::ScriptData(source->cached_data->data,
2143 443 : source->cached_data->length);
2144 : }
2145 :
2146 317445 : i::Handle<i::String> str = Utils::OpenHandle(*(source->source_string));
2147 : i::Handle<i::SharedFunctionInfo> result;
2148 : {
2149 317445 : i::HistogramTimerScope total(isolate->counters()->compile_script(), true);
2150 950825 : TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.CompileScript");
2151 : i::Handle<i::Object> name_obj;
2152 : i::Handle<i::Object> source_map_url;
2153 : int line_offset = 0;
2154 : int column_offset = 0;
2155 317445 : if (!source->resource_name.IsEmpty()) {
2156 202745 : name_obj = Utils::OpenHandle(*(source->resource_name));
2157 : }
2158 317445 : if (!source->resource_line_offset.IsEmpty()) {
2159 46689 : line_offset = static_cast<int>(source->resource_line_offset->Value());
2160 : }
2161 317445 : if (!source->resource_column_offset.IsEmpty()) {
2162 : column_offset =
2163 46634 : static_cast<int>(source->resource_column_offset->Value());
2164 : }
2165 317445 : if (!source->source_map_url.IsEmpty()) {
2166 5268 : source_map_url = Utils::OpenHandle(*(source->source_map_url));
2167 : }
2168 : result = i::Compiler::GetSharedFunctionInfoForScript(
2169 : str, name_obj, line_offset, column_offset, source->resource_options,
2170 : source_map_url, isolate->native_context(), NULL, &script_data, options,
2171 317445 : i::NOT_NATIVES_CODE);
2172 : has_pending_exception = result.is_null();
2173 317875 : if (has_pending_exception && script_data != NULL) {
2174 : // This case won't happen during normal operation; we have compiled
2175 : // successfully and produced cached data, and but the second compilation
2176 : // of the same source code fails.
2177 0 : delete script_data;
2178 0 : script_data = NULL;
2179 : }
2180 318953 : RETURN_ON_FAILED_EXECUTION(UnboundScript);
2181 :
2182 316381 : if ((options == kProduceParserCache || options == kProduceCodeCache) &&
2183 446 : script_data != NULL) {
2184 : // script_data now contains the data that was generated. source will
2185 : // take the ownership.
2186 : source->cached_data = new CachedData(
2187 862 : script_data->data(), script_data->length(), CachedData::BufferOwned);
2188 431 : script_data->ReleaseDataOwnership();
2189 315504 : } else if (options == kConsumeParserCache || options == kConsumeCodeCache) {
2190 886 : source->cached_data->rejected = script_data->rejected();
2191 : }
2192 316809 : delete script_data;
2193 : }
2194 315936 : RETURN_ESCAPED(ToApiHandle<UnboundScript>(result));
2195 : }
2196 :
2197 :
2198 15027 : MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundScript(
2199 : Isolate* v8_isolate, Source* source, CompileOptions options) {
2200 : Utils::ApiCheck(
2201 : !source->GetResourceOptions().IsModule(),
2202 : "v8::ScriptCompiler::CompileUnboundScript",
2203 : "v8::ScriptCompiler::CompileModule must be used to compile modules");
2204 15027 : return CompileUnboundInternal(v8_isolate, source, options);
2205 : }
2206 :
2207 :
2208 0 : Local<UnboundScript> ScriptCompiler::CompileUnbound(Isolate* v8_isolate,
2209 : Source* source,
2210 : CompileOptions options) {
2211 : Utils::ApiCheck(
2212 : !source->GetResourceOptions().IsModule(),
2213 : "v8::ScriptCompiler::CompileUnbound",
2214 : "v8::ScriptCompiler::CompileModule must be used to compile modules");
2215 0 : RETURN_TO_LOCAL_UNCHECKED(CompileUnboundInternal(v8_isolate, source, options),
2216 : UnboundScript);
2217 : }
2218 :
2219 :
2220 300392 : MaybeLocal<Script> ScriptCompiler::Compile(Local<Context> context,
2221 : Source* source,
2222 : CompileOptions options) {
2223 : Utils::ApiCheck(
2224 : !source->GetResourceOptions().IsModule(), "v8::ScriptCompiler::Compile",
2225 : "v8::ScriptCompiler::CompileModule must be used to compile modules");
2226 : auto isolate = context->GetIsolate();
2227 300392 : auto maybe = CompileUnboundInternal(isolate, source, options);
2228 : Local<UnboundScript> result;
2229 300391 : if (!maybe.ToLocal(&result)) return MaybeLocal<Script>();
2230 : v8::Context::Scope scope(context);
2231 298923 : return result->BindToCurrentContext();
2232 : }
2233 :
2234 :
2235 0 : Local<Script> ScriptCompiler::Compile(
2236 : Isolate* v8_isolate,
2237 : Source* source,
2238 : CompileOptions options) {
2239 0 : auto context = v8_isolate->GetCurrentContext();
2240 0 : RETURN_TO_LOCAL_UNCHECKED(Compile(context, source, options), Script);
2241 : }
2242 :
2243 2033 : MaybeLocal<Module> ScriptCompiler::CompileModule(Isolate* isolate,
2244 : Source* source) {
2245 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
2246 :
2247 : Utils::ApiCheck(source->GetResourceOptions().IsModule(),
2248 : "v8::ScriptCompiler::CompileModule",
2249 : "Invalid ScriptOrigin: is_module must be true");
2250 2033 : auto maybe = CompileUnboundInternal(isolate, source, kNoCompileOptions);
2251 : Local<UnboundScript> unbound;
2252 2033 : if (!maybe.ToLocal(&unbound)) return MaybeLocal<Module>();
2253 :
2254 2001 : i::Handle<i::SharedFunctionInfo> shared = Utils::OpenHandle(*unbound);
2255 2001 : return ToApiHandle<Module>(i_isolate->factory()->NewModule(shared));
2256 : }
2257 :
2258 :
2259 : class IsIdentifierHelper {
2260 : public:
2261 28 : IsIdentifierHelper() : is_identifier_(false), first_char_(true) {}
2262 :
2263 : bool Check(i::String* string) {
2264 28 : i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
2265 28 : if (cons_string == NULL) return is_identifier_;
2266 : // We don't support cons strings here.
2267 : return false;
2268 : }
2269 28 : void VisitOneByteString(const uint8_t* chars, int length) {
2270 98 : for (int i = 0; i < length; ++i) {
2271 70 : if (first_char_) {
2272 28 : first_char_ = false;
2273 56 : is_identifier_ = unicode_cache_.IsIdentifierStart(chars[0]);
2274 : } else {
2275 84 : is_identifier_ &= unicode_cache_.IsIdentifierPart(chars[i]);
2276 : }
2277 : }
2278 28 : }
2279 0 : void VisitTwoByteString(const uint16_t* chars, int length) {
2280 0 : for (int i = 0; i < length; ++i) {
2281 0 : if (first_char_) {
2282 0 : first_char_ = false;
2283 0 : is_identifier_ = unicode_cache_.IsIdentifierStart(chars[0]);
2284 : } else {
2285 0 : is_identifier_ &= unicode_cache_.IsIdentifierPart(chars[i]);
2286 : }
2287 : }
2288 0 : }
2289 :
2290 : private:
2291 : bool is_identifier_;
2292 : bool first_char_;
2293 : i::UnicodeCache unicode_cache_;
2294 : DISALLOW_COPY_AND_ASSIGN(IsIdentifierHelper);
2295 : };
2296 :
2297 :
2298 56 : MaybeLocal<Function> ScriptCompiler::CompileFunctionInContext(
2299 : Local<Context> v8_context, Source* source, size_t arguments_count,
2300 : Local<String> arguments[], size_t context_extension_count,
2301 : Local<Object> context_extensions[]) {
2302 224 : PREPARE_FOR_EXECUTION(v8_context, ScriptCompiler, CompileFunctionInContext,
2303 : Function);
2304 168 : TRACE_EVENT0("v8", "V8.ScriptCompiler");
2305 : i::Handle<i::String> source_string;
2306 : int parameters_end_pos = i::kNoSourcePosition;
2307 : auto factory = isolate->factory();
2308 56 : if (arguments_count) {
2309 28 : if (i::FLAG_harmony_function_tostring) {
2310 7 : source_string = factory->NewStringFromStaticChars("(function anonymous(");
2311 : } else {
2312 21 : source_string = factory->NewStringFromStaticChars("(function(");
2313 : }
2314 49 : for (size_t i = 0; i < arguments_count; ++i) {
2315 : IsIdentifierHelper helper;
2316 56 : if (!helper.Check(*Utils::OpenHandle(*arguments[i]))) {
2317 7 : return Local<Function>();
2318 : }
2319 : has_pending_exception =
2320 : !factory->NewConsString(source_string,
2321 : Utils::OpenHandle(*arguments[i]))
2322 42 : .ToHandle(&source_string);
2323 21 : RETURN_ON_FAILED_EXECUTION(Function);
2324 42 : if (i + 1 == arguments_count) continue;
2325 : has_pending_exception =
2326 : !factory->NewConsString(source_string,
2327 : factory->LookupSingleCharacterStringFromCode(
2328 0 : ',')).ToHandle(&source_string);
2329 0 : RETURN_ON_FAILED_EXECUTION(Function);
2330 : }
2331 : i::Handle<i::String> brackets;
2332 21 : if (i::FLAG_harmony_function_tostring) {
2333 : // Append linefeed and signal that text beyond the linefeed is not part of
2334 : // the formal parameters.
2335 7 : brackets = factory->NewStringFromStaticChars("\n) {\n");
2336 7 : parameters_end_pos = source_string->length() + 1;
2337 : } else {
2338 14 : brackets = factory->NewStringFromStaticChars("){");
2339 : }
2340 : has_pending_exception = !factory->NewConsString(source_string, brackets)
2341 42 : .ToHandle(&source_string);
2342 21 : RETURN_ON_FAILED_EXECUTION(Function);
2343 : } else {
2344 28 : if (i::FLAG_harmony_function_tostring) {
2345 : source_string =
2346 7 : factory->NewStringFromStaticChars("(function anonymous(\n) {\n");
2347 7 : parameters_end_pos = source_string->length() - 4;
2348 : } else {
2349 21 : source_string = factory->NewStringFromStaticChars("(function(){");
2350 : }
2351 : }
2352 :
2353 : int scope_position = source_string->length();
2354 : has_pending_exception =
2355 : !factory->NewConsString(source_string,
2356 : Utils::OpenHandle(*source->source_string))
2357 98 : .ToHandle(&source_string);
2358 49 : RETURN_ON_FAILED_EXECUTION(Function);
2359 : // Include \n in case the source contains a line end comment.
2360 49 : auto brackets = factory->NewStringFromStaticChars("\n})");
2361 : has_pending_exception =
2362 98 : !factory->NewConsString(source_string, brackets).ToHandle(&source_string);
2363 49 : RETURN_ON_FAILED_EXECUTION(Function);
2364 :
2365 : i::Handle<i::Context> context = Utils::OpenHandle(*v8_context);
2366 : i::Handle<i::SharedFunctionInfo> outer_info(context->closure()->shared(),
2367 : isolate);
2368 84 : for (size_t i = 0; i < context_extension_count; ++i) {
2369 : i::Handle<i::JSReceiver> extension =
2370 35 : Utils::OpenHandle(*context_extensions[i]);
2371 35 : if (!extension->IsJSObject()) return Local<Function>();
2372 : i::Handle<i::JSFunction> closure(context->closure(), isolate);
2373 : context = factory->NewWithContext(
2374 : closure, context,
2375 : i::ScopeInfo::CreateForWithScope(
2376 35 : isolate, context->IsNativeContext()
2377 : ? i::Handle<i::ScopeInfo>::null()
2378 : : i::Handle<i::ScopeInfo>(context->scope_info())),
2379 77 : extension);
2380 : }
2381 :
2382 : i::Handle<i::Object> name_obj;
2383 : int eval_scope_position = 0;
2384 : int eval_position = i::kNoSourcePosition;
2385 : int line_offset = 0;
2386 : int column_offset = 0;
2387 49 : if (!source->resource_name.IsEmpty()) {
2388 21 : name_obj = Utils::OpenHandle(*(source->resource_name));
2389 : }
2390 49 : if (!source->resource_line_offset.IsEmpty()) {
2391 21 : line_offset = static_cast<int>(source->resource_line_offset->Value());
2392 : }
2393 49 : if (!source->resource_column_offset.IsEmpty()) {
2394 21 : column_offset = static_cast<int>(source->resource_column_offset->Value());
2395 : }
2396 : i::Handle<i::JSFunction> fun;
2397 : has_pending_exception =
2398 : !i::Compiler::GetFunctionFromEval(
2399 : source_string, outer_info, context, i::SLOPPY,
2400 : i::ONLY_SINGLE_FUNCTION_LITERAL, parameters_end_pos,
2401 : eval_scope_position, eval_position, line_offset,
2402 : column_offset - scope_position, name_obj, source->resource_options)
2403 98 : .ToHandle(&fun);
2404 49 : if (has_pending_exception) {
2405 0 : isolate->ReportPendingMessages();
2406 : }
2407 49 : RETURN_ON_FAILED_EXECUTION(Function);
2408 :
2409 : i::Handle<i::Object> result;
2410 : has_pending_exception =
2411 : !i::Execution::Call(isolate, fun,
2412 98 : Utils::OpenHandle(*v8_context->Global()), 0,
2413 98 : nullptr).ToHandle(&result);
2414 49 : RETURN_ON_FAILED_EXECUTION(Function);
2415 49 : RETURN_ESCAPED(
2416 : Utils::CallableToLocal(i::Handle<i::JSFunction>::cast(result)));
2417 : }
2418 :
2419 :
2420 0 : Local<Function> ScriptCompiler::CompileFunctionInContext(
2421 : Isolate* v8_isolate, Source* source, Local<Context> v8_context,
2422 : size_t arguments_count, Local<String> arguments[],
2423 : size_t context_extension_count, Local<Object> context_extensions[]) {
2424 0 : RETURN_TO_LOCAL_UNCHECKED(
2425 : CompileFunctionInContext(v8_context, source, arguments_count, arguments,
2426 : context_extension_count, context_extensions),
2427 : Function);
2428 : }
2429 :
2430 :
2431 132 : ScriptCompiler::ScriptStreamingTask* ScriptCompiler::StartStreamingScript(
2432 : Isolate* v8_isolate, StreamedSource* source, CompileOptions options) {
2433 132 : if (!i::FLAG_script_streaming) {
2434 : return nullptr;
2435 : }
2436 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
2437 : return new i::BackgroundParsingTask(source->impl(), options,
2438 132 : i::FLAG_stack_size, isolate);
2439 : }
2440 :
2441 :
2442 126 : MaybeLocal<Script> ScriptCompiler::Compile(Local<Context> context,
2443 : StreamedSource* v8_source,
2444 : Local<String> full_source_string,
2445 : const ScriptOrigin& origin) {
2446 504 : PREPARE_FOR_EXECUTION(context, ScriptCompiler, Compile, Script);
2447 378 : TRACE_EVENT0("v8", "V8.ScriptCompiler");
2448 : i::StreamedSource* source = v8_source->impl();
2449 : i::Handle<i::String> str = Utils::OpenHandle(*(full_source_string));
2450 126 : i::Handle<i::Script> script = isolate->factory()->NewScript(str);
2451 126 : if (!origin.ResourceName().IsEmpty()) {
2452 126 : script->set_name(*Utils::OpenHandle(*(origin.ResourceName())));
2453 : }
2454 126 : if (!origin.ResourceLineOffset().IsEmpty()) {
2455 : script->set_line_offset(
2456 0 : static_cast<int>(origin.ResourceLineOffset()->Value()));
2457 : }
2458 126 : if (!origin.ResourceColumnOffset().IsEmpty()) {
2459 : script->set_column_offset(
2460 0 : static_cast<int>(origin.ResourceColumnOffset()->Value()));
2461 : }
2462 : script->set_origin_options(origin.Options());
2463 126 : if (!origin.SourceMapUrl().IsEmpty()) {
2464 : script->set_source_mapping_url(
2465 0 : *Utils::OpenHandle(*(origin.SourceMapUrl())));
2466 : }
2467 :
2468 : source->info->set_script(script);
2469 126 : if (source->info->literal() == nullptr) {
2470 12 : source->parser->ReportErrors(isolate, script);
2471 : }
2472 126 : source->parser->UpdateStatistics(isolate, script);
2473 :
2474 252 : i::DeferredHandleScope deferred_handle_scope(isolate);
2475 : {
2476 : // Internalize AST values on the main thread.
2477 126 : source->info->ReopenHandlesInNewHandleScope();
2478 126 : source->info->ast_value_factory()->Internalize(isolate);
2479 126 : source->parser->HandleSourceURLComments(isolate, script);
2480 : }
2481 252 : source->info->set_deferred_handles(deferred_handle_scope.Detach());
2482 :
2483 : i::Handle<i::SharedFunctionInfo> result;
2484 126 : if (source->info->literal() != nullptr) {
2485 : // Parsing has succeeded.
2486 : result = i::Compiler::GetSharedFunctionInfoForStreamedScript(
2487 114 : script, source->info.get(), str->length());
2488 : }
2489 : has_pending_exception = result.is_null();
2490 126 : if (has_pending_exception) isolate->ReportPendingMessages();
2491 :
2492 126 : source->Release();
2493 :
2494 138 : RETURN_ON_FAILED_EXECUTION(Script);
2495 :
2496 : Local<UnboundScript> generic = ToApiHandle<UnboundScript>(result);
2497 114 : if (generic.IsEmpty()) return Local<Script>();
2498 114 : Local<Script> bound = generic->BindToCurrentContext();
2499 114 : if (bound.IsEmpty()) return Local<Script>();
2500 114 : RETURN_ESCAPED(bound);
2501 : }
2502 :
2503 :
2504 0 : Local<Script> ScriptCompiler::Compile(Isolate* v8_isolate,
2505 : StreamedSource* v8_source,
2506 : Local<String> full_source_string,
2507 : const ScriptOrigin& origin) {
2508 0 : auto context = v8_isolate->GetCurrentContext();
2509 0 : RETURN_TO_LOCAL_UNCHECKED(
2510 : Compile(context, v8_source, full_source_string, origin), Script);
2511 : }
2512 :
2513 :
2514 0 : uint32_t ScriptCompiler::CachedDataVersionTag() {
2515 : return static_cast<uint32_t>(base::hash_combine(
2516 0 : internal::Version::Hash(), internal::FlagList::Hash(),
2517 0 : static_cast<uint32_t>(internal::CpuFeatures::SupportedFeatures())));
2518 : }
2519 :
2520 :
2521 107002 : MaybeLocal<Script> Script::Compile(Local<Context> context, Local<String> source,
2522 : ScriptOrigin* origin) {
2523 107002 : if (origin) {
2524 : ScriptCompiler::Source script_source(source, *origin);
2525 7202 : return ScriptCompiler::Compile(context, &script_source);
2526 : }
2527 : ScriptCompiler::Source script_source(source);
2528 99800 : return ScriptCompiler::Compile(context, &script_source);
2529 : }
2530 :
2531 :
2532 0 : Local<Script> Script::Compile(v8::Local<String> source,
2533 : v8::ScriptOrigin* origin) {
2534 : auto str = Utils::OpenHandle(*source);
2535 0 : auto context = ContextFromHeapObject(str);
2536 0 : RETURN_TO_LOCAL_UNCHECKED(Compile(context, source, origin), Script);
2537 : }
2538 :
2539 :
2540 0 : Local<Script> Script::Compile(v8::Local<String> source,
2541 : v8::Local<String> file_name) {
2542 : auto str = Utils::OpenHandle(*source);
2543 0 : auto context = ContextFromHeapObject(str);
2544 : ScriptOrigin origin(file_name);
2545 0 : return Compile(context, source, &origin).FromMaybe(Local<Script>());
2546 : }
2547 :
2548 :
2549 : // --- E x c e p t i o n s ---
2550 :
2551 :
2552 0 : v8::TryCatch::TryCatch()
2553 : : isolate_(i::Isolate::Current()),
2554 : next_(isolate_->try_catch_handler()),
2555 : is_verbose_(false),
2556 : can_continue_(true),
2557 : capture_message_(true),
2558 : rethrow_(false),
2559 0 : has_terminated_(false) {
2560 : ResetInternal();
2561 : // Special handling for simulators which have a separate JS stack.
2562 : js_stack_comparable_address_ =
2563 : reinterpret_cast<void*>(i::SimulatorStack::RegisterCTryCatch(
2564 0 : isolate_, i::GetCurrentStackPosition()));
2565 0 : isolate_->RegisterTryCatchHandler(this);
2566 0 : }
2567 :
2568 :
2569 23359260 : v8::TryCatch::TryCatch(v8::Isolate* isolate)
2570 : : isolate_(reinterpret_cast<i::Isolate*>(isolate)),
2571 : next_(isolate_->try_catch_handler()),
2572 : is_verbose_(false),
2573 : can_continue_(true),
2574 : capture_message_(true),
2575 : rethrow_(false),
2576 46718520 : has_terminated_(false) {
2577 : ResetInternal();
2578 : // Special handling for simulators which have a separate JS stack.
2579 : js_stack_comparable_address_ =
2580 : reinterpret_cast<void*>(i::SimulatorStack::RegisterCTryCatch(
2581 23359260 : isolate_, i::GetCurrentStackPosition()));
2582 23359260 : isolate_->RegisterTryCatchHandler(this);
2583 23359257 : }
2584 :
2585 :
2586 23359258 : v8::TryCatch::~TryCatch() {
2587 23359258 : if (rethrow_) {
2588 143 : v8::Isolate* isolate = reinterpret_cast<Isolate*>(isolate_);
2589 : v8::HandleScope scope(isolate);
2590 286 : v8::Local<v8::Value> exc = v8::Local<v8::Value>::New(isolate, Exception());
2591 143 : if (HasCaught() && capture_message_) {
2592 : // If an exception was caught and rethrow_ is indicated, the saved
2593 : // message, script, and location need to be restored to Isolate TLS
2594 : // for reuse. capture_message_ needs to be disabled so that Throw()
2595 : // does not create a new message.
2596 143 : isolate_->thread_local_top()->rethrowing_message_ = true;
2597 143 : isolate_->RestorePendingMessageFromTryCatch(this);
2598 : }
2599 143 : isolate_->UnregisterTryCatchHandler(this);
2600 : i::SimulatorStack::UnregisterCTryCatch(isolate_);
2601 143 : reinterpret_cast<Isolate*>(isolate_)->ThrowException(exc);
2602 : DCHECK(!isolate_->thread_local_top()->rethrowing_message_);
2603 : } else {
2604 23375339 : if (HasCaught() && isolate_->has_scheduled_exception()) {
2605 : // If an exception was caught but is still scheduled because no API call
2606 : // promoted it, then it is canceled to prevent it from being propagated.
2607 : // Note that this will not cancel termination exceptions.
2608 657 : isolate_->CancelScheduledExceptionFromTryCatch(this);
2609 : }
2610 23359117 : isolate_->UnregisterTryCatchHandler(this);
2611 : i::SimulatorStack::UnregisterCTryCatch(isolate_);
2612 : }
2613 23359262 : }
2614 :
2615 0 : V8_NORETURN void* v8::TryCatch::operator new(size_t) {
2616 0 : base::OS::Abort();
2617 : abort();
2618 : }
2619 :
2620 0 : void v8::TryCatch::operator delete(void*, size_t) { base::OS::Abort(); }
2621 :
2622 24016428 : bool v8::TryCatch::HasCaught() const {
2623 48032858 : return !reinterpret_cast<i::Object*>(exception_)->IsTheHole(isolate_);
2624 : }
2625 :
2626 :
2627 70 : bool v8::TryCatch::CanContinue() const {
2628 70 : return can_continue_;
2629 : }
2630 :
2631 :
2632 60 : bool v8::TryCatch::HasTerminated() const {
2633 60 : return has_terminated_;
2634 : }
2635 :
2636 :
2637 143 : v8::Local<v8::Value> v8::TryCatch::ReThrow() {
2638 143 : if (!HasCaught()) return v8::Local<v8::Value>();
2639 143 : rethrow_ = true;
2640 286 : return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate_));
2641 : }
2642 :
2643 :
2644 15549 : v8::Local<Value> v8::TryCatch::Exception() const {
2645 15549 : if (HasCaught()) {
2646 : // Check for out of memory exception.
2647 15549 : i::Object* exception = reinterpret_cast<i::Object*>(exception_);
2648 15549 : return v8::Utils::ToLocal(i::Handle<i::Object>(exception, isolate_));
2649 : } else {
2650 0 : return v8::Local<Value>();
2651 : }
2652 : }
2653 :
2654 :
2655 11517 : MaybeLocal<Value> v8::TryCatch::StackTrace(Local<Context> context) const {
2656 11517 : if (!HasCaught()) return v8::Local<Value>();
2657 11517 : i::Object* raw_obj = reinterpret_cast<i::Object*>(exception_);
2658 11517 : if (!raw_obj->IsJSObject()) return v8::Local<Value>();
2659 5624 : PREPARE_FOR_EXECUTION(context, TryCatch, StackTrace, Value);
2660 1406 : i::Handle<i::JSObject> obj(i::JSObject::cast(raw_obj), isolate_);
2661 : i::Handle<i::String> name = isolate->factory()->stack_string();
2662 1406 : Maybe<bool> maybe = i::JSReceiver::HasProperty(obj, name);
2663 1406 : has_pending_exception = !maybe.IsJust();
2664 1406 : RETURN_ON_FAILED_EXECUTION(Value);
2665 1406 : if (!maybe.FromJust()) return v8::Local<Value>();
2666 : Local<Value> result;
2667 : has_pending_exception =
2668 2812 : !ToLocal<Value>(i::JSReceiver::GetProperty(obj, name), &result);
2669 1406 : RETURN_ON_FAILED_EXECUTION(Value);
2670 1406 : RETURN_ESCAPED(result);
2671 : }
2672 :
2673 :
2674 0 : v8::Local<Value> v8::TryCatch::StackTrace() const {
2675 0 : auto context = reinterpret_cast<v8::Isolate*>(isolate_)->GetCurrentContext();
2676 0 : RETURN_TO_LOCAL_UNCHECKED(StackTrace(context), Value);
2677 : }
2678 :
2679 :
2680 13797 : v8::Local<v8::Message> v8::TryCatch::Message() const {
2681 13797 : i::Object* message = reinterpret_cast<i::Object*>(message_obj_);
2682 : DCHECK(message->IsJSMessageObject() || message->IsTheHole(isolate_));
2683 27594 : if (HasCaught() && !message->IsTheHole(isolate_)) {
2684 13727 : return v8::Utils::MessageToLocal(i::Handle<i::Object>(message, isolate_));
2685 : } else {
2686 70 : return v8::Local<v8::Message>();
2687 : }
2688 : }
2689 :
2690 :
2691 864 : void v8::TryCatch::Reset() {
2692 1441 : if (!rethrow_ && HasCaught() && isolate_->has_scheduled_exception()) {
2693 : // If an exception was caught but is still scheduled because no API call
2694 : // promoted it, then it is canceled to prevent it from being propagated.
2695 : // Note that this will not cancel termination exceptions.
2696 6 : isolate_->CancelScheduledExceptionFromTryCatch(this);
2697 : }
2698 : ResetInternal();
2699 864 : }
2700 :
2701 :
2702 0 : void v8::TryCatch::ResetInternal() {
2703 23360124 : i::Object* the_hole = isolate_->heap()->the_hole_value();
2704 23360124 : exception_ = the_hole;
2705 23360124 : message_obj_ = the_hole;
2706 0 : }
2707 :
2708 :
2709 1042343 : void v8::TryCatch::SetVerbose(bool value) {
2710 1042343 : is_verbose_ = value;
2711 1042343 : }
2712 :
2713 :
2714 465902 : void v8::TryCatch::SetCaptureMessage(bool value) {
2715 465902 : capture_message_ = value;
2716 465902 : }
2717 :
2718 :
2719 : // --- M e s s a g e ---
2720 :
2721 :
2722 2606 : Local<String> Message::Get() const {
2723 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2724 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2725 2606 : EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
2726 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
2727 2606 : i::Handle<i::String> raw_result = i::MessageHandler::GetMessage(isolate, obj);
2728 : Local<String> result = Utils::ToLocal(raw_result);
2729 2606 : return scope.Escape(result);
2730 : }
2731 :
2732 :
2733 25562 : ScriptOrigin Message::GetScriptOrigin() const {
2734 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2735 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2736 : auto message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this));
2737 : auto script_wraper = i::Handle<i::Object>(message->script(), isolate);
2738 : auto script_value = i::Handle<i::JSValue>::cast(script_wraper);
2739 : i::Handle<i::Script> script(i::Script::cast(script_value->value()));
2740 51124 : return GetScriptOriginForScript(isolate, script);
2741 : }
2742 :
2743 :
2744 0 : v8::Local<Value> Message::GetScriptResourceName() const {
2745 0 : return GetScriptOrigin().ResourceName();
2746 : }
2747 :
2748 :
2749 1827 : v8::Local<v8::StackTrace> Message::GetStackTrace() const {
2750 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2751 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2752 1827 : EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
2753 : auto message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this));
2754 : i::Handle<i::Object> stackFramesObj(message->stack_frames(), isolate);
2755 1827 : if (!stackFramesObj->IsFixedArray()) return v8::Local<v8::StackTrace>();
2756 : auto stackTrace = i::Handle<i::FixedArray>::cast(stackFramesObj);
2757 : return scope.Escape(Utils::StackTraceToLocal(stackTrace));
2758 : }
2759 :
2760 :
2761 13971 : Maybe<int> Message::GetLineNumber(Local<Context> context) const {
2762 : auto self = Utils::OpenHandle(this);
2763 : i::Isolate* isolate = self->GetIsolate();
2764 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2765 13971 : EscapableHandleScope handle_scope(reinterpret_cast<Isolate*>(isolate));
2766 : auto msg = i::Handle<i::JSMessageObject>::cast(self);
2767 27942 : return Just(msg->GetLineNumber());
2768 : }
2769 :
2770 :
2771 0 : int Message::GetLineNumber() const {
2772 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
2773 0 : return GetLineNumber(context).FromMaybe(0);
2774 : }
2775 :
2776 :
2777 42 : int Message::GetStartPosition() const {
2778 : auto self = Utils::OpenHandle(this);
2779 42 : return self->start_position();
2780 : }
2781 :
2782 :
2783 21 : int Message::GetEndPosition() const {
2784 : auto self = Utils::OpenHandle(this);
2785 21 : return self->end_position();
2786 : }
2787 :
2788 40909 : int Message::ErrorLevel() const {
2789 : auto self = Utils::OpenHandle(this);
2790 40909 : return self->error_level();
2791 : }
2792 :
2793 13418 : Maybe<int> Message::GetStartColumn(Local<Context> context) const {
2794 : auto self = Utils::OpenHandle(this);
2795 : i::Isolate* isolate = self->GetIsolate();
2796 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2797 13418 : EscapableHandleScope handle_scope(reinterpret_cast<Isolate*>(isolate));
2798 : auto msg = i::Handle<i::JSMessageObject>::cast(self);
2799 26836 : return Just(msg->GetColumnNumber());
2800 : }
2801 :
2802 :
2803 0 : int Message::GetStartColumn() const {
2804 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
2805 : const int default_value = kNoColumnInfo;
2806 0 : return GetStartColumn(context).FromMaybe(default_value);
2807 : }
2808 :
2809 :
2810 11525 : Maybe<int> Message::GetEndColumn(Local<Context> context) const {
2811 : auto self = Utils::OpenHandle(this);
2812 : i::Isolate* isolate = self->GetIsolate();
2813 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2814 11525 : EscapableHandleScope handle_scope(reinterpret_cast<Isolate*>(isolate));
2815 : auto msg = i::Handle<i::JSMessageObject>::cast(self);
2816 11525 : const int column_number = msg->GetColumnNumber();
2817 11525 : if (column_number == -1) return Just(-1);
2818 : const int start = self->start_position();
2819 : const int end = self->end_position();
2820 11525 : return Just(column_number + (end - start));
2821 : }
2822 :
2823 :
2824 0 : int Message::GetEndColumn() const {
2825 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
2826 : const int default_value = kNoColumnInfo;
2827 0 : return GetEndColumn(context).FromMaybe(default_value);
2828 : }
2829 :
2830 :
2831 43 : bool Message::IsSharedCrossOrigin() const {
2832 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2833 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2834 : auto self = Utils::OpenHandle(this);
2835 : auto script = i::Handle<i::JSValue>::cast(
2836 : i::Handle<i::Object>(self->script(), isolate));
2837 : return i::Script::cast(script->value())
2838 : ->origin_options()
2839 43 : .IsSharedCrossOrigin();
2840 : }
2841 :
2842 0 : bool Message::IsOpaque() const {
2843 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2844 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2845 : auto self = Utils::OpenHandle(this);
2846 : auto script = i::Handle<i::JSValue>::cast(
2847 : i::Handle<i::Object>(self->script(), isolate));
2848 0 : return i::Script::cast(script->value())->origin_options().IsOpaque();
2849 : }
2850 :
2851 :
2852 11538 : MaybeLocal<String> Message::GetSourceLine(Local<Context> context) const {
2853 : auto self = Utils::OpenHandle(this);
2854 : i::Isolate* isolate = self->GetIsolate();
2855 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2856 11538 : EscapableHandleScope handle_scope(reinterpret_cast<Isolate*>(isolate));
2857 : auto msg = i::Handle<i::JSMessageObject>::cast(self);
2858 34614 : RETURN_ESCAPED(Utils::ToLocal(msg->GetSourceLine()));
2859 : }
2860 :
2861 :
2862 0 : Local<String> Message::GetSourceLine() const {
2863 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
2864 0 : RETURN_TO_LOCAL_UNCHECKED(GetSourceLine(context), String)
2865 : }
2866 :
2867 :
2868 0 : void Message::PrintCurrentStackTrace(Isolate* isolate, FILE* out) {
2869 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
2870 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
2871 0 : i_isolate->PrintCurrentStackTrace(out);
2872 0 : }
2873 :
2874 :
2875 : // --- S t a c k T r a c e ---
2876 :
2877 47103 : Local<StackFrame> StackTrace::GetFrame(uint32_t index) const {
2878 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2879 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
2880 47103 : EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
2881 47103 : auto obj = handle(Utils::OpenHandle(this)->get(index), isolate);
2882 : auto info = i::Handle<i::StackFrameInfo>::cast(obj);
2883 47103 : return scope.Escape(Utils::StackFrameToLocal(info));
2884 : }
2885 :
2886 :
2887 96198 : int StackTrace::GetFrameCount() const {
2888 96198 : return Utils::OpenHandle(this)->length();
2889 : }
2890 :
2891 : namespace {
2892 0 : i::Handle<i::JSObject> NewFrameObject(i::Isolate* isolate,
2893 : i::Handle<i::StackFrameInfo> frame) {
2894 : i::Handle<i::JSObject> frame_obj =
2895 0 : isolate->factory()->NewJSObject(isolate->object_function());
2896 : i::JSObject::AddProperty(
2897 : frame_obj, handle(isolate->heap()->line_string()),
2898 0 : handle(i::Smi::FromInt(frame->line_number() + 1), isolate), i::NONE);
2899 : i::JSObject::AddProperty(
2900 : frame_obj, handle(isolate->heap()->column_string()),
2901 0 : handle(i::Smi::FromInt(frame->column_number() + 1), isolate), i::NONE);
2902 : i::JSObject::AddProperty(frame_obj,
2903 : isolate->factory()->InternalizeOneByteString(
2904 : STATIC_CHAR_VECTOR("scriptId")),
2905 : handle(i::Smi::FromInt(frame->script_id()), isolate),
2906 0 : i::NONE);
2907 : i::JSObject::AddProperty(frame_obj,
2908 : isolate->factory()->InternalizeOneByteString(
2909 : STATIC_CHAR_VECTOR("scriptName")),
2910 0 : handle(frame->script_name(), isolate), i::NONE);
2911 : i::JSObject::AddProperty(frame_obj,
2912 : isolate->factory()->InternalizeOneByteString(
2913 : STATIC_CHAR_VECTOR("scriptNameOrSourceURL")),
2914 : handle(frame->script_name_or_source_url(), isolate),
2915 0 : i::NONE);
2916 : i::JSObject::AddProperty(frame_obj,
2917 : isolate->factory()->InternalizeOneByteString(
2918 : STATIC_CHAR_VECTOR("functionName")),
2919 0 : handle(frame->function_name(), isolate), i::NONE);
2920 : i::JSObject::AddProperty(frame_obj,
2921 : isolate->factory()->InternalizeOneByteString(
2922 : STATIC_CHAR_VECTOR("isEval")),
2923 : isolate->factory()->ToBoolean(frame->is_eval()),
2924 0 : i::NONE);
2925 : i::JSObject::AddProperty(
2926 : frame_obj,
2927 : isolate->factory()->InternalizeOneByteString(
2928 : STATIC_CHAR_VECTOR("isConstructor")),
2929 0 : isolate->factory()->ToBoolean(frame->is_constructor()), i::NONE);
2930 0 : return frame_obj;
2931 : }
2932 : } // namespace
2933 :
2934 0 : Local<Array> StackTrace::AsArray() {
2935 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2936 : i::Handle<i::FixedArray> self = Utils::OpenHandle(this);
2937 : int frame_count = self->length();
2938 : i::Handle<i::FixedArray> frames =
2939 0 : isolate->factory()->NewFixedArray(frame_count);
2940 0 : for (int i = 0; i < frame_count; ++i) {
2941 : auto obj = handle(self->get(i), isolate);
2942 0 : auto frame = i::Handle<i::StackFrameInfo>::cast(obj);
2943 0 : i::Handle<i::JSObject> frame_obj = NewFrameObject(isolate, frame);
2944 0 : frames->set(i, *frame_obj);
2945 : }
2946 : return Utils::ToLocal(isolate->factory()->NewJSArrayWithElements(
2947 0 : frames, i::FAST_ELEMENTS, frame_count));
2948 : }
2949 :
2950 :
2951 61660 : Local<StackTrace> StackTrace::CurrentStackTrace(
2952 : Isolate* isolate,
2953 : int frame_limit,
2954 : StackTraceOptions options) {
2955 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
2956 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
2957 : i::Handle<i::FixedArray> stackTrace =
2958 61660 : i_isolate->CaptureCurrentStackTrace(frame_limit, options);
2959 61660 : return Utils::StackTraceToLocal(stackTrace);
2960 : }
2961 :
2962 :
2963 : // --- S t a c k F r a m e ---
2964 :
2965 45483 : int StackFrame::GetLineNumber() const {
2966 : int v = Utils::OpenHandle(this)->line_number();
2967 45483 : return v ? v : Message::kNoLineNumberInfo;
2968 : }
2969 :
2970 :
2971 45441 : int StackFrame::GetColumn() const {
2972 : int v = Utils::OpenHandle(this)->column_number();
2973 45441 : return v ? v : Message::kNoLineNumberInfo;
2974 : }
2975 :
2976 :
2977 45173 : int StackFrame::GetScriptId() const {
2978 : int v = Utils::OpenHandle(this)->script_id();
2979 45173 : return v ? v : Message::kNoScriptIdInfo;
2980 : }
2981 :
2982 212 : Local<String> StackFrame::GetScriptName() const {
2983 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2984 212 : EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
2985 : i::Handle<i::StackFrameInfo> self = Utils::OpenHandle(this);
2986 : i::Handle<i::Object> obj(self->script_name(), isolate);
2987 : return obj->IsString()
2988 : ? scope.Escape(Local<String>::Cast(Utils::ToLocal(obj)))
2989 568 : : Local<String>();
2990 : }
2991 :
2992 :
2993 45239 : Local<String> StackFrame::GetScriptNameOrSourceURL() const {
2994 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
2995 45239 : EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
2996 : i::Handle<i::StackFrameInfo> self = Utils::OpenHandle(this);
2997 : i::Handle<i::Object> obj(self->script_name_or_source_url(), isolate);
2998 : return obj->IsString()
2999 : ? scope.Escape(Local<String>::Cast(Utils::ToLocal(obj)))
3000 135195 : : Local<String>();
3001 : }
3002 :
3003 :
3004 45398 : Local<String> StackFrame::GetFunctionName() const {
3005 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
3006 45398 : EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
3007 : i::Handle<i::StackFrameInfo> self = Utils::OpenHandle(this);
3008 : i::Handle<i::Object> obj(self->function_name(), isolate);
3009 : return obj->IsString()
3010 : ? scope.Escape(Local<String>::Cast(Utils::ToLocal(obj)))
3011 136194 : : Local<String>();
3012 : }
3013 :
3014 240 : bool StackFrame::IsEval() const { return Utils::OpenHandle(this)->is_eval(); }
3015 :
3016 120 : bool StackFrame::IsConstructor() const {
3017 120 : return Utils::OpenHandle(this)->is_constructor();
3018 : }
3019 :
3020 90262 : bool StackFrame::IsWasm() const { return Utils::OpenHandle(this)->is_wasm(); }
3021 :
3022 : // --- N a t i v e W e a k M a p ---
3023 :
3024 6 : Local<NativeWeakMap> NativeWeakMap::New(Isolate* v8_isolate) {
3025 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
3026 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
3027 6 : i::Handle<i::JSWeakMap> weakmap = isolate->factory()->NewJSWeakMap();
3028 6 : i::JSWeakCollection::Initialize(weakmap, isolate);
3029 6 : return Utils::NativeWeakMapToLocal(weakmap);
3030 : }
3031 :
3032 :
3033 24 : void NativeWeakMap::Set(Local<Value> v8_key, Local<Value> v8_value) {
3034 : i::Handle<i::JSWeakMap> weak_collection = Utils::OpenHandle(this);
3035 : i::Isolate* isolate = weak_collection->GetIsolate();
3036 : ENTER_V8(isolate);
3037 : i::HandleScope scope(isolate);
3038 : i::Handle<i::Object> key = Utils::OpenHandle(*v8_key);
3039 24 : i::Handle<i::Object> value = Utils::OpenHandle(*v8_value);
3040 30 : if (!key->IsJSReceiver() && !key->IsSymbol()) {
3041 : DCHECK(false);
3042 : return;
3043 : }
3044 : i::Handle<i::ObjectHashTable> table(
3045 : i::ObjectHashTable::cast(weak_collection->table()));
3046 24 : if (!table->IsKey(isolate, *key)) {
3047 : DCHECK(false);
3048 : return;
3049 : }
3050 24 : int32_t hash = i::Object::GetOrCreateHash(isolate, key)->value();
3051 24 : i::JSWeakCollection::Set(weak_collection, key, value, hash);
3052 : }
3053 :
3054 72 : Local<Value> NativeWeakMap::Get(Local<Value> v8_key) const {
3055 : i::Handle<i::JSWeakMap> weak_collection = Utils::OpenHandle(this);
3056 : i::Isolate* isolate = weak_collection->GetIsolate();
3057 : ENTER_V8(isolate);
3058 : i::Handle<i::Object> key = Utils::OpenHandle(*v8_key);
3059 84 : if (!key->IsJSReceiver() && !key->IsSymbol()) {
3060 : DCHECK(false);
3061 0 : return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
3062 : }
3063 : i::Handle<i::ObjectHashTable> table(
3064 : i::ObjectHashTable::cast(weak_collection->table()));
3065 72 : if (!table->IsKey(isolate, *key)) {
3066 : DCHECK(false);
3067 0 : return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
3068 : }
3069 72 : i::Handle<i::Object> lookup(table->Lookup(key), isolate);
3070 72 : if (lookup->IsTheHole(isolate))
3071 12 : return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
3072 : return Utils::ToLocal(lookup);
3073 : }
3074 :
3075 :
3076 42 : bool NativeWeakMap::Has(Local<Value> v8_key) {
3077 : i::Handle<i::JSWeakMap> weak_collection = Utils::OpenHandle(this);
3078 : i::Isolate* isolate = weak_collection->GetIsolate();
3079 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
3080 : i::HandleScope scope(isolate);
3081 : i::Handle<i::Object> key = Utils::OpenHandle(*v8_key);
3082 48 : if (!key->IsJSReceiver() && !key->IsSymbol()) {
3083 : DCHECK(false);
3084 : return false;
3085 : }
3086 : i::Handle<i::ObjectHashTable> table(
3087 : i::ObjectHashTable::cast(weak_collection->table()));
3088 42 : if (!table->IsKey(isolate, *key)) {
3089 : DCHECK(false);
3090 : return false;
3091 : }
3092 42 : i::Handle<i::Object> lookup(table->Lookup(key), isolate);
3093 42 : return !lookup->IsTheHole(isolate);
3094 : }
3095 :
3096 :
3097 6 : bool NativeWeakMap::Delete(Local<Value> v8_key) {
3098 : i::Handle<i::JSWeakMap> weak_collection = Utils::OpenHandle(this);
3099 : i::Isolate* isolate = weak_collection->GetIsolate();
3100 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
3101 : i::HandleScope scope(isolate);
3102 : i::Handle<i::Object> key = Utils::OpenHandle(*v8_key);
3103 6 : if (!key->IsJSReceiver() && !key->IsSymbol()) {
3104 : DCHECK(false);
3105 : return false;
3106 : }
3107 : i::Handle<i::ObjectHashTable> table(
3108 : i::ObjectHashTable::cast(weak_collection->table()));
3109 6 : if (!table->IsKey(isolate, *key)) {
3110 : DCHECK(false);
3111 : return false;
3112 : }
3113 6 : int32_t hash = i::Object::GetOrCreateHash(isolate, key)->value();
3114 6 : return i::JSWeakCollection::Delete(weak_collection, key, hash);
3115 : }
3116 :
3117 :
3118 : // --- J S O N ---
3119 :
3120 0 : MaybeLocal<Value> JSON::Parse(Isolate* v8_isolate, Local<String> json_string) {
3121 0 : auto isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
3122 0 : PREPARE_FOR_EXECUTION_WITH_ISOLATE(isolate, JSON, Parse, Value);
3123 0 : i::Handle<i::String> string = Utils::OpenHandle(*json_string);
3124 0 : i::Handle<i::String> source = i::String::Flatten(string);
3125 : i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
3126 : auto maybe = source->IsSeqOneByteString()
3127 : ? i::JsonParser<true>::Parse(isolate, source, undefined)
3128 0 : : i::JsonParser<false>::Parse(isolate, source, undefined);
3129 : Local<Value> result;
3130 0 : has_pending_exception = !ToLocal<Value>(maybe, &result);
3131 0 : RETURN_ON_FAILED_EXECUTION(Value);
3132 0 : RETURN_ESCAPED(result);
3133 : }
3134 :
3135 32 : MaybeLocal<Value> JSON::Parse(Local<Context> context,
3136 : Local<String> json_string) {
3137 128 : PREPARE_FOR_EXECUTION(context, JSON, Parse, Value);
3138 32 : i::Handle<i::String> string = Utils::OpenHandle(*json_string);
3139 32 : i::Handle<i::String> source = i::String::Flatten(string);
3140 : i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
3141 : auto maybe = source->IsSeqOneByteString()
3142 : ? i::JsonParser<true>::Parse(isolate, source, undefined)
3143 32 : : i::JsonParser<false>::Parse(isolate, source, undefined);
3144 : Local<Value> result;
3145 32 : has_pending_exception = !ToLocal<Value>(maybe, &result);
3146 33 : RETURN_ON_FAILED_EXECUTION(Value);
3147 31 : RETURN_ESCAPED(result);
3148 : }
3149 :
3150 0 : Local<Value> JSON::Parse(Local<String> json_string) {
3151 0 : RETURN_TO_LOCAL_UNCHECKED(Parse(Local<Context>(), json_string), Value);
3152 : }
3153 :
3154 16 : MaybeLocal<String> JSON::Stringify(Local<Context> context,
3155 : Local<Object> json_object,
3156 : Local<String> gap) {
3157 64 : PREPARE_FOR_EXECUTION(context, JSON, Stringify, String);
3158 : i::Handle<i::Object> object = Utils::OpenHandle(*json_object);
3159 : i::Handle<i::Object> replacer = isolate->factory()->undefined_value();
3160 : i::Handle<i::String> gap_string = gap.IsEmpty()
3161 : ? isolate->factory()->empty_string()
3162 16 : : Utils::OpenHandle(*gap);
3163 : i::Handle<i::Object> maybe;
3164 : has_pending_exception = !i::JsonStringifier(isolate)
3165 : .Stringify(object, replacer, gap_string)
3166 48 : .ToHandle(&maybe);
3167 16 : RETURN_ON_FAILED_EXECUTION(String);
3168 : Local<String> result;
3169 : has_pending_exception =
3170 32 : !ToLocal<String>(i::Object::ToString(isolate, maybe), &result);
3171 16 : RETURN_ON_FAILED_EXECUTION(String);
3172 16 : RETURN_ESCAPED(result);
3173 : }
3174 :
3175 : // --- V a l u e S e r i a l i z a t i o n ---
3176 :
3177 0 : Maybe<bool> ValueSerializer::Delegate::WriteHostObject(Isolate* v8_isolate,
3178 : Local<Object> object) {
3179 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
3180 : isolate->ScheduleThrow(*isolate->factory()->NewError(
3181 : isolate->error_function(), i::MessageTemplate::kDataCloneError,
3182 0 : Utils::OpenHandle(*object)));
3183 0 : return Nothing<bool>();
3184 : }
3185 :
3186 0 : Maybe<uint32_t> ValueSerializer::Delegate::GetSharedArrayBufferId(
3187 : Isolate* v8_isolate, Local<SharedArrayBuffer> shared_array_buffer) {
3188 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
3189 : isolate->ScheduleThrow(*isolate->factory()->NewError(
3190 : isolate->error_function(), i::MessageTemplate::kDataCloneError,
3191 0 : Utils::OpenHandle(*shared_array_buffer)));
3192 0 : return Nothing<uint32_t>();
3193 : }
3194 :
3195 0 : Maybe<uint32_t> ValueSerializer::Delegate::GetWasmModuleTransferId(
3196 : Isolate* v8_isolate, Local<WasmCompiledModule> module) {
3197 0 : return Nothing<uint32_t>();
3198 : }
3199 :
3200 19 : void* ValueSerializer::Delegate::ReallocateBufferMemory(void* old_buffer,
3201 : size_t size,
3202 : size_t* actual_size) {
3203 19 : *actual_size = size;
3204 19 : return realloc(old_buffer, size);
3205 : }
3206 :
3207 1 : void ValueSerializer::Delegate::FreeBufferMemory(void* buffer) {
3208 1 : return free(buffer);
3209 : }
3210 :
3211 1243 : struct ValueSerializer::PrivateData {
3212 : explicit PrivateData(i::Isolate* i, ValueSerializer::Delegate* delegate)
3213 1243 : : isolate(i), serializer(i, delegate) {}
3214 : i::Isolate* isolate;
3215 : i::ValueSerializer serializer;
3216 : };
3217 :
3218 : // static
3219 0 : uint32_t ValueSerializer::GetCurrentDataFormatVersion() {
3220 0 : return i::ValueSerializer::GetCurrentDataFormatVersion();
3221 : }
3222 :
3223 0 : ValueSerializer::ValueSerializer(Isolate* isolate)
3224 0 : : ValueSerializer(isolate, nullptr) {}
3225 :
3226 1243 : ValueSerializer::ValueSerializer(Isolate* isolate, Delegate* delegate)
3227 : : private_(
3228 2486 : new PrivateData(reinterpret_cast<i::Isolate*>(isolate), delegate)) {}
3229 :
3230 2486 : ValueSerializer::~ValueSerializer() { delete private_; }
3231 :
3232 1228 : void ValueSerializer::WriteHeader() { private_->serializer.WriteHeader(); }
3233 :
3234 1 : void ValueSerializer::SetTreatArrayBufferViewsAsHostObjects(bool mode) {
3235 1 : private_->serializer.SetTreatArrayBufferViewsAsHostObjects(mode);
3236 1 : }
3237 :
3238 1228 : Maybe<bool> ValueSerializer::WriteValue(Local<Context> context,
3239 : Local<Value> value) {
3240 4912 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, ValueSerializer, WriteValue, bool);
3241 1228 : i::Handle<i::Object> object = Utils::OpenHandle(*value);
3242 1228 : Maybe<bool> result = private_->serializer.WriteObject(object);
3243 1228 : has_pending_exception = result.IsNothing();
3244 1228 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3245 983 : return result;
3246 : }
3247 :
3248 0 : std::vector<uint8_t> ValueSerializer::ReleaseBuffer() {
3249 0 : return private_->serializer.ReleaseBuffer();
3250 : }
3251 :
3252 983 : std::pair<uint8_t*, size_t> ValueSerializer::Release() {
3253 983 : return private_->serializer.Release();
3254 : }
3255 :
3256 32 : void ValueSerializer::TransferArrayBuffer(uint32_t transfer_id,
3257 : Local<ArrayBuffer> array_buffer) {
3258 : private_->serializer.TransferArrayBuffer(transfer_id,
3259 32 : Utils::OpenHandle(*array_buffer));
3260 32 : }
3261 :
3262 0 : void ValueSerializer::TransferSharedArrayBuffer(
3263 : uint32_t transfer_id, Local<SharedArrayBuffer> shared_array_buffer) {
3264 : private_->serializer.TransferArrayBuffer(
3265 0 : transfer_id, Utils::OpenHandle(*shared_array_buffer));
3266 0 : }
3267 :
3268 2 : void ValueSerializer::WriteUint32(uint32_t value) {
3269 2 : private_->serializer.WriteUint32(value);
3270 2 : }
3271 :
3272 2 : void ValueSerializer::WriteUint64(uint64_t value) {
3273 2 : private_->serializer.WriteUint64(value);
3274 2 : }
3275 :
3276 4 : void ValueSerializer::WriteDouble(double value) {
3277 4 : private_->serializer.WriteDouble(value);
3278 4 : }
3279 :
3280 12 : void ValueSerializer::WriteRawBytes(const void* source, size_t length) {
3281 12 : private_->serializer.WriteRawBytes(source, length);
3282 12 : }
3283 :
3284 0 : MaybeLocal<Object> ValueDeserializer::Delegate::ReadHostObject(
3285 : Isolate* v8_isolate) {
3286 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
3287 : isolate->ScheduleThrow(*isolate->factory()->NewError(
3288 : isolate->error_function(),
3289 0 : i::MessageTemplate::kDataCloneDeserializationError));
3290 0 : return MaybeLocal<Object>();
3291 : }
3292 :
3293 1 : MaybeLocal<WasmCompiledModule> ValueDeserializer::Delegate::GetWasmModuleFromId(
3294 : Isolate* v8_isolate, uint32_t id) {
3295 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
3296 : isolate->ScheduleThrow(*isolate->factory()->NewError(
3297 : isolate->error_function(),
3298 2 : i::MessageTemplate::kDataCloneDeserializationError));
3299 1 : return MaybeLocal<WasmCompiledModule>();
3300 : }
3301 :
3302 1025 : struct ValueDeserializer::PrivateData {
3303 : PrivateData(i::Isolate* i, i::Vector<const uint8_t> data, Delegate* delegate)
3304 1025 : : isolate(i), deserializer(i, data, delegate) {}
3305 : i::Isolate* isolate;
3306 : i::ValueDeserializer deserializer;
3307 : bool has_aborted = false;
3308 : bool supports_legacy_wire_format = false;
3309 : };
3310 :
3311 0 : ValueDeserializer::ValueDeserializer(Isolate* isolate, const uint8_t* data,
3312 : size_t size)
3313 0 : : ValueDeserializer(isolate, data, size, nullptr) {}
3314 :
3315 1025 : ValueDeserializer::ValueDeserializer(Isolate* isolate, const uint8_t* data,
3316 : size_t size, Delegate* delegate) {
3317 1025 : if (base::IsValueInRangeForNumericType<int>(size)) {
3318 : private_ = new PrivateData(
3319 : reinterpret_cast<i::Isolate*>(isolate),
3320 2050 : i::Vector<const uint8_t>(data, static_cast<int>(size)), delegate);
3321 : } else {
3322 : private_ = new PrivateData(reinterpret_cast<i::Isolate*>(isolate),
3323 0 : i::Vector<const uint8_t>(nullptr, 0), nullptr);
3324 0 : private_->has_aborted = true;
3325 : }
3326 1025 : }
3327 :
3328 2050 : ValueDeserializer::~ValueDeserializer() { delete private_; }
3329 :
3330 1025 : Maybe<bool> ValueDeserializer::ReadHeader(Local<Context> context) {
3331 4100 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, ValueDeserializer, ReadHeader, bool);
3332 :
3333 : // We could have aborted during the constructor.
3334 : // If so, ReadHeader is where we report it.
3335 1025 : if (private_->has_aborted) {
3336 : isolate->Throw(*isolate->factory()->NewError(
3337 0 : i::MessageTemplate::kDataCloneDeserializationError));
3338 : has_pending_exception = true;
3339 0 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3340 : }
3341 :
3342 : bool read_header = false;
3343 2050 : has_pending_exception = !private_->deserializer.ReadHeader().To(&read_header);
3344 1025 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3345 : DCHECK(read_header);
3346 :
3347 : static const uint32_t kMinimumNonLegacyVersion = 13;
3348 1140 : if (GetWireFormatVersion() < kMinimumNonLegacyVersion &&
3349 117 : !private_->supports_legacy_wire_format) {
3350 : isolate->Throw(*isolate->factory()->NewError(
3351 0 : i::MessageTemplate::kDataCloneDeserializationVersionError));
3352 : has_pending_exception = true;
3353 0 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
3354 : }
3355 :
3356 : return Just(true);
3357 : }
3358 :
3359 1025 : void ValueDeserializer::SetSupportsLegacyWireFormat(
3360 : bool supports_legacy_wire_format) {
3361 1025 : private_->supports_legacy_wire_format = supports_legacy_wire_format;
3362 1025 : }
3363 :
3364 240 : void ValueDeserializer::SetExpectInlineWasm(bool expect_inline_wasm) {
3365 240 : private_->deserializer.set_expect_inline_wasm(expect_inline_wasm);
3366 240 : }
3367 :
3368 2054 : uint32_t ValueDeserializer::GetWireFormatVersion() const {
3369 2054 : CHECK(!private_->has_aborted);
3370 2054 : return private_->deserializer.GetWireFormatVersion();
3371 : }
3372 :
3373 1023 : MaybeLocal<Value> ValueDeserializer::ReadValue(Local<Context> context) {
3374 1023 : CHECK(!private_->has_aborted);
3375 4092 : PREPARE_FOR_EXECUTION(context, ValueDeserializer, ReadValue, Value);
3376 : i::MaybeHandle<i::Object> result;
3377 1023 : if (GetWireFormatVersion() > 0) {
3378 1011 : result = private_->deserializer.ReadObject();
3379 : } else {
3380 : result =
3381 12 : private_->deserializer.ReadObjectUsingEntireBufferForLegacyFormat();
3382 : }
3383 : Local<Value> value;
3384 : has_pending_exception = !ToLocal(result, &value);
3385 1046 : RETURN_ON_FAILED_EXECUTION(Value);
3386 1000 : RETURN_ESCAPED(value);
3387 : }
3388 :
3389 32 : void ValueDeserializer::TransferArrayBuffer(uint32_t transfer_id,
3390 : Local<ArrayBuffer> array_buffer) {
3391 32 : CHECK(!private_->has_aborted);
3392 : private_->deserializer.TransferArrayBuffer(transfer_id,
3393 32 : Utils::OpenHandle(*array_buffer));
3394 32 : }
3395 :
3396 259 : void ValueDeserializer::TransferSharedArrayBuffer(
3397 : uint32_t transfer_id, Local<SharedArrayBuffer> shared_array_buffer) {
3398 259 : CHECK(!private_->has_aborted);
3399 : private_->deserializer.TransferArrayBuffer(
3400 259 : transfer_id, Utils::OpenHandle(*shared_array_buffer));
3401 259 : }
3402 :
3403 2 : bool ValueDeserializer::ReadUint32(uint32_t* value) {
3404 2 : return private_->deserializer.ReadUint32(value);
3405 : }
3406 :
3407 2 : bool ValueDeserializer::ReadUint64(uint64_t* value) {
3408 2 : return private_->deserializer.ReadUint64(value);
3409 : }
3410 :
3411 4 : bool ValueDeserializer::ReadDouble(double* value) {
3412 4 : return private_->deserializer.ReadDouble(value);
3413 : }
3414 :
3415 13 : bool ValueDeserializer::ReadRawBytes(size_t length, const void** data) {
3416 13 : return private_->deserializer.ReadRawBytes(length, data);
3417 : }
3418 :
3419 : // --- D a t a ---
3420 :
3421 0 : bool Value::FullIsUndefined() const {
3422 : i::Handle<i::Object> object = Utils::OpenHandle(this);
3423 : bool result = false;
3424 0 : if (!object->IsSmi()) {
3425 : result = object->IsUndefined(i::HeapObject::cast(*object)->GetIsolate());
3426 : }
3427 : DCHECK_EQ(result, QuickIsUndefined());
3428 0 : return result;
3429 : }
3430 :
3431 :
3432 0 : bool Value::FullIsNull() const {
3433 : i::Handle<i::Object> object = Utils::OpenHandle(this);
3434 : bool result = false;
3435 0 : if (!object->IsSmi()) {
3436 : result = object->IsNull(i::HeapObject::cast(*object)->GetIsolate());
3437 : }
3438 : DCHECK_EQ(result, QuickIsNull());
3439 0 : return result;
3440 : }
3441 :
3442 :
3443 156549 : bool Value::IsTrue() const {
3444 : i::Handle<i::Object> object = Utils::OpenHandle(this);
3445 156549 : if (object->IsSmi()) return false;
3446 156549 : return object->IsTrue(i::HeapObject::cast(*object)->GetIsolate());
3447 : }
3448 :
3449 :
3450 137 : bool Value::IsFalse() const {
3451 : i::Handle<i::Object> object = Utils::OpenHandle(this);
3452 137 : if (object->IsSmi()) return false;
3453 137 : return object->IsFalse(i::HeapObject::cast(*object)->GetIsolate());
3454 : }
3455 :
3456 :
3457 1190870 : bool Value::IsFunction() const { return Utils::OpenHandle(this)->IsCallable(); }
3458 :
3459 :
3460 15042 : bool Value::IsName() const {
3461 15042 : return Utils::OpenHandle(this)->IsName();
3462 : }
3463 :
3464 :
3465 0 : bool Value::FullIsString() const {
3466 : bool result = Utils::OpenHandle(this)->IsString();
3467 : DCHECK_EQ(result, QuickIsString());
3468 0 : return result;
3469 : }
3470 :
3471 :
3472 4317521 : bool Value::IsSymbol() const {
3473 4317521 : return Utils::OpenHandle(this)->IsSymbol();
3474 : }
3475 :
3476 :
3477 20086498 : bool Value::IsArray() const {
3478 20086498 : return Utils::OpenHandle(this)->IsJSArray();
3479 : }
3480 :
3481 :
3482 13771 : bool Value::IsArrayBuffer() const {
3483 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
3484 26132 : return obj->IsJSArrayBuffer() && !i::JSArrayBuffer::cast(*obj)->is_shared();
3485 : }
3486 :
3487 :
3488 91 : bool Value::IsArrayBufferView() const {
3489 91 : return Utils::OpenHandle(this)->IsJSArrayBufferView();
3490 : }
3491 :
3492 :
3493 10171662 : bool Value::IsTypedArray() const {
3494 10171662 : return Utils::OpenHandle(this)->IsJSTypedArray();
3495 : }
3496 :
3497 :
3498 : #define VALUE_IS_TYPED_ARRAY(Type, typeName, TYPE, ctype, size) \
3499 : bool Value::Is##Type##Array() const { \
3500 : i::Handle<i::Object> obj = Utils::OpenHandle(this); \
3501 : return obj->IsJSTypedArray() && \
3502 : i::JSTypedArray::cast(*obj)->type() == i::kExternal##Type##Array; \
3503 : }
3504 :
3505 :
3506 243 : TYPED_ARRAYS(VALUE_IS_TYPED_ARRAY)
3507 :
3508 : #undef VALUE_IS_TYPED_ARRAY
3509 :
3510 :
3511 9 : bool Value::IsDataView() const {
3512 9 : return Utils::OpenHandle(this)->IsJSDataView();
3513 : }
3514 :
3515 :
3516 1 : bool Value::IsSharedArrayBuffer() const {
3517 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
3518 2 : return obj->IsJSArrayBuffer() && i::JSArrayBuffer::cast(*obj)->is_shared();
3519 : }
3520 :
3521 :
3522 66439794 : bool Value::IsObject() const { return Utils::OpenHandle(this)->IsJSReceiver(); }
3523 :
3524 :
3525 32037519 : bool Value::IsNumber() const {
3526 32037519 : return Utils::OpenHandle(this)->IsNumber();
3527 : }
3528 :
3529 :
3530 20305204 : bool Value::IsProxy() const { return Utils::OpenHandle(this)->IsJSProxy(); }
3531 :
3532 112 : bool Value::IsWebAssemblyCompiledModule() const {
3533 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
3534 112 : if (!obj->IsJSObject()) return false;
3535 : i::Handle<i::JSObject> js_obj = i::Handle<i::JSObject>::cast(obj);
3536 224 : return js_obj->GetIsolate()->native_context()->wasm_module_constructor() ==
3537 112 : js_obj->map()->GetConstructor();
3538 : }
3539 :
3540 : #define VALUE_IS_SPECIFIC_TYPE(Type, Class) \
3541 : bool Value::Is##Type() const { \
3542 : i::Handle<i::Object> obj = Utils::OpenHandle(this); \
3543 : if (!obj->IsHeapObject()) return false; \
3544 : i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate(); \
3545 : return obj->HasSpecificClassOf(isolate->heap()->Class##_string()); \
3546 : }
3547 :
3548 30619298 : VALUE_IS_SPECIFIC_TYPE(ArgumentsObject, Arguments)
3549 2931 : VALUE_IS_SPECIFIC_TYPE(BooleanObject, Boolean)
3550 2777 : VALUE_IS_SPECIFIC_TYPE(NumberObject, Number)
3551 2834 : VALUE_IS_SPECIFIC_TYPE(StringObject, String)
3552 2703 : VALUE_IS_SPECIFIC_TYPE(SymbolObject, Symbol)
3553 30510723 : VALUE_IS_SPECIFIC_TYPE(Date, Date)
3554 30830084 : VALUE_IS_SPECIFIC_TYPE(Map, Map)
3555 30828290 : VALUE_IS_SPECIFIC_TYPE(Set, Set)
3556 30509888 : VALUE_IS_SPECIFIC_TYPE(WeakMap, WeakMap)
3557 30508160 : VALUE_IS_SPECIFIC_TYPE(WeakSet, WeakSet)
3558 :
3559 : #undef VALUE_IS_SPECIFIC_TYPE
3560 :
3561 :
3562 45912071 : bool Value::IsBoolean() const {
3563 45912071 : return Utils::OpenHandle(this)->IsBoolean();
3564 : }
3565 :
3566 :
3567 6 : bool Value::IsExternal() const {
3568 6 : return Utils::OpenHandle(this)->IsExternal();
3569 : }
3570 :
3571 :
3572 795795 : bool Value::IsInt32() const {
3573 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
3574 795795 : if (obj->IsSmi()) return true;
3575 42 : if (obj->IsNumber()) {
3576 42 : return i::IsInt32Double(obj->Number());
3577 : }
3578 : return false;
3579 : }
3580 :
3581 :
3582 258 : bool Value::IsUint32() const {
3583 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
3584 383 : if (obj->IsSmi()) return i::Smi::cast(*obj)->value() >= 0;
3585 133 : if (obj->IsNumber()) {
3586 : double value = obj->Number();
3587 126 : return !i::IsMinusZero(value) &&
3588 112 : value >= 0 &&
3589 238 : value <= i::kMaxUInt32 &&
3590 133 : value == i::FastUI2D(i::FastD2UI(value));
3591 : }
3592 : return false;
3593 : }
3594 :
3595 :
3596 10167588 : bool Value::IsNativeError() const {
3597 10167588 : return Utils::OpenHandle(this)->IsJSError();
3598 : }
3599 :
3600 :
3601 10170185 : bool Value::IsRegExp() const {
3602 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
3603 10170185 : return obj->IsJSRegExp();
3604 : }
3605 :
3606 14 : bool Value::IsAsyncFunction() const {
3607 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
3608 14 : if (!obj->IsJSFunction()) return false;
3609 : i::Handle<i::JSFunction> func = i::Handle<i::JSFunction>::cast(obj);
3610 14 : return i::IsAsyncFunction(func->shared()->kind());
3611 : }
3612 :
3613 65 : bool Value::IsGeneratorFunction() const {
3614 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
3615 65 : if (!obj->IsJSFunction()) return false;
3616 : i::Handle<i::JSFunction> func = i::Handle<i::JSFunction>::cast(obj);
3617 45 : return i::IsGeneratorFunction(func->shared()->kind());
3618 : }
3619 :
3620 :
3621 10274719 : bool Value::IsGeneratorObject() const {
3622 10274719 : return Utils::OpenHandle(this)->IsJSGeneratorObject();
3623 : }
3624 :
3625 :
3626 10169222 : bool Value::IsMapIterator() const {
3627 10169222 : return Utils::OpenHandle(this)->IsJSMapIterator();
3628 : }
3629 :
3630 :
3631 10168550 : bool Value::IsSetIterator() const {
3632 10168550 : return Utils::OpenHandle(this)->IsJSSetIterator();
3633 : }
3634 :
3635 20310768 : bool Value::IsPromise() const { return Utils::OpenHandle(this)->IsJSPromise(); }
3636 :
3637 60694787 : MaybeLocal<String> Value::ToString(Local<Context> context) const {
3638 : auto obj = Utils::OpenHandle(this);
3639 60694785 : if (obj->IsString()) return ToApiHandle<String>(obj);
3640 166676 : PREPARE_FOR_EXECUTION(context, Object, ToString, String);
3641 : Local<String> result;
3642 : has_pending_exception =
3643 83338 : !ToLocal<String>(i::Object::ToString(isolate, obj), &result);
3644 41798 : RETURN_ON_FAILED_EXECUTION(String);
3645 41540 : RETURN_ESCAPED(result);
3646 : }
3647 :
3648 :
3649 0 : Local<String> Value::ToString(Isolate* isolate) const {
3650 0 : RETURN_TO_LOCAL_UNCHECKED(ToString(isolate->GetCurrentContext()), String);
3651 : }
3652 :
3653 :
3654 0 : MaybeLocal<String> Value::ToDetailString(Local<Context> context) const {
3655 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
3656 0 : if (obj->IsString()) return ToApiHandle<String>(obj);
3657 0 : PREPARE_FOR_EXECUTION(context, Object, ToDetailString, String);
3658 : Local<String> result =
3659 0 : Utils::ToLocal(i::Object::NoSideEffectsToString(isolate, obj));
3660 : RETURN_ON_FAILED_EXECUTION(String);
3661 0 : RETURN_ESCAPED(result);
3662 : }
3663 :
3664 :
3665 0 : Local<String> Value::ToDetailString(Isolate* isolate) const {
3666 0 : RETURN_TO_LOCAL_UNCHECKED(ToDetailString(isolate->GetCurrentContext()),
3667 : String);
3668 : }
3669 :
3670 :
3671 2544 : MaybeLocal<Object> Value::ToObject(Local<Context> context) const {
3672 : auto obj = Utils::OpenHandle(this);
3673 2544 : if (obj->IsJSReceiver()) return ToApiHandle<Object>(obj);
3674 28 : PREPARE_FOR_EXECUTION(context, Object, ToObject, Object);
3675 : Local<Object> result;
3676 : has_pending_exception =
3677 14 : !ToLocal<Object>(i::Object::ToObject(isolate, obj), &result);
3678 14 : RETURN_ON_FAILED_EXECUTION(Object);
3679 0 : RETURN_ESCAPED(result);
3680 : }
3681 :
3682 :
3683 0 : Local<v8::Object> Value::ToObject(Isolate* isolate) const {
3684 0 : RETURN_TO_LOCAL_UNCHECKED(ToObject(isolate->GetCurrentContext()), Object);
3685 : }
3686 :
3687 :
3688 180 : MaybeLocal<Boolean> Value::ToBoolean(Local<Context> context) const {
3689 : auto obj = Utils::OpenHandle(this);
3690 180 : if (obj->IsBoolean()) return ToApiHandle<Boolean>(obj);
3691 : auto isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
3692 0 : auto val = isolate->factory()->ToBoolean(obj->BooleanValue());
3693 0 : return ToApiHandle<Boolean>(val);
3694 : }
3695 :
3696 :
3697 0 : Local<Boolean> Value::ToBoolean(Isolate* v8_isolate) const {
3698 0 : return ToBoolean(v8_isolate->GetCurrentContext()).ToLocalChecked();
3699 : }
3700 :
3701 :
3702 141 : MaybeLocal<Number> Value::ToNumber(Local<Context> context) const {
3703 : auto obj = Utils::OpenHandle(this);
3704 141 : if (obj->IsNumber()) return ToApiHandle<Number>(obj);
3705 28 : PREPARE_FOR_EXECUTION(context, Object, ToNumber, Number);
3706 : Local<Number> result;
3707 14 : has_pending_exception = !ToLocal<Number>(i::Object::ToNumber(obj), &result);
3708 14 : RETURN_ON_FAILED_EXECUTION(Number);
3709 0 : RETURN_ESCAPED(result);
3710 : }
3711 :
3712 :
3713 0 : Local<Number> Value::ToNumber(Isolate* isolate) const {
3714 0 : RETURN_TO_LOCAL_UNCHECKED(ToNumber(isolate->GetCurrentContext()), Number);
3715 : }
3716 :
3717 :
3718 49 : MaybeLocal<Integer> Value::ToInteger(Local<Context> context) const {
3719 : auto obj = Utils::OpenHandle(this);
3720 49 : if (obj->IsSmi()) return ToApiHandle<Integer>(obj);
3721 28 : PREPARE_FOR_EXECUTION(context, Object, ToInteger, Integer);
3722 : Local<Integer> result;
3723 : has_pending_exception =
3724 7 : !ToLocal<Integer>(i::Object::ToInteger(isolate, obj), &result);
3725 14 : RETURN_ON_FAILED_EXECUTION(Integer);
3726 0 : RETURN_ESCAPED(result);
3727 : }
3728 :
3729 :
3730 0 : Local<Integer> Value::ToInteger(Isolate* isolate) const {
3731 0 : RETURN_TO_LOCAL_UNCHECKED(ToInteger(isolate->GetCurrentContext()), Integer);
3732 : }
3733 :
3734 :
3735 148 : MaybeLocal<Int32> Value::ToInt32(Local<Context> context) const {
3736 : auto obj = Utils::OpenHandle(this);
3737 148 : if (obj->IsSmi()) return ToApiHandle<Int32>(obj);
3738 : Local<Int32> result;
3739 192 : PREPARE_FOR_EXECUTION(context, Object, ToInt32, Int32);
3740 : has_pending_exception =
3741 48 : !ToLocal<Int32>(i::Object::ToInt32(isolate, obj), &result);
3742 55 : RETURN_ON_FAILED_EXECUTION(Int32);
3743 41 : RETURN_ESCAPED(result);
3744 : }
3745 :
3746 :
3747 0 : Local<Int32> Value::ToInt32(Isolate* isolate) const {
3748 0 : RETURN_TO_LOCAL_UNCHECKED(ToInt32(isolate->GetCurrentContext()), Int32);
3749 : }
3750 :
3751 :
3752 56 : MaybeLocal<Uint32> Value::ToUint32(Local<Context> context) const {
3753 : auto obj = Utils::OpenHandle(this);
3754 56 : if (obj->IsSmi()) return ToApiHandle<Uint32>(obj);
3755 : Local<Uint32> result;
3756 168 : PREPARE_FOR_EXECUTION(context, Object, ToUint32, Uint32);
3757 : has_pending_exception =
3758 84 : !ToLocal<Uint32>(i::Object::ToUint32(isolate, obj), &result);
3759 49 : RETURN_ON_FAILED_EXECUTION(Uint32);
3760 35 : RETURN_ESCAPED(result);
3761 : }
3762 :
3763 :
3764 0 : Local<Uint32> Value::ToUint32(Isolate* isolate) const {
3765 0 : RETURN_TO_LOCAL_UNCHECKED(ToUint32(isolate->GetCurrentContext()), Uint32);
3766 : }
3767 :
3768 :
3769 0 : void i::Internals::CheckInitializedImpl(v8::Isolate* external_isolate) {
3770 0 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(external_isolate);
3771 0 : Utils::ApiCheck(isolate != NULL && !isolate->IsDead(),
3772 : "v8::internal::Internals::CheckInitialized",
3773 : "Isolate is not initialized or V8 has died");
3774 0 : }
3775 :
3776 :
3777 0 : void External::CheckCast(v8::Value* that) {
3778 : Utils::ApiCheck(Utils::OpenHandle(that)->IsExternal(), "v8::External::Cast",
3779 : "Could not convert to external");
3780 0 : }
3781 :
3782 :
3783 0 : void v8::Object::CheckCast(Value* that) {
3784 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3785 : Utils::ApiCheck(obj->IsJSReceiver(), "v8::Object::Cast",
3786 : "Could not convert to object");
3787 0 : }
3788 :
3789 :
3790 0 : void v8::Function::CheckCast(Value* that) {
3791 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3792 : Utils::ApiCheck(obj->IsCallable(), "v8::Function::Cast",
3793 : "Could not convert to function");
3794 0 : }
3795 :
3796 :
3797 0 : void v8::Boolean::CheckCast(v8::Value* that) {
3798 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3799 : Utils::ApiCheck(obj->IsBoolean(), "v8::Boolean::Cast",
3800 : "Could not convert to boolean");
3801 0 : }
3802 :
3803 :
3804 0 : void v8::Name::CheckCast(v8::Value* that) {
3805 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3806 : Utils::ApiCheck(obj->IsName(), "v8::Name::Cast", "Could not convert to name");
3807 0 : }
3808 :
3809 :
3810 0 : void v8::String::CheckCast(v8::Value* that) {
3811 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3812 : Utils::ApiCheck(obj->IsString(), "v8::String::Cast",
3813 : "Could not convert to string");
3814 0 : }
3815 :
3816 :
3817 0 : void v8::Symbol::CheckCast(v8::Value* that) {
3818 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3819 : Utils::ApiCheck(obj->IsSymbol(), "v8::Symbol::Cast",
3820 : "Could not convert to symbol");
3821 0 : }
3822 :
3823 :
3824 0 : void v8::Number::CheckCast(v8::Value* that) {
3825 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3826 : Utils::ApiCheck(obj->IsNumber(),
3827 : "v8::Number::Cast()",
3828 : "Could not convert to number");
3829 0 : }
3830 :
3831 :
3832 0 : void v8::Integer::CheckCast(v8::Value* that) {
3833 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3834 : Utils::ApiCheck(obj->IsNumber(), "v8::Integer::Cast",
3835 : "Could not convert to number");
3836 0 : }
3837 :
3838 :
3839 0 : void v8::Int32::CheckCast(v8::Value* that) {
3840 0 : Utils::ApiCheck(that->IsInt32(), "v8::Int32::Cast",
3841 : "Could not convert to 32-bit signed integer");
3842 0 : }
3843 :
3844 :
3845 0 : void v8::Uint32::CheckCast(v8::Value* that) {
3846 0 : Utils::ApiCheck(that->IsUint32(), "v8::Uint32::Cast",
3847 : "Could not convert to 32-bit unsigned integer");
3848 0 : }
3849 :
3850 :
3851 0 : void v8::Array::CheckCast(Value* that) {
3852 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3853 : Utils::ApiCheck(obj->IsJSArray(), "v8::Array::Cast",
3854 : "Could not convert to array");
3855 0 : }
3856 :
3857 :
3858 0 : void v8::Map::CheckCast(Value* that) {
3859 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3860 : Utils::ApiCheck(obj->IsJSMap(), "v8::Map::Cast", "Could not convert to Map");
3861 0 : }
3862 :
3863 :
3864 0 : void v8::Set::CheckCast(Value* that) {
3865 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3866 : Utils::ApiCheck(obj->IsJSSet(), "v8_Set_Cast", "Could not convert to Set");
3867 0 : }
3868 :
3869 :
3870 0 : void v8::Promise::CheckCast(Value* that) {
3871 0 : Utils::ApiCheck(that->IsPromise(), "v8::Promise::Cast",
3872 : "Could not convert to promise");
3873 0 : }
3874 :
3875 :
3876 0 : void v8::Promise::Resolver::CheckCast(Value* that) {
3877 0 : Utils::ApiCheck(that->IsPromise(), "v8::Promise::Resolver::Cast",
3878 : "Could not convert to promise resolver");
3879 0 : }
3880 :
3881 :
3882 0 : void v8::Proxy::CheckCast(Value* that) {
3883 0 : Utils::ApiCheck(that->IsProxy(), "v8::Proxy::Cast",
3884 : "Could not convert to proxy");
3885 0 : }
3886 :
3887 0 : void v8::WasmCompiledModule::CheckCast(Value* that) {
3888 0 : Utils::ApiCheck(that->IsWebAssemblyCompiledModule(),
3889 : "v8::WasmCompiledModule::Cast",
3890 : "Could not convert to wasm compiled module");
3891 0 : }
3892 :
3893 0 : void v8::ArrayBuffer::CheckCast(Value* that) {
3894 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3895 : Utils::ApiCheck(
3896 0 : obj->IsJSArrayBuffer() && !i::JSArrayBuffer::cast(*obj)->is_shared(),
3897 : "v8::ArrayBuffer::Cast()", "Could not convert to ArrayBuffer");
3898 0 : }
3899 :
3900 :
3901 0 : void v8::ArrayBufferView::CheckCast(Value* that) {
3902 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3903 : Utils::ApiCheck(obj->IsJSArrayBufferView(),
3904 : "v8::ArrayBufferView::Cast()",
3905 : "Could not convert to ArrayBufferView");
3906 0 : }
3907 :
3908 :
3909 0 : void v8::TypedArray::CheckCast(Value* that) {
3910 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3911 : Utils::ApiCheck(obj->IsJSTypedArray(),
3912 : "v8::TypedArray::Cast()",
3913 : "Could not convert to TypedArray");
3914 0 : }
3915 :
3916 :
3917 : #define CHECK_TYPED_ARRAY_CAST(Type, typeName, TYPE, ctype, size) \
3918 : void v8::Type##Array::CheckCast(Value* that) { \
3919 : i::Handle<i::Object> obj = Utils::OpenHandle(that); \
3920 : Utils::ApiCheck( \
3921 : obj->IsJSTypedArray() && \
3922 : i::JSTypedArray::cast(*obj)->type() == i::kExternal##Type##Array, \
3923 : "v8::" #Type "Array::Cast()", "Could not convert to " #Type "Array"); \
3924 : }
3925 :
3926 :
3927 0 : TYPED_ARRAYS(CHECK_TYPED_ARRAY_CAST)
3928 :
3929 : #undef CHECK_TYPED_ARRAY_CAST
3930 :
3931 :
3932 0 : void v8::DataView::CheckCast(Value* that) {
3933 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3934 : Utils::ApiCheck(obj->IsJSDataView(),
3935 : "v8::DataView::Cast()",
3936 : "Could not convert to DataView");
3937 0 : }
3938 :
3939 :
3940 0 : void v8::SharedArrayBuffer::CheckCast(Value* that) {
3941 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3942 : Utils::ApiCheck(
3943 0 : obj->IsJSArrayBuffer() && i::JSArrayBuffer::cast(*obj)->is_shared(),
3944 : "v8::SharedArrayBuffer::Cast()",
3945 : "Could not convert to SharedArrayBuffer");
3946 0 : }
3947 :
3948 :
3949 0 : void v8::Date::CheckCast(v8::Value* that) {
3950 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3951 : i::Isolate* isolate = NULL;
3952 0 : if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3953 0 : Utils::ApiCheck(isolate != NULL &&
3954 0 : obj->HasSpecificClassOf(isolate->heap()->Date_string()),
3955 : "v8::Date::Cast()",
3956 : "Could not convert to date");
3957 0 : }
3958 :
3959 :
3960 0 : void v8::StringObject::CheckCast(v8::Value* that) {
3961 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3962 : i::Isolate* isolate = NULL;
3963 0 : if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3964 0 : Utils::ApiCheck(isolate != NULL &&
3965 0 : obj->HasSpecificClassOf(isolate->heap()->String_string()),
3966 : "v8::StringObject::Cast()",
3967 : "Could not convert to StringObject");
3968 0 : }
3969 :
3970 :
3971 0 : void v8::SymbolObject::CheckCast(v8::Value* that) {
3972 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3973 : i::Isolate* isolate = NULL;
3974 0 : if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3975 0 : Utils::ApiCheck(isolate != NULL &&
3976 0 : obj->HasSpecificClassOf(isolate->heap()->Symbol_string()),
3977 : "v8::SymbolObject::Cast()",
3978 : "Could not convert to SymbolObject");
3979 0 : }
3980 :
3981 :
3982 0 : void v8::NumberObject::CheckCast(v8::Value* that) {
3983 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3984 : i::Isolate* isolate = NULL;
3985 0 : if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3986 0 : Utils::ApiCheck(isolate != NULL &&
3987 0 : obj->HasSpecificClassOf(isolate->heap()->Number_string()),
3988 : "v8::NumberObject::Cast()",
3989 : "Could not convert to NumberObject");
3990 0 : }
3991 :
3992 :
3993 0 : void v8::BooleanObject::CheckCast(v8::Value* that) {
3994 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
3995 : i::Isolate* isolate = NULL;
3996 0 : if (obj->IsHeapObject()) isolate = i::HeapObject::cast(*obj)->GetIsolate();
3997 0 : Utils::ApiCheck(isolate != NULL &&
3998 0 : obj->HasSpecificClassOf(isolate->heap()->Boolean_string()),
3999 : "v8::BooleanObject::Cast()",
4000 : "Could not convert to BooleanObject");
4001 0 : }
4002 :
4003 :
4004 0 : void v8::RegExp::CheckCast(v8::Value* that) {
4005 : i::Handle<i::Object> obj = Utils::OpenHandle(that);
4006 : Utils::ApiCheck(obj->IsJSRegExp(),
4007 : "v8::RegExp::Cast()",
4008 : "Could not convert to regular expression");
4009 0 : }
4010 :
4011 :
4012 15543 : Maybe<bool> Value::BooleanValue(Local<Context> context) const {
4013 31086 : return Just(Utils::OpenHandle(this)->BooleanValue());
4014 : }
4015 :
4016 :
4017 0 : bool Value::BooleanValue() const {
4018 0 : return Utils::OpenHandle(this)->BooleanValue();
4019 : }
4020 :
4021 :
4022 10174 : Maybe<double> Value::NumberValue(Local<Context> context) const {
4023 : auto obj = Utils::OpenHandle(this);
4024 10174 : if (obj->IsNumber()) return Just(obj->Number());
4025 904 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, NumberValue, double);
4026 : i::Handle<i::Object> num;
4027 452 : has_pending_exception = !i::Object::ToNumber(obj).ToHandle(&num);
4028 226 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(double);
4029 : return Just(num->Number());
4030 : }
4031 :
4032 :
4033 0 : double Value::NumberValue() const {
4034 : auto obj = Utils::OpenHandle(this);
4035 0 : if (obj->IsNumber()) return obj->Number();
4036 : return NumberValue(ContextFromHeapObject(obj))
4037 0 : .FromMaybe(std::numeric_limits<double>::quiet_NaN());
4038 : }
4039 :
4040 :
4041 6496 : Maybe<int64_t> Value::IntegerValue(Local<Context> context) const {
4042 : auto obj = Utils::OpenHandle(this);
4043 6496 : if (obj->IsNumber()) {
4044 : return Just(NumberToInt64(*obj));
4045 : }
4046 1436 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, IntegerValue, int64_t);
4047 : i::Handle<i::Object> num;
4048 359 : has_pending_exception = !i::Object::ToInteger(isolate, obj).ToHandle(&num);
4049 359 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int64_t);
4050 : return Just(NumberToInt64(*num));
4051 : }
4052 :
4053 :
4054 0 : int64_t Value::IntegerValue() const {
4055 : auto obj = Utils::OpenHandle(this);
4056 0 : if (obj->IsNumber()) {
4057 0 : if (obj->IsSmi()) {
4058 0 : return i::Smi::cast(*obj)->value();
4059 : } else {
4060 0 : return static_cast<int64_t>(obj->Number());
4061 : }
4062 : }
4063 0 : return IntegerValue(ContextFromHeapObject(obj)).FromMaybe(0);
4064 : }
4065 :
4066 :
4067 659679 : Maybe<int32_t> Value::Int32Value(Local<Context> context) const {
4068 : auto obj = Utils::OpenHandle(this);
4069 1318265 : if (obj->IsNumber()) return Just(NumberToInt32(*obj));
4070 4372 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, Int32Value, int32_t);
4071 : i::Handle<i::Object> num;
4072 1093 : has_pending_exception = !i::Object::ToInt32(isolate, obj).ToHandle(&num);
4073 1093 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int32_t);
4074 : return Just(num->IsSmi() ? i::Smi::cast(*num)->value()
4075 1011 : : static_cast<int32_t>(num->Number()));
4076 : }
4077 :
4078 :
4079 0 : int32_t Value::Int32Value() const {
4080 : auto obj = Utils::OpenHandle(this);
4081 0 : if (obj->IsNumber()) return NumberToInt32(*obj);
4082 0 : return Int32Value(ContextFromHeapObject(obj)).FromMaybe(0);
4083 : }
4084 :
4085 :
4086 249 : Maybe<uint32_t> Value::Uint32Value(Local<Context> context) const {
4087 : auto obj = Utils::OpenHandle(this);
4088 491 : if (obj->IsNumber()) return Just(NumberToUint32(*obj));
4089 28 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, Uint32Value, uint32_t);
4090 : i::Handle<i::Object> num;
4091 14 : has_pending_exception = !i::Object::ToUint32(isolate, obj).ToHandle(&num);
4092 7 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(uint32_t);
4093 : return Just(num->IsSmi() ? static_cast<uint32_t>(i::Smi::cast(*num)->value())
4094 0 : : static_cast<uint32_t>(num->Number()));
4095 : }
4096 :
4097 :
4098 0 : uint32_t Value::Uint32Value() const {
4099 : auto obj = Utils::OpenHandle(this);
4100 0 : if (obj->IsNumber()) return NumberToUint32(*obj);
4101 0 : return Uint32Value(ContextFromHeapObject(obj)).FromMaybe(0);
4102 : }
4103 :
4104 :
4105 49 : MaybeLocal<Uint32> Value::ToArrayIndex(Local<Context> context) const {
4106 : auto self = Utils::OpenHandle(this);
4107 49 : if (self->IsSmi()) {
4108 14 : if (i::Smi::cast(*self)->value() >= 0) return Utils::Uint32ToLocal(self);
4109 7 : return Local<Uint32>();
4110 : }
4111 140 : PREPARE_FOR_EXECUTION(context, Object, ToArrayIndex, Uint32);
4112 : i::Handle<i::Object> string_obj;
4113 : has_pending_exception =
4114 70 : !i::Object::ToString(isolate, self).ToHandle(&string_obj);
4115 35 : RETURN_ON_FAILED_EXECUTION(Uint32);
4116 : i::Handle<i::String> str = i::Handle<i::String>::cast(string_obj);
4117 : uint32_t index;
4118 35 : if (str->AsArrayIndex(&index)) {
4119 : i::Handle<i::Object> value;
4120 14 : if (index <= static_cast<uint32_t>(i::Smi::kMaxValue)) {
4121 : value = i::Handle<i::Object>(i::Smi::FromInt(index), isolate);
4122 : } else {
4123 7 : value = isolate->factory()->NewNumber(index);
4124 : }
4125 14 : RETURN_ESCAPED(Utils::Uint32ToLocal(value));
4126 : }
4127 21 : return Local<Uint32>();
4128 : }
4129 :
4130 :
4131 0 : Local<Uint32> Value::ToArrayIndex() const {
4132 : auto self = Utils::OpenHandle(this);
4133 0 : if (self->IsSmi()) {
4134 0 : if (i::Smi::cast(*self)->value() >= 0) return Utils::Uint32ToLocal(self);
4135 0 : return Local<Uint32>();
4136 : }
4137 0 : auto context = ContextFromHeapObject(self);
4138 0 : RETURN_TO_LOCAL_UNCHECKED(ToArrayIndex(context), Uint32);
4139 : }
4140 :
4141 :
4142 192426 : Maybe<bool> Value::Equals(Local<Context> context, Local<Value> that) const {
4143 192426 : auto self = Utils::OpenHandle(this);
4144 192426 : auto other = Utils::OpenHandle(*that);
4145 192426 : return i::Object::Equals(self, other);
4146 : }
4147 :
4148 :
4149 0 : bool Value::Equals(Local<Value> that) const {
4150 0 : auto self = Utils::OpenHandle(this);
4151 0 : auto other = Utils::OpenHandle(*that);
4152 0 : if (self->IsSmi() && other->IsSmi()) {
4153 0 : return self->Number() == other->Number();
4154 : }
4155 0 : if (self->IsJSObject() && other->IsJSObject()) {
4156 0 : return *self == *other;
4157 : }
4158 0 : auto heap_object = self->IsSmi() ? other : self;
4159 : auto context = ContextFromHeapObject(heap_object);
4160 : return Equals(context, that).FromMaybe(false);
4161 : }
4162 :
4163 :
4164 659 : bool Value::StrictEquals(Local<Value> that) const {
4165 : auto self = Utils::OpenHandle(this);
4166 : auto other = Utils::OpenHandle(*that);
4167 659 : return self->StrictEquals(*other);
4168 : }
4169 :
4170 :
4171 334 : bool Value::SameValue(Local<Value> that) const {
4172 : auto self = Utils::OpenHandle(this);
4173 : auto other = Utils::OpenHandle(*that);
4174 334 : return self->SameValue(*other);
4175 : }
4176 :
4177 58 : Local<String> Value::TypeOf(v8::Isolate* external_isolate) {
4178 58 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(external_isolate);
4179 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
4180 116 : LOG_API(isolate, Value, TypeOf);
4181 116 : return Utils::ToLocal(i::Object::TypeOf(isolate, Utils::OpenHandle(this)));
4182 : }
4183 :
4184 84 : Maybe<bool> Value::InstanceOf(v8::Local<v8::Context> context,
4185 : v8::Local<v8::Object> object) {
4186 336 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Value, InstanceOf, bool);
4187 84 : auto left = Utils::OpenHandle(this);
4188 : auto right = Utils::OpenHandle(*object);
4189 : i::Handle<i::Object> result;
4190 : has_pending_exception =
4191 168 : !i::Object::InstanceOf(isolate, left, right).ToHandle(&result);
4192 84 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4193 : return Just(result->IsTrue(isolate));
4194 : }
4195 :
4196 420763 : Maybe<bool> v8::Object::Set(v8::Local<v8::Context> context,
4197 : v8::Local<Value> key, v8::Local<Value> value) {
4198 1683052 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, Set, bool);
4199 : auto self = Utils::OpenHandle(this);
4200 420763 : auto key_obj = Utils::OpenHandle(*key);
4201 420763 : auto value_obj = Utils::OpenHandle(*value);
4202 : has_pending_exception =
4203 : i::Runtime::SetObjectProperty(isolate, self, key_obj, value_obj,
4204 841526 : i::SLOPPY).is_null();
4205 420763 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4206 : return Just(true);
4207 : }
4208 :
4209 :
4210 0 : bool v8::Object::Set(v8::Local<Value> key, v8::Local<Value> value) {
4211 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4212 0 : return Set(context, key, value).FromMaybe(false);
4213 : }
4214 :
4215 :
4216 204572 : Maybe<bool> v8::Object::Set(v8::Local<v8::Context> context, uint32_t index,
4217 : v8::Local<Value> value) {
4218 818288 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, Set, bool);
4219 : auto self = Utils::OpenHandle(this);
4220 204572 : auto value_obj = Utils::OpenHandle(*value);
4221 : has_pending_exception = i::Object::SetElement(isolate, self, index, value_obj,
4222 409144 : i::SLOPPY).is_null();
4223 204572 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4224 : return Just(true);
4225 : }
4226 :
4227 :
4228 0 : bool v8::Object::Set(uint32_t index, v8::Local<Value> value) {
4229 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4230 0 : return Set(context, index, value).FromMaybe(false);
4231 : }
4232 :
4233 :
4234 279524 : Maybe<bool> v8::Object::CreateDataProperty(v8::Local<v8::Context> context,
4235 : v8::Local<Name> key,
4236 : v8::Local<Value> value) {
4237 1118096 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, CreateDataProperty, bool);
4238 : i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
4239 279524 : i::Handle<i::Name> key_obj = Utils::OpenHandle(*key);
4240 279524 : i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
4241 :
4242 : i::LookupIterator it = i::LookupIterator::PropertyOrElement(
4243 279524 : isolate, self, key_obj, self, i::LookupIterator::OWN);
4244 : Maybe<bool> result =
4245 279524 : i::JSReceiver::CreateDataProperty(&it, value_obj, i::Object::DONT_THROW);
4246 279524 : has_pending_exception = result.IsNothing();
4247 279524 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4248 279518 : return result;
4249 : }
4250 :
4251 :
4252 13702 : Maybe<bool> v8::Object::CreateDataProperty(v8::Local<v8::Context> context,
4253 : uint32_t index,
4254 : v8::Local<Value> value) {
4255 54808 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, CreateDataProperty, bool);
4256 : i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
4257 13702 : i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
4258 :
4259 : i::LookupIterator it(isolate, self, index, self, i::LookupIterator::OWN);
4260 : Maybe<bool> result =
4261 13702 : i::JSReceiver::CreateDataProperty(&it, value_obj, i::Object::DONT_THROW);
4262 13702 : has_pending_exception = result.IsNothing();
4263 13702 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4264 13702 : return result;
4265 : }
4266 :
4267 : struct v8::PropertyDescriptor::PrivateData {
4268 : PrivateData() : desc() {}
4269 : i::PropertyDescriptor desc;
4270 : };
4271 :
4272 242 : v8::PropertyDescriptor::PropertyDescriptor() : private_(new PrivateData()) {}
4273 :
4274 : // DataDescriptor
4275 96 : v8::PropertyDescriptor::PropertyDescriptor(v8::Local<v8::Value> value)
4276 192 : : private_(new PrivateData()) {
4277 : private_->desc.set_value(Utils::OpenHandle(*value, true));
4278 96 : }
4279 :
4280 : // DataDescriptor with writable field
4281 31 : v8::PropertyDescriptor::PropertyDescriptor(v8::Local<v8::Value> value,
4282 : bool writable)
4283 62 : : private_(new PrivateData()) {
4284 : private_->desc.set_value(Utils::OpenHandle(*value, true));
4285 : private_->desc.set_writable(writable);
4286 31 : }
4287 :
4288 : // AccessorDescriptor
4289 77 : v8::PropertyDescriptor::PropertyDescriptor(v8::Local<v8::Value> get,
4290 : v8::Local<v8::Value> set)
4291 154 : : private_(new PrivateData()) {
4292 : DCHECK(get.IsEmpty() || get->IsUndefined() || get->IsFunction());
4293 : DCHECK(set.IsEmpty() || set->IsUndefined() || set->IsFunction());
4294 : private_->desc.set_get(Utils::OpenHandle(*get, true));
4295 : private_->desc.set_set(Utils::OpenHandle(*set, true));
4296 77 : }
4297 :
4298 325 : v8::PropertyDescriptor::~PropertyDescriptor() { delete private_; }
4299 :
4300 38 : v8::Local<Value> v8::PropertyDescriptor::value() const {
4301 : DCHECK(private_->desc.has_value());
4302 38 : return Utils::ToLocal(private_->desc.value());
4303 : }
4304 :
4305 26 : v8::Local<Value> v8::PropertyDescriptor::get() const {
4306 : DCHECK(private_->desc.has_get());
4307 26 : return Utils::ToLocal(private_->desc.get());
4308 : }
4309 :
4310 26 : v8::Local<Value> v8::PropertyDescriptor::set() const {
4311 : DCHECK(private_->desc.has_set());
4312 26 : return Utils::ToLocal(private_->desc.set());
4313 : }
4314 :
4315 82 : bool v8::PropertyDescriptor::has_value() const {
4316 164 : return private_->desc.has_value();
4317 : }
4318 82 : bool v8::PropertyDescriptor::has_get() const {
4319 164 : return private_->desc.has_get();
4320 : }
4321 82 : bool v8::PropertyDescriptor::has_set() const {
4322 164 : return private_->desc.has_set();
4323 : }
4324 :
4325 19 : bool v8::PropertyDescriptor::writable() const {
4326 : DCHECK(private_->desc.has_writable());
4327 38 : return private_->desc.writable();
4328 : }
4329 :
4330 82 : bool v8::PropertyDescriptor::has_writable() const {
4331 164 : return private_->desc.has_writable();
4332 : }
4333 :
4334 44 : void v8::PropertyDescriptor::set_enumerable(bool enumerable) {
4335 44 : private_->desc.set_enumerable(enumerable);
4336 44 : }
4337 :
4338 20 : bool v8::PropertyDescriptor::enumerable() const {
4339 : DCHECK(private_->desc.has_enumerable());
4340 40 : return private_->desc.enumerable();
4341 : }
4342 :
4343 75 : bool v8::PropertyDescriptor::has_enumerable() const {
4344 150 : return private_->desc.has_enumerable();
4345 : }
4346 :
4347 45 : void v8::PropertyDescriptor::set_configurable(bool configurable) {
4348 45 : private_->desc.set_configurable(configurable);
4349 45 : }
4350 :
4351 38 : bool v8::PropertyDescriptor::configurable() const {
4352 : DCHECK(private_->desc.has_configurable());
4353 76 : return private_->desc.configurable();
4354 : }
4355 :
4356 75 : bool v8::PropertyDescriptor::has_configurable() const {
4357 150 : return private_->desc.has_configurable();
4358 : }
4359 :
4360 4734 : Maybe<bool> v8::Object::DefineOwnProperty(v8::Local<v8::Context> context,
4361 : v8::Local<Name> key,
4362 : v8::Local<Value> value,
4363 : v8::PropertyAttribute attributes) {
4364 18936 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, DefineOwnProperty, bool);
4365 4734 : i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
4366 : i::Handle<i::Name> key_obj = Utils::OpenHandle(*key);
4367 : i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
4368 :
4369 : i::PropertyDescriptor desc;
4370 4734 : desc.set_writable(!(attributes & v8::ReadOnly));
4371 4734 : desc.set_enumerable(!(attributes & v8::DontEnum));
4372 4734 : desc.set_configurable(!(attributes & v8::DontDelete));
4373 : desc.set_value(value_obj);
4374 : Maybe<bool> success = i::JSReceiver::DefineOwnProperty(
4375 4734 : isolate, self, key_obj, &desc, i::Object::DONT_THROW);
4376 : // Even though we said DONT_THROW, there might be accessors that do throw.
4377 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4378 4734 : return success;
4379 : }
4380 :
4381 151 : Maybe<bool> v8::Object::DefineProperty(v8::Local<v8::Context> context,
4382 : v8::Local<Name> key,
4383 : PropertyDescriptor& descriptor) {
4384 604 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, DefineProperty, bool);
4385 151 : i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
4386 : i::Handle<i::Name> key_obj = Utils::OpenHandle(*key);
4387 :
4388 : Maybe<bool> success = i::JSReceiver::DefineOwnProperty(
4389 : isolate, self, key_obj, &descriptor.get_private()->desc,
4390 302 : i::Object::DONT_THROW);
4391 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4392 151 : return success;
4393 : }
4394 :
4395 : MUST_USE_RESULT
4396 0 : static i::MaybeHandle<i::Object> DefineObjectProperty(
4397 : i::Handle<i::JSObject> js_object, i::Handle<i::Object> key,
4398 : i::Handle<i::Object> value, i::PropertyAttributes attrs) {
4399 : i::Isolate* isolate = js_object->GetIsolate();
4400 0 : bool success = false;
4401 : i::LookupIterator it = i::LookupIterator::PropertyOrElement(
4402 0 : isolate, js_object, key, &success, i::LookupIterator::OWN);
4403 0 : if (!success) return i::MaybeHandle<i::Object>();
4404 :
4405 : return i::JSObject::DefineOwnPropertyIgnoreAttributes(
4406 0 : &it, value, attrs, i::JSObject::FORCE_FIELD);
4407 : }
4408 :
4409 :
4410 0 : Maybe<bool> v8::Object::ForceSet(v8::Local<v8::Context> context,
4411 : v8::Local<Value> key, v8::Local<Value> value,
4412 : v8::PropertyAttribute attribs) {
4413 0 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, ForceSet, bool);
4414 0 : auto self = i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
4415 0 : auto key_obj = Utils::OpenHandle(*key);
4416 0 : auto value_obj = Utils::OpenHandle(*value);
4417 : has_pending_exception =
4418 : DefineObjectProperty(self, key_obj, value_obj,
4419 : static_cast<i::PropertyAttributes>(attribs))
4420 0 : .is_null();
4421 0 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4422 : return Just(true);
4423 : }
4424 :
4425 :
4426 0 : bool v8::Object::ForceSet(v8::Local<Value> key, v8::Local<Value> value,
4427 : v8::PropertyAttribute attribs) {
4428 0 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
4429 0 : PREPARE_FOR_EXECUTION_GENERIC(isolate, Local<Context>(), Object, ForceSet,
4430 : false, i::HandleScope, false);
4431 : i::Handle<i::JSObject> self =
4432 0 : i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
4433 0 : i::Handle<i::Object> key_obj = Utils::OpenHandle(*key);
4434 0 : i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
4435 : has_pending_exception =
4436 : DefineObjectProperty(self, key_obj, value_obj,
4437 : static_cast<i::PropertyAttributes>(attribs))
4438 0 : .is_null();
4439 0 : EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, false);
4440 : return true;
4441 : }
4442 :
4443 :
4444 297200 : Maybe<bool> v8::Object::SetPrivate(Local<Context> context, Local<Private> key,
4445 : Local<Value> value) {
4446 1188800 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, SetPrivate, bool);
4447 : auto self = Utils::OpenHandle(this);
4448 : auto key_obj = Utils::OpenHandle(reinterpret_cast<Name*>(*key));
4449 : auto value_obj = Utils::OpenHandle(*value);
4450 297200 : if (self->IsJSProxy()) {
4451 : i::PropertyDescriptor desc;
4452 : desc.set_writable(true);
4453 : desc.set_enumerable(false);
4454 : desc.set_configurable(true);
4455 : desc.set_value(value_obj);
4456 : return i::JSProxy::SetPrivateProperty(
4457 : isolate, i::Handle<i::JSProxy>::cast(self),
4458 21 : i::Handle<i::Symbol>::cast(key_obj), &desc, i::Object::DONT_THROW);
4459 : }
4460 : auto js_object = i::Handle<i::JSObject>::cast(self);
4461 297179 : i::LookupIterator it(js_object, key_obj, js_object);
4462 : has_pending_exception = i::JSObject::DefineOwnPropertyIgnoreAttributes(
4463 : &it, value_obj, i::DONT_ENUM)
4464 594358 : .is_null();
4465 297179 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4466 : return Just(true);
4467 : }
4468 :
4469 :
4470 49487154 : MaybeLocal<Value> v8::Object::Get(Local<v8::Context> context,
4471 : Local<Value> key) {
4472 197948616 : PREPARE_FOR_EXECUTION(context, Object, Get, Value);
4473 : auto self = Utils::OpenHandle(this);
4474 49487154 : auto key_obj = Utils::OpenHandle(*key);
4475 : i::Handle<i::Object> result;
4476 : has_pending_exception =
4477 98974308 : !i::Runtime::GetObjectProperty(isolate, self, key_obj).ToHandle(&result);
4478 49487202 : RETURN_ON_FAILED_EXECUTION(Value);
4479 49487106 : RETURN_ESCAPED(Utils::ToLocal(result));
4480 : }
4481 :
4482 :
4483 0 : Local<Value> v8::Object::Get(v8::Local<Value> key) {
4484 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4485 0 : RETURN_TO_LOCAL_UNCHECKED(Get(context, key), Value);
4486 : }
4487 :
4488 :
4489 71321200 : MaybeLocal<Value> v8::Object::Get(Local<Context> context, uint32_t index) {
4490 285284800 : PREPARE_FOR_EXECUTION(context, Object, Get, Value);
4491 71321200 : auto self = Utils::OpenHandle(this);
4492 : i::Handle<i::Object> result;
4493 : has_pending_exception =
4494 142642400 : !i::JSReceiver::GetElement(isolate, self, index).ToHandle(&result);
4495 71321215 : RETURN_ON_FAILED_EXECUTION(Value);
4496 71321185 : RETURN_ESCAPED(Utils::ToLocal(result));
4497 : }
4498 :
4499 :
4500 0 : Local<Value> v8::Object::Get(uint32_t index) {
4501 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4502 0 : RETURN_TO_LOCAL_UNCHECKED(Get(context, index), Value);
4503 : }
4504 :
4505 :
4506 3781944 : MaybeLocal<Value> v8::Object::GetPrivate(Local<Context> context,
4507 : Local<Private> key) {
4508 3781944 : return Get(context, Local<Value>(reinterpret_cast<Value*>(*key)));
4509 : }
4510 :
4511 :
4512 68 : Maybe<PropertyAttribute> v8::Object::GetPropertyAttributes(
4513 : Local<Context> context, Local<Value> key) {
4514 272 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, GetPropertyAttributes,
4515 : PropertyAttribute);
4516 68 : auto self = Utils::OpenHandle(this);
4517 : auto key_obj = Utils::OpenHandle(*key);
4518 68 : if (!key_obj->IsName()) {
4519 : has_pending_exception =
4520 28 : !i::Object::ToString(isolate, key_obj).ToHandle(&key_obj);
4521 14 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(PropertyAttribute);
4522 : }
4523 61 : auto key_name = i::Handle<i::Name>::cast(key_obj);
4524 61 : auto result = i::JSReceiver::GetPropertyAttributes(self, key_name);
4525 61 : has_pending_exception = result.IsNothing();
4526 61 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(PropertyAttribute);
4527 61 : if (result.FromJust() == i::ABSENT) {
4528 : return Just(static_cast<PropertyAttribute>(i::NONE));
4529 : }
4530 : return Just(static_cast<PropertyAttribute>(result.FromJust()));
4531 : }
4532 :
4533 :
4534 0 : PropertyAttribute v8::Object::GetPropertyAttributes(v8::Local<Value> key) {
4535 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4536 : return GetPropertyAttributes(context, key)
4537 0 : .FromMaybe(static_cast<PropertyAttribute>(i::NONE));
4538 : }
4539 :
4540 :
4541 6900 : MaybeLocal<Value> v8::Object::GetOwnPropertyDescriptor(Local<Context> context,
4542 : Local<String> key) {
4543 27600 : PREPARE_FOR_EXECUTION(context, Object, GetOwnPropertyDescriptor, Value);
4544 6900 : i::Handle<i::JSReceiver> obj = Utils::OpenHandle(this);
4545 : i::Handle<i::String> key_name = Utils::OpenHandle(*key);
4546 :
4547 : i::PropertyDescriptor desc;
4548 : Maybe<bool> found =
4549 6900 : i::JSReceiver::GetOwnPropertyDescriptor(isolate, obj, key_name, &desc);
4550 6900 : has_pending_exception = found.IsNothing();
4551 6900 : RETURN_ON_FAILED_EXECUTION(Value);
4552 6900 : if (!found.FromJust()) {
4553 6 : return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
4554 : }
4555 13788 : RETURN_ESCAPED(Utils::ToLocal(desc.ToObject(isolate)));
4556 : }
4557 :
4558 :
4559 0 : Local<Value> v8::Object::GetOwnPropertyDescriptor(Local<String> key) {
4560 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4561 0 : RETURN_TO_LOCAL_UNCHECKED(GetOwnPropertyDescriptor(context, key), Value);
4562 : }
4563 :
4564 :
4565 7571 : Local<Value> v8::Object::GetPrototype() {
4566 : auto isolate = Utils::OpenHandle(this)->GetIsolate();
4567 7571 : auto self = Utils::OpenHandle(this);
4568 7571 : i::PrototypeIterator iter(isolate, self);
4569 7571 : return Utils::ToLocal(i::PrototypeIterator::GetCurrent(iter));
4570 : }
4571 :
4572 :
4573 3579514 : Maybe<bool> v8::Object::SetPrototype(Local<Context> context,
4574 : Local<Value> value) {
4575 14318056 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, SetPrototype, bool);
4576 3579514 : auto self = Utils::OpenHandle(this);
4577 3579514 : auto value_obj = Utils::OpenHandle(*value);
4578 : // We do not allow exceptions thrown while setting the prototype
4579 : // to propagate outside.
4580 7159028 : TryCatch try_catch(reinterpret_cast<v8::Isolate*>(isolate));
4581 : auto result = i::JSReceiver::SetPrototype(self, value_obj, false,
4582 3579514 : i::Object::THROW_ON_ERROR);
4583 3579514 : has_pending_exception = result.IsNothing();
4584 3579514 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4585 : return Just(true);
4586 : }
4587 :
4588 :
4589 0 : bool v8::Object::SetPrototype(Local<Value> value) {
4590 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4591 0 : return SetPrototype(context, value).FromMaybe(false);
4592 : }
4593 :
4594 63 : Local<Object> v8::Object::FindInstanceInPrototypeChain(
4595 : v8::Local<FunctionTemplate> tmpl) {
4596 : auto self = Utils::OpenHandle(this);
4597 : auto isolate = self->GetIsolate();
4598 : i::PrototypeIterator iter(isolate, *self, i::kStartAtReceiver);
4599 : auto tmpl_info = *Utils::OpenHandle(*tmpl);
4600 189 : while (!tmpl_info->IsTemplateFor(iter.GetCurrent<i::JSObject>())) {
4601 84 : iter.Advance();
4602 84 : if (iter.IsAtEnd()) return Local<Object>();
4603 126 : if (!iter.GetCurrent()->IsJSObject()) return Local<Object>();
4604 : }
4605 : // IsTemplateFor() ensures that iter.GetCurrent() can't be a Proxy here.
4606 42 : return Utils::ToLocal(i::handle(iter.GetCurrent<i::JSObject>(), isolate));
4607 : }
4608 :
4609 9025367 : MaybeLocal<Array> v8::Object::GetPropertyNames(Local<Context> context) {
4610 : return GetPropertyNames(
4611 : context, v8::KeyCollectionMode::kIncludePrototypes,
4612 : static_cast<v8::PropertyFilter>(ONLY_ENUMERABLE | SKIP_SYMBOLS),
4613 9025367 : v8::IndexFilter::kIncludeIndices);
4614 : }
4615 :
4616 9026129 : MaybeLocal<Array> v8::Object::GetPropertyNames(Local<Context> context,
4617 : KeyCollectionMode mode,
4618 : PropertyFilter property_filter,
4619 : IndexFilter index_filter) {
4620 36104516 : PREPARE_FOR_EXECUTION(context, Object, GetPropertyNames, Array);
4621 9026129 : auto self = Utils::OpenHandle(this);
4622 : i::Handle<i::FixedArray> value;
4623 : i::KeyAccumulator accumulator(
4624 : isolate, static_cast<i::KeyCollectionMode>(mode),
4625 9026129 : static_cast<i::PropertyFilter>(property_filter));
4626 9026129 : accumulator.set_skip_indices(index_filter == IndexFilter::kSkipIndices);
4627 9026129 : has_pending_exception = accumulator.CollectKeys(self, self).IsNothing();
4628 9026129 : RETURN_ON_FAILED_EXECUTION(Array);
4629 9026129 : value = accumulator.GetKeys(i::GetKeysConversion::kKeepNumbers);
4630 : DCHECK(self->map()->EnumLength() == i::kInvalidEnumCacheSentinel ||
4631 : self->map()->EnumLength() == 0 ||
4632 : self->map()->instance_descriptors()->GetEnumCache() != *value);
4633 : auto result = isolate->factory()->NewJSArrayWithElements(value);
4634 9026129 : RETURN_ESCAPED(Utils::ToLocal(result));
4635 : }
4636 :
4637 :
4638 0 : Local<Array> v8::Object::GetPropertyNames() {
4639 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4640 0 : RETURN_TO_LOCAL_UNCHECKED(GetPropertyNames(context), Array);
4641 : }
4642 :
4643 685 : MaybeLocal<Array> v8::Object::GetOwnPropertyNames(Local<Context> context) {
4644 : return GetOwnPropertyNames(
4645 685 : context, static_cast<v8::PropertyFilter>(ONLY_ENUMERABLE | SKIP_SYMBOLS));
4646 : }
4647 :
4648 0 : Local<Array> v8::Object::GetOwnPropertyNames() {
4649 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4650 0 : RETURN_TO_LOCAL_UNCHECKED(GetOwnPropertyNames(context), Array);
4651 : }
4652 :
4653 21 : MaybeLocal<Array> v8::Object::GetOwnPropertyNames(Local<Context> context,
4654 : PropertyFilter filter) {
4655 : return GetPropertyNames(context, KeyCollectionMode::kOwnOnly, filter,
4656 706 : v8::IndexFilter::kIncludeIndices);
4657 : }
4658 :
4659 495 : MaybeLocal<String> v8::Object::ObjectProtoToString(Local<Context> context) {
4660 1980 : PREPARE_FOR_EXECUTION(context, Object, ObjectProtoToString, String);
4661 : auto self = Utils::OpenHandle(this);
4662 : Local<Value> result;
4663 : has_pending_exception =
4664 : !ToLocal<Value>(i::Execution::Call(isolate, isolate->object_to_string(),
4665 : self, 0, nullptr),
4666 1485 : &result);
4667 507 : RETURN_ON_FAILED_EXECUTION(String);
4668 483 : RETURN_ESCAPED(Local<String>::Cast(result));
4669 : }
4670 :
4671 :
4672 0 : Local<String> v8::Object::ObjectProtoToString() {
4673 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4674 0 : RETURN_TO_LOCAL_UNCHECKED(ObjectProtoToString(context), String);
4675 : }
4676 :
4677 :
4678 7504192 : Local<String> v8::Object::GetConstructorName() {
4679 7504192 : auto self = Utils::OpenHandle(this);
4680 7504192 : i::Handle<i::String> name = i::JSReceiver::GetConstructorName(self);
4681 7504192 : return Utils::ToLocal(name);
4682 : }
4683 :
4684 7 : Maybe<bool> v8::Object::SetIntegrityLevel(Local<Context> context,
4685 : IntegrityLevel level) {
4686 28 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, SetIntegrityLevel, bool);
4687 7 : auto self = Utils::OpenHandle(this);
4688 : i::JSReceiver::IntegrityLevel i_level =
4689 7 : level == IntegrityLevel::kFrozen ? i::FROZEN : i::SEALED;
4690 : Maybe<bool> result = i::JSReceiver::SetIntegrityLevel(
4691 7 : self, i_level, i::Object::THROW_ON_ERROR);
4692 7 : has_pending_exception = result.IsNothing();
4693 7 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4694 6 : return result;
4695 : }
4696 :
4697 7072 : Maybe<bool> v8::Object::Delete(Local<Context> context, Local<Value> key) {
4698 28288 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, Delete, bool);
4699 7072 : auto self = Utils::OpenHandle(this);
4700 7072 : auto key_obj = Utils::OpenHandle(*key);
4701 : Maybe<bool> result =
4702 7072 : i::Runtime::DeleteObjectProperty(isolate, self, key_obj, i::SLOPPY);
4703 7072 : has_pending_exception = result.IsNothing();
4704 7072 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4705 7072 : return result;
4706 : }
4707 :
4708 :
4709 0 : bool v8::Object::Delete(v8::Local<Value> key) {
4710 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4711 0 : return Delete(context, key).FromMaybe(false);
4712 : }
4713 :
4714 :
4715 49 : Maybe<bool> v8::Object::DeletePrivate(Local<Context> context,
4716 : Local<Private> key) {
4717 49 : return Delete(context, Local<Value>(reinterpret_cast<Value*>(*key)));
4718 : }
4719 :
4720 :
4721 201621 : Maybe<bool> v8::Object::Has(Local<Context> context, Local<Value> key) {
4722 806484 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, Get, bool);
4723 201621 : auto self = Utils::OpenHandle(this);
4724 : auto key_obj = Utils::OpenHandle(*key);
4725 : Maybe<bool> maybe = Nothing<bool>();
4726 : // Check if the given key is an array index.
4727 201621 : uint32_t index = 0;
4728 201621 : if (key_obj->ToArrayIndex(&index)) {
4729 0 : maybe = i::JSReceiver::HasElement(self, index);
4730 : } else {
4731 : // Convert the key to a name - possibly by calling back into JavaScript.
4732 : i::Handle<i::Name> name;
4733 403242 : if (i::Object::ToName(isolate, key_obj).ToHandle(&name)) {
4734 201621 : maybe = i::JSReceiver::HasProperty(self, name);
4735 : }
4736 : }
4737 201621 : has_pending_exception = maybe.IsNothing();
4738 201621 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4739 201621 : return maybe;
4740 : }
4741 :
4742 :
4743 0 : bool v8::Object::Has(v8::Local<Value> key) {
4744 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4745 0 : return Has(context, key).FromMaybe(false);
4746 : }
4747 :
4748 :
4749 10188134 : Maybe<bool> v8::Object::HasPrivate(Local<Context> context, Local<Private> key) {
4750 10188134 : return HasOwnProperty(context, Local<Name>(reinterpret_cast<Name*>(*key)));
4751 : }
4752 :
4753 :
4754 12 : Maybe<bool> v8::Object::Delete(Local<Context> context, uint32_t index) {
4755 48 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, DeleteProperty, bool);
4756 12 : auto self = Utils::OpenHandle(this);
4757 12 : Maybe<bool> result = i::JSReceiver::DeleteElement(self, index);
4758 12 : has_pending_exception = result.IsNothing();
4759 12 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4760 6 : return result;
4761 : }
4762 :
4763 :
4764 0 : bool v8::Object::Delete(uint32_t index) {
4765 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4766 0 : return Delete(context, index).FromMaybe(false);
4767 : }
4768 :
4769 :
4770 35 : Maybe<bool> v8::Object::Has(Local<Context> context, uint32_t index) {
4771 140 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, Get, bool);
4772 35 : auto self = Utils::OpenHandle(this);
4773 35 : auto maybe = i::JSReceiver::HasElement(self, index);
4774 35 : has_pending_exception = maybe.IsNothing();
4775 35 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4776 35 : return maybe;
4777 : }
4778 :
4779 :
4780 0 : bool v8::Object::Has(uint32_t index) {
4781 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4782 0 : return Has(context, index).FromMaybe(false);
4783 : }
4784 :
4785 : template <typename Getter, typename Setter, typename Data>
4786 7065 : static Maybe<bool> ObjectSetAccessor(Local<Context> context, Object* self,
4787 : Local<Name> name, Getter getter,
4788 : Setter setter, Data data,
4789 : AccessControl settings,
4790 : PropertyAttribute attributes,
4791 : bool is_special_data_property) {
4792 28260 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, SetAccessor, bool);
4793 7065 : if (!Utils::OpenHandle(self)->IsJSObject()) return Just(false);
4794 : i::Handle<i::JSObject> obj =
4795 : i::Handle<i::JSObject>::cast(Utils::OpenHandle(self));
4796 : v8::Local<AccessorSignature> signature;
4797 : auto info = MakeAccessorInfo(name, getter, setter, data, settings, attributes,
4798 7065 : signature, is_special_data_property, false);
4799 7065 : if (info.is_null()) return Nothing<bool>();
4800 7065 : bool fast = obj->HasFastProperties();
4801 : i::Handle<i::Object> result;
4802 : has_pending_exception =
4803 14130 : !i::JSObject::SetAccessor(obj, info).ToHandle(&result);
4804 7065 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4805 7059 : if (result->IsUndefined(obj->GetIsolate())) return Just(false);
4806 7030 : if (fast) {
4807 7016 : i::JSObject::MigrateSlowToFast(obj, 0, "APISetAccessor");
4808 : }
4809 : return Just(true);
4810 : }
4811 :
4812 :
4813 7058 : Maybe<bool> Object::SetAccessor(Local<Context> context, Local<Name> name,
4814 : AccessorNameGetterCallback getter,
4815 : AccessorNameSetterCallback setter,
4816 : MaybeLocal<Value> data, AccessControl settings,
4817 : PropertyAttribute attribute) {
4818 : return ObjectSetAccessor(context, this, name, getter, setter,
4819 : data.FromMaybe(Local<Value>()), settings, attribute,
4820 14116 : i::FLAG_disable_old_api_accessors);
4821 : }
4822 :
4823 :
4824 0 : bool Object::SetAccessor(Local<String> name, AccessorGetterCallback getter,
4825 : AccessorSetterCallback setter, v8::Local<Value> data,
4826 : AccessControl settings, PropertyAttribute attributes) {
4827 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4828 : return ObjectSetAccessor(context, this, name, getter, setter, data, settings,
4829 0 : attributes, i::FLAG_disable_old_api_accessors)
4830 0 : .FromMaybe(false);
4831 : }
4832 :
4833 :
4834 0 : bool Object::SetAccessor(Local<Name> name, AccessorNameGetterCallback getter,
4835 : AccessorNameSetterCallback setter,
4836 : v8::Local<Value> data, AccessControl settings,
4837 : PropertyAttribute attributes) {
4838 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4839 : return ObjectSetAccessor(context, this, name, getter, setter, data, settings,
4840 0 : attributes, i::FLAG_disable_old_api_accessors)
4841 0 : .FromMaybe(false);
4842 : }
4843 :
4844 :
4845 211590 : void Object::SetAccessorProperty(Local<Name> name, Local<Function> getter,
4846 : Local<Function> setter,
4847 : PropertyAttribute attribute,
4848 : AccessControl settings) {
4849 : // TODO(verwaest): Remove |settings|.
4850 : DCHECK_EQ(v8::DEFAULT, settings);
4851 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
4852 : ENTER_V8(isolate);
4853 : i::HandleScope scope(isolate);
4854 : auto self = Utils::OpenHandle(this);
4855 423182 : if (!self->IsJSObject()) return;
4856 : i::Handle<i::Object> getter_i = v8::Utils::OpenHandle(*getter);
4857 : i::Handle<i::Object> setter_i = v8::Utils::OpenHandle(*setter, true);
4858 211591 : if (setter_i.is_null()) setter_i = isolate->factory()->null_value();
4859 : i::JSObject::DefineAccessor(i::Handle<i::JSObject>::cast(self),
4860 : v8::Utils::OpenHandle(*name), getter_i, setter_i,
4861 211591 : static_cast<i::PropertyAttributes>(attribute));
4862 : }
4863 :
4864 7 : Maybe<bool> Object::SetNativeDataProperty(v8::Local<v8::Context> context,
4865 : v8::Local<Name> name,
4866 : AccessorNameGetterCallback getter,
4867 : AccessorNameSetterCallback setter,
4868 : v8::Local<Value> data,
4869 : PropertyAttribute attributes) {
4870 : return ObjectSetAccessor(context, this, name, getter, setter, data, DEFAULT,
4871 7 : attributes, true);
4872 : }
4873 :
4874 10188272 : Maybe<bool> v8::Object::HasOwnProperty(Local<Context> context,
4875 : Local<Name> key) {
4876 40753088 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, HasOwnProperty, bool);
4877 10188272 : auto self = Utils::OpenHandle(this);
4878 10188272 : auto key_val = Utils::OpenHandle(*key);
4879 10188272 : auto result = i::JSReceiver::HasOwnProperty(self, key_val);
4880 10188272 : has_pending_exception = result.IsNothing();
4881 10188272 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4882 10188266 : return result;
4883 : }
4884 :
4885 30 : Maybe<bool> v8::Object::HasOwnProperty(Local<Context> context, uint32_t index) {
4886 120 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, HasOwnProperty, bool);
4887 30 : auto self = Utils::OpenHandle(this);
4888 30 : auto result = i::JSReceiver::HasOwnProperty(self, index);
4889 30 : has_pending_exception = result.IsNothing();
4890 30 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4891 30 : return result;
4892 : }
4893 :
4894 0 : bool v8::Object::HasOwnProperty(Local<String> key) {
4895 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4896 0 : return HasOwnProperty(context, key).FromMaybe(false);
4897 : }
4898 :
4899 :
4900 66900019 : Maybe<bool> v8::Object::HasRealNamedProperty(Local<Context> context,
4901 : Local<Name> key) {
4902 267600076 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, HasRealNamedProperty, bool);
4903 : auto self = Utils::OpenHandle(this);
4904 66900019 : if (!self->IsJSObject()) return Just(false);
4905 66900019 : auto key_val = Utils::OpenHandle(*key);
4906 : auto result = i::JSObject::HasRealNamedProperty(
4907 66900019 : i::Handle<i::JSObject>::cast(self), key_val);
4908 66900019 : has_pending_exception = result.IsNothing();
4909 66900019 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4910 66900013 : return result;
4911 : }
4912 :
4913 :
4914 0 : bool v8::Object::HasRealNamedProperty(Local<String> key) {
4915 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4916 0 : return HasRealNamedProperty(context, key).FromMaybe(false);
4917 : }
4918 :
4919 :
4920 20 : Maybe<bool> v8::Object::HasRealIndexedProperty(Local<Context> context,
4921 : uint32_t index) {
4922 80 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, HasRealIndexedProperty,
4923 : bool);
4924 : auto self = Utils::OpenHandle(this);
4925 20 : if (!self->IsJSObject()) return Just(false);
4926 : auto result = i::JSObject::HasRealElementProperty(
4927 20 : i::Handle<i::JSObject>::cast(self), index);
4928 20 : has_pending_exception = result.IsNothing();
4929 20 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4930 14 : return result;
4931 : }
4932 :
4933 :
4934 0 : bool v8::Object::HasRealIndexedProperty(uint32_t index) {
4935 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4936 0 : return HasRealIndexedProperty(context, index).FromMaybe(false);
4937 : }
4938 :
4939 :
4940 6 : Maybe<bool> v8::Object::HasRealNamedCallbackProperty(Local<Context> context,
4941 : Local<Name> key) {
4942 24 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Object, HasRealNamedCallbackProperty,
4943 : bool);
4944 : auto self = Utils::OpenHandle(this);
4945 6 : if (!self->IsJSObject()) return Just(false);
4946 6 : auto key_val = Utils::OpenHandle(*key);
4947 : auto result = i::JSObject::HasRealNamedCallbackProperty(
4948 6 : i::Handle<i::JSObject>::cast(self), key_val);
4949 6 : has_pending_exception = result.IsNothing();
4950 6 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
4951 0 : return result;
4952 : }
4953 :
4954 :
4955 0 : bool v8::Object::HasRealNamedCallbackProperty(Local<String> key) {
4956 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
4957 0 : return HasRealNamedCallbackProperty(context, key).FromMaybe(false);
4958 : }
4959 :
4960 :
4961 0 : bool v8::Object::HasNamedLookupInterceptor() {
4962 : auto self = Utils::OpenHandle(this);
4963 0 : return self->IsJSObject() &&
4964 0 : i::Handle<i::JSObject>::cast(self)->HasNamedInterceptor();
4965 : }
4966 :
4967 :
4968 0 : bool v8::Object::HasIndexedLookupInterceptor() {
4969 : auto self = Utils::OpenHandle(this);
4970 0 : return self->IsJSObject() &&
4971 0 : i::Handle<i::JSObject>::cast(self)->HasIndexedInterceptor();
4972 : }
4973 :
4974 :
4975 7 : MaybeLocal<Value> v8::Object::GetRealNamedPropertyInPrototypeChain(
4976 : Local<Context> context, Local<Name> key) {
4977 28 : PREPARE_FOR_EXECUTION(context, Object, GetRealNamedPropertyInPrototypeChain,
4978 : Value);
4979 : i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
4980 7 : if (!self->IsJSObject()) return MaybeLocal<Value>();
4981 7 : i::Handle<i::Name> key_obj = Utils::OpenHandle(*key);
4982 7 : i::PrototypeIterator iter(isolate, self);
4983 7 : if (iter.IsAtEnd()) return MaybeLocal<Value>();
4984 : i::Handle<i::JSReceiver> proto =
4985 7 : i::PrototypeIterator::GetCurrent<i::JSReceiver>(iter);
4986 : i::LookupIterator it = i::LookupIterator::PropertyOrElement(
4987 : isolate, self, key_obj, proto,
4988 7 : i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
4989 : Local<Value> result;
4990 14 : has_pending_exception = !ToLocal<Value>(i::Object::GetProperty(&it), &result);
4991 14 : RETURN_ON_FAILED_EXECUTION(Value);
4992 0 : if (!it.IsFound()) return MaybeLocal<Value>();
4993 0 : RETURN_ESCAPED(result);
4994 : }
4995 :
4996 :
4997 0 : Local<Value> v8::Object::GetRealNamedPropertyInPrototypeChain(
4998 : Local<String> key) {
4999 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5000 0 : RETURN_TO_LOCAL_UNCHECKED(GetRealNamedPropertyInPrototypeChain(context, key),
5001 : Value);
5002 : }
5003 :
5004 :
5005 : Maybe<PropertyAttribute>
5006 7 : v8::Object::GetRealNamedPropertyAttributesInPrototypeChain(
5007 : Local<Context> context, Local<Name> key) {
5008 28 : PREPARE_FOR_EXECUTION_PRIMITIVE(
5009 : context, Object, GetRealNamedPropertyAttributesInPrototypeChain,
5010 : PropertyAttribute);
5011 : i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
5012 7 : if (!self->IsJSObject()) return Nothing<PropertyAttribute>();
5013 7 : i::Handle<i::Name> key_obj = Utils::OpenHandle(*key);
5014 7 : i::PrototypeIterator iter(isolate, self);
5015 7 : if (iter.IsAtEnd()) return Nothing<PropertyAttribute>();
5016 : i::Handle<i::JSReceiver> proto =
5017 7 : i::PrototypeIterator::GetCurrent<i::JSReceiver>(iter);
5018 : i::LookupIterator it = i::LookupIterator::PropertyOrElement(
5019 : isolate, self, key_obj, proto,
5020 7 : i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
5021 : Maybe<i::PropertyAttributes> result =
5022 7 : i::JSReceiver::GetPropertyAttributes(&it);
5023 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(PropertyAttribute);
5024 7 : if (!it.IsFound()) return Nothing<PropertyAttribute>();
5025 7 : if (result.FromJust() == i::ABSENT) return Just(None);
5026 : return Just(static_cast<PropertyAttribute>(result.FromJust()));
5027 : }
5028 :
5029 :
5030 : Maybe<PropertyAttribute>
5031 0 : v8::Object::GetRealNamedPropertyAttributesInPrototypeChain(Local<String> key) {
5032 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5033 0 : return GetRealNamedPropertyAttributesInPrototypeChain(context, key);
5034 : }
5035 :
5036 :
5037 80 : MaybeLocal<Value> v8::Object::GetRealNamedProperty(Local<Context> context,
5038 : Local<Name> key) {
5039 320 : PREPARE_FOR_EXECUTION(context, Object, GetRealNamedProperty, Value);
5040 : auto self = Utils::OpenHandle(this);
5041 80 : auto key_obj = Utils::OpenHandle(*key);
5042 : i::LookupIterator it = i::LookupIterator::PropertyOrElement(
5043 : isolate, self, key_obj, self,
5044 80 : i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
5045 : Local<Value> result;
5046 160 : has_pending_exception = !ToLocal<Value>(i::Object::GetProperty(&it), &result);
5047 101 : RETURN_ON_FAILED_EXECUTION(Value);
5048 59 : if (!it.IsFound()) return MaybeLocal<Value>();
5049 45 : RETURN_ESCAPED(result);
5050 : }
5051 :
5052 :
5053 0 : Local<Value> v8::Object::GetRealNamedProperty(Local<String> key) {
5054 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5055 0 : RETURN_TO_LOCAL_UNCHECKED(GetRealNamedProperty(context, key), Value);
5056 : }
5057 :
5058 :
5059 21 : Maybe<PropertyAttribute> v8::Object::GetRealNamedPropertyAttributes(
5060 : Local<Context> context, Local<Name> key) {
5061 84 : PREPARE_FOR_EXECUTION_PRIMITIVE(
5062 : context, Object, GetRealNamedPropertyAttributes, PropertyAttribute);
5063 : auto self = Utils::OpenHandle(this);
5064 21 : auto key_obj = Utils::OpenHandle(*key);
5065 : i::LookupIterator it = i::LookupIterator::PropertyOrElement(
5066 : isolate, self, key_obj, self,
5067 21 : i::LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
5068 21 : auto result = i::JSReceiver::GetPropertyAttributes(&it);
5069 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(PropertyAttribute);
5070 21 : if (!it.IsFound()) return Nothing<PropertyAttribute>();
5071 21 : if (result.FromJust() == i::ABSENT) {
5072 : return Just(static_cast<PropertyAttribute>(i::NONE));
5073 : }
5074 : return Just<PropertyAttribute>(
5075 : static_cast<PropertyAttribute>(result.FromJust()));
5076 : }
5077 :
5078 :
5079 0 : Maybe<PropertyAttribute> v8::Object::GetRealNamedPropertyAttributes(
5080 : Local<String> key) {
5081 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5082 0 : return GetRealNamedPropertyAttributes(context, key);
5083 : }
5084 :
5085 :
5086 19 : Local<v8::Object> v8::Object::Clone() {
5087 : auto self = i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
5088 : auto isolate = self->GetIsolate();
5089 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
5090 19 : auto result = isolate->factory()->CopyJSObject(self);
5091 19 : CHECK(!result.is_null());
5092 19 : return Utils::ToLocal(result);
5093 : }
5094 :
5095 :
5096 479 : Local<v8::Context> v8::Object::CreationContext() {
5097 : auto self = Utils::OpenHandle(this);
5098 479 : return Utils::ToLocal(self->GetCreationContext());
5099 : }
5100 :
5101 :
5102 124 : int v8::Object::GetIdentityHash() {
5103 : auto isolate = Utils::OpenHandle(this)->GetIsolate();
5104 : i::HandleScope scope(isolate);
5105 124 : auto self = Utils::OpenHandle(this);
5106 248 : return i::JSReceiver::GetOrCreateIdentityHash(isolate, self)->value();
5107 : }
5108 :
5109 :
5110 28 : bool v8::Object::IsCallable() {
5111 : auto self = Utils::OpenHandle(this);
5112 28 : return self->IsCallable();
5113 : }
5114 :
5115 7 : bool v8::Object::IsConstructor() {
5116 : auto self = Utils::OpenHandle(this);
5117 7 : return self->IsConstructor();
5118 : }
5119 :
5120 126 : MaybeLocal<Value> Object::CallAsFunction(Local<Context> context,
5121 : Local<Value> recv, int argc,
5122 : Local<Value> argv[]) {
5123 756 : PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE(
5124 : "v8", "V8.Execute", context, Object, CallAsFunction, MaybeLocal<Value>(),
5125 : InternalEscapableScope, true);
5126 : i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
5127 : auto self = Utils::OpenHandle(this);
5128 126 : auto recv_obj = Utils::OpenHandle(*recv);
5129 : STATIC_ASSERT(sizeof(v8::Local<v8::Value>) == sizeof(i::Object**));
5130 : i::Handle<i::Object>* args = reinterpret_cast<i::Handle<i::Object>*>(argv);
5131 : Local<Value> result;
5132 : has_pending_exception = !ToLocal<Value>(
5133 252 : i::Execution::Call(isolate, self, recv_obj, argc, args), &result);
5134 140 : RETURN_ON_FAILED_EXECUTION(Value);
5135 238 : RETURN_ESCAPED(result);
5136 : }
5137 :
5138 :
5139 0 : Local<v8::Value> Object::CallAsFunction(v8::Local<v8::Value> recv, int argc,
5140 : v8::Local<v8::Value> argv[]) {
5141 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5142 : Local<Value>* argv_cast = reinterpret_cast<Local<Value>*>(argv);
5143 0 : RETURN_TO_LOCAL_UNCHECKED(CallAsFunction(context, recv, argc, argv_cast),
5144 : Value);
5145 : }
5146 :
5147 :
5148 63 : MaybeLocal<Value> Object::CallAsConstructor(Local<Context> context, int argc,
5149 : Local<Value> argv[]) {
5150 378 : PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE(
5151 : "v8", "V8.Execute", context, Object, CallAsConstructor,
5152 : MaybeLocal<Value>(), InternalEscapableScope, true);
5153 : i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
5154 : auto self = Utils::OpenHandle(this);
5155 : STATIC_ASSERT(sizeof(v8::Local<v8::Value>) == sizeof(i::Object**));
5156 : i::Handle<i::Object>* args = reinterpret_cast<i::Handle<i::Object>*>(argv);
5157 : Local<Value> result;
5158 : has_pending_exception = !ToLocal<Value>(
5159 126 : i::Execution::New(isolate, self, self, argc, args), &result);
5160 77 : RETURN_ON_FAILED_EXECUTION(Value);
5161 112 : RETURN_ESCAPED(result);
5162 : }
5163 :
5164 :
5165 0 : Local<v8::Value> Object::CallAsConstructor(int argc,
5166 : v8::Local<v8::Value> argv[]) {
5167 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5168 : Local<Value>* argv_cast = reinterpret_cast<Local<Value>*>(argv);
5169 0 : RETURN_TO_LOCAL_UNCHECKED(CallAsConstructor(context, argc, argv_cast), Value);
5170 : }
5171 :
5172 42894 : MaybeLocal<Function> Function::New(Local<Context> context,
5173 : FunctionCallback callback, Local<Value> data,
5174 : int length, ConstructorBehavior behavior) {
5175 42894 : i::Isolate* isolate = Utils::OpenHandle(*context)->GetIsolate();
5176 85788 : LOG_API(isolate, Function, New);
5177 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
5178 : auto templ = FunctionTemplateNew(isolate, callback, data, Local<Signature>(),
5179 42894 : length, true);
5180 42894 : if (behavior == ConstructorBehavior::kThrow) templ->RemovePrototype();
5181 85788 : return templ->GetFunction(context);
5182 : }
5183 :
5184 :
5185 0 : Local<Function> Function::New(Isolate* v8_isolate, FunctionCallback callback,
5186 : Local<Value> data, int length) {
5187 : return Function::New(v8_isolate->GetCurrentContext(), callback, data, length,
5188 0 : ConstructorBehavior::kAllow)
5189 0 : .FromMaybe(Local<Function>());
5190 : }
5191 :
5192 :
5193 0 : Local<v8::Object> Function::NewInstance() const {
5194 0 : return NewInstance(Isolate::GetCurrent()->GetCurrentContext(), 0, NULL)
5195 0 : .FromMaybe(Local<Object>());
5196 : }
5197 :
5198 :
5199 920 : MaybeLocal<Object> Function::NewInstance(Local<Context> context, int argc,
5200 : v8::Local<v8::Value> argv[]) const {
5201 5520 : PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE(
5202 : "v8", "V8.Execute", context, Function, NewInstance, MaybeLocal<Object>(),
5203 : InternalEscapableScope, true);
5204 : i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
5205 : auto self = Utils::OpenHandle(this);
5206 : STATIC_ASSERT(sizeof(v8::Local<v8::Value>) == sizeof(i::Object**));
5207 : i::Handle<i::Object>* args = reinterpret_cast<i::Handle<i::Object>*>(argv);
5208 : Local<Object> result;
5209 : has_pending_exception = !ToLocal<Object>(
5210 1840 : i::Execution::New(isolate, self, self, argc, args), &result);
5211 927 : RETURN_ON_FAILED_EXECUTION(Object);
5212 1833 : RETURN_ESCAPED(result);
5213 : }
5214 :
5215 :
5216 0 : Local<v8::Object> Function::NewInstance(int argc,
5217 : v8::Local<v8::Value> argv[]) const {
5218 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5219 0 : RETURN_TO_LOCAL_UNCHECKED(NewInstance(context, argc, argv), Object);
5220 : }
5221 :
5222 :
5223 29701234 : MaybeLocal<v8::Value> Function::Call(Local<Context> context,
5224 : v8::Local<v8::Value> recv, int argc,
5225 : v8::Local<v8::Value> argv[]) {
5226 178207404 : PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE(
5227 : "v8", "V8.Execute", context, Function, Call, MaybeLocal<Value>(),
5228 : InternalEscapableScope, true);
5229 : i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
5230 : auto self = Utils::OpenHandle(this);
5231 29701234 : i::Handle<i::Object> recv_obj = Utils::OpenHandle(*recv);
5232 : STATIC_ASSERT(sizeof(v8::Local<v8::Value>) == sizeof(i::Object**));
5233 : i::Handle<i::Object>* args = reinterpret_cast<i::Handle<i::Object>*>(argv);
5234 : Local<Value> result;
5235 : has_pending_exception = !ToLocal<Value>(
5236 59402468 : i::Execution::Call(isolate, self, recv_obj, argc, args), &result);
5237 29703127 : RETURN_ON_FAILED_EXECUTION(Value);
5238 59400575 : RETURN_ESCAPED(result);
5239 : }
5240 :
5241 :
5242 0 : Local<v8::Value> Function::Call(v8::Local<v8::Value> recv, int argc,
5243 : v8::Local<v8::Value> argv[]) {
5244 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
5245 0 : RETURN_TO_LOCAL_UNCHECKED(Call(context, recv, argc, argv), Value);
5246 : }
5247 :
5248 :
5249 38073 : void Function::SetName(v8::Local<v8::String> name) {
5250 : auto self = Utils::OpenHandle(this);
5251 76146 : if (!self->IsJSFunction()) return;
5252 : auto func = i::Handle<i::JSFunction>::cast(self);
5253 38073 : func->shared()->set_name(*Utils::OpenHandle(*name));
5254 : }
5255 :
5256 :
5257 44 : Local<Value> Function::GetName() const {
5258 : auto self = Utils::OpenHandle(this);
5259 : i::Isolate* isolate = self->GetIsolate();
5260 44 : if (self->IsJSBoundFunction()) {
5261 0 : auto func = i::Handle<i::JSBoundFunction>::cast(self);
5262 : i::Handle<i::Object> name;
5263 0 : ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, name,
5264 : i::JSBoundFunction::GetName(isolate, func),
5265 : Local<Value>());
5266 : return Utils::ToLocal(name);
5267 : }
5268 44 : if (self->IsJSFunction()) {
5269 : auto func = i::Handle<i::JSFunction>::cast(self);
5270 : return Utils::ToLocal(handle(func->shared()->name(), isolate));
5271 : }
5272 0 : return ToApiHandle<Primitive>(isolate->factory()->undefined_value());
5273 : }
5274 :
5275 :
5276 7 : Local<Value> Function::GetInferredName() const {
5277 : auto self = Utils::OpenHandle(this);
5278 7 : if (!self->IsJSFunction()) {
5279 : return ToApiHandle<Primitive>(
5280 0 : self->GetIsolate()->factory()->undefined_value());
5281 : }
5282 : auto func = i::Handle<i::JSFunction>::cast(self);
5283 7 : return Utils::ToLocal(i::Handle<i::Object>(func->shared()->inferred_name(),
5284 : func->GetIsolate()));
5285 : }
5286 :
5287 :
5288 84 : Local<Value> Function::GetDebugName() const {
5289 : auto self = Utils::OpenHandle(this);
5290 84 : if (!self->IsJSFunction()) {
5291 : return ToApiHandle<Primitive>(
5292 0 : self->GetIsolate()->factory()->undefined_value());
5293 : }
5294 84 : auto func = i::Handle<i::JSFunction>::cast(self);
5295 84 : i::Handle<i::String> name = i::JSFunction::GetDebugName(func);
5296 : return Utils::ToLocal(i::Handle<i::Object>(*name, name->GetIsolate()));
5297 : }
5298 :
5299 :
5300 49 : Local<Value> Function::GetDisplayName() const {
5301 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
5302 : ENTER_V8(isolate);
5303 : auto self = Utils::OpenHandle(this);
5304 49 : if (!self->IsJSFunction()) {
5305 0 : return ToApiHandle<Primitive>(isolate->factory()->undefined_value());
5306 : }
5307 : auto func = i::Handle<i::JSFunction>::cast(self);
5308 : i::Handle<i::String> property_name =
5309 49 : isolate->factory()->NewStringFromStaticChars("displayName");
5310 : i::Handle<i::Object> value =
5311 49 : i::JSReceiver::GetDataProperty(func, property_name);
5312 49 : if (value->IsString()) {
5313 : i::Handle<i::String> name = i::Handle<i::String>::cast(value);
5314 21 : if (name->length() > 0) return Utils::ToLocal(name);
5315 : }
5316 28 : return ToApiHandle<Primitive>(isolate->factory()->undefined_value());
5317 : }
5318 :
5319 :
5320 14 : ScriptOrigin Function::GetScriptOrigin() const {
5321 : auto self = Utils::OpenHandle(this);
5322 14 : if (!self->IsJSFunction()) {
5323 : return v8::ScriptOrigin(Local<Value>());
5324 : }
5325 : auto func = i::Handle<i::JSFunction>::cast(self);
5326 14 : if (func->shared()->script()->IsScript()) {
5327 : i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
5328 14 : return GetScriptOriginForScript(func->GetIsolate(), script);
5329 : }
5330 : return v8::ScriptOrigin(Local<Value>());
5331 : }
5332 :
5333 :
5334 : const int Function::kLineOffsetNotFound = -1;
5335 :
5336 :
5337 7196 : int Function::GetScriptLineNumber() const {
5338 : auto self = Utils::OpenHandle(this);
5339 7196 : if (!self->IsJSFunction()) {
5340 : return kLineOffsetNotFound;
5341 : }
5342 : auto func = i::Handle<i::JSFunction>::cast(self);
5343 7190 : if (func->shared()->script()->IsScript()) {
5344 : i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
5345 7190 : return i::Script::GetLineNumber(script, func->shared()->start_position());
5346 : }
5347 : return kLineOffsetNotFound;
5348 : }
5349 :
5350 :
5351 196 : int Function::GetScriptColumnNumber() const {
5352 : auto self = Utils::OpenHandle(this);
5353 196 : if (!self->IsJSFunction()) {
5354 : return kLineOffsetNotFound;
5355 : }
5356 : auto func = i::Handle<i::JSFunction>::cast(self);
5357 190 : if (func->shared()->script()->IsScript()) {
5358 : i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
5359 190 : return i::Script::GetColumnNumber(script, func->shared()->start_position());
5360 : }
5361 : return kLineOffsetNotFound;
5362 : }
5363 :
5364 :
5365 0 : bool Function::IsBuiltin() const {
5366 : auto self = Utils::OpenHandle(this);
5367 0 : if (!self->IsJSFunction()) {
5368 : return false;
5369 : }
5370 : auto func = i::Handle<i::JSFunction>::cast(self);
5371 0 : return !func->shared()->IsUserJavaScript();
5372 : }
5373 :
5374 :
5375 9080 : int Function::ScriptId() const {
5376 : auto self = Utils::OpenHandle(this);
5377 9080 : if (!self->IsJSFunction()) {
5378 : return v8::UnboundScript::kNoScriptId;
5379 : }
5380 : auto func = i::Handle<i::JSFunction>::cast(self);
5381 9074 : if (!func->shared()->script()->IsScript()) {
5382 : return v8::UnboundScript::kNoScriptId;
5383 : }
5384 : i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
5385 8990 : return script->id();
5386 : }
5387 :
5388 :
5389 272 : Local<v8::Value> Function::GetBoundFunction() const {
5390 : auto self = Utils::OpenHandle(this);
5391 272 : if (self->IsJSBoundFunction()) {
5392 : auto bound_function = i::Handle<i::JSBoundFunction>::cast(self);
5393 : auto bound_target_function = i::handle(
5394 : bound_function->bound_target_function(), bound_function->GetIsolate());
5395 122 : return Utils::CallableToLocal(bound_target_function);
5396 : }
5397 150 : return v8::Undefined(reinterpret_cast<v8::Isolate*>(self->GetIsolate()));
5398 : }
5399 :
5400 60 : int Name::GetIdentityHash() {
5401 : auto self = Utils::OpenHandle(this);
5402 60 : return static_cast<int>(self->Hash());
5403 : }
5404 :
5405 :
5406 200254204 : int String::Length() const {
5407 : i::Handle<i::String> str = Utils::OpenHandle(this);
5408 200254204 : return str->length();
5409 : }
5410 :
5411 :
5412 80 : bool String::IsOneByte() const {
5413 : i::Handle<i::String> str = Utils::OpenHandle(this);
5414 80 : return str->HasOnlyOneByteChars();
5415 : }
5416 :
5417 :
5418 : // Helpers for ContainsOnlyOneByteHelper
5419 : template<size_t size> struct OneByteMask;
5420 : template<> struct OneByteMask<4> {
5421 : static const uint32_t value = 0xFF00FF00;
5422 : };
5423 : template<> struct OneByteMask<8> {
5424 : static const uint64_t value = V8_2PART_UINT64_C(0xFF00FF00, FF00FF00);
5425 : };
5426 : static const uintptr_t kOneByteMask = OneByteMask<sizeof(uintptr_t)>::value;
5427 : static const uintptr_t kAlignmentMask = sizeof(uintptr_t) - 1;
5428 : static inline bool Unaligned(const uint16_t* chars) {
5429 55098 : return reinterpret_cast<const uintptr_t>(chars) & kAlignmentMask;
5430 : }
5431 :
5432 :
5433 : static inline const uint16_t* Align(const uint16_t* chars) {
5434 : return reinterpret_cast<uint16_t*>(
5435 21462 : reinterpret_cast<uintptr_t>(chars) & ~kAlignmentMask);
5436 : }
5437 :
5438 : class ContainsOnlyOneByteHelper {
5439 : public:
5440 21462 : ContainsOnlyOneByteHelper() : is_one_byte_(true) {}
5441 21462 : bool Check(i::String* string) {
5442 21462 : i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
5443 21462 : if (cons_string == NULL) return is_one_byte_;
5444 36 : return CheckCons(cons_string);
5445 : }
5446 : void VisitOneByteString(const uint8_t* chars, int length) {
5447 : // Nothing to do.
5448 : }
5449 21462 : void VisitTwoByteString(const uint16_t* chars, int length) {
5450 : // Accumulated bits.
5451 : uintptr_t acc = 0;
5452 : // Align to uintptr_t.
5453 21462 : const uint16_t* end = chars + length;
5454 76560 : while (Unaligned(chars) && chars != end) {
5455 33636 : acc |= *chars++;
5456 : }
5457 : // Read word aligned in blocks,
5458 : // checking the return value at the end of each block.
5459 : const uint16_t* aligned_end = Align(end);
5460 : const int increment = sizeof(uintptr_t)/sizeof(uint16_t);
5461 : const int inner_loops = 16;
5462 61770 : while (chars + inner_loops*increment < aligned_end) {
5463 475680 : for (int i = 0; i < inner_loops; i++) {
5464 475680 : acc |= *reinterpret_cast<const uintptr_t*>(chars);
5465 475680 : chars += increment;
5466 : }
5467 : // Check for early return.
5468 29730 : if ((acc & kOneByteMask) != 0) {
5469 10884 : is_one_byte_ = false;
5470 32346 : return;
5471 : }
5472 : }
5473 : // Read the rest.
5474 561744 : while (chars != end) {
5475 551166 : acc |= *chars++;
5476 : }
5477 : // Check result.
5478 10578 : if ((acc & kOneByteMask) != 0) is_one_byte_ = false;
5479 : }
5480 :
5481 : private:
5482 48 : bool CheckCons(i::ConsString* cons_string) {
5483 : while (true) {
5484 : // Check left side if flat.
5485 : i::String* left = cons_string->first();
5486 : i::ConsString* left_as_cons =
5487 47532 : i::String::VisitFlat(this, left, 0);
5488 47532 : if (!is_one_byte_) return false;
5489 : // Check right side if flat.
5490 : i::String* right = cons_string->second();
5491 : i::ConsString* right_as_cons =
5492 47532 : i::String::VisitFlat(this, right, 0);
5493 47532 : if (!is_one_byte_) return false;
5494 : // Standard recurse/iterate trick.
5495 47532 : if (left_as_cons != NULL && right_as_cons != NULL) {
5496 12 : if (left->length() < right->length()) {
5497 0 : CheckCons(left_as_cons);
5498 : cons_string = right_as_cons;
5499 : } else {
5500 12 : CheckCons(right_as_cons);
5501 : cons_string = left_as_cons;
5502 : }
5503 : // Check fast return.
5504 12 : if (!is_one_byte_) return false;
5505 : continue;
5506 : }
5507 : // Descend left in place.
5508 47520 : if (left_as_cons != NULL) {
5509 : cons_string = left_as_cons;
5510 : continue;
5511 : }
5512 : // Descend right in place.
5513 23778 : if (right_as_cons != NULL) {
5514 : cons_string = right_as_cons;
5515 : continue;
5516 : }
5517 : // Terminate.
5518 : break;
5519 : }
5520 : return is_one_byte_;
5521 : }
5522 : bool is_one_byte_;
5523 : DISALLOW_COPY_AND_ASSIGN(ContainsOnlyOneByteHelper);
5524 : };
5525 :
5526 :
5527 21486 : bool String::ContainsOnlyOneByte() const {
5528 : i::Handle<i::String> str = Utils::OpenHandle(this);
5529 21486 : if (str->HasOnlyOneByteChars()) return true;
5530 : ContainsOnlyOneByteHelper helper;
5531 21462 : return helper.Check(*str);
5532 : }
5533 :
5534 :
5535 : class Utf8LengthHelper : public i::AllStatic {
5536 : public:
5537 : enum State {
5538 : kEndsWithLeadingSurrogate = 1 << 0,
5539 : kStartsWithTrailingSurrogate = 1 << 1,
5540 : kLeftmostEdgeIsCalculated = 1 << 2,
5541 : kRightmostEdgeIsCalculated = 1 << 3,
5542 : kLeftmostEdgeIsSurrogate = 1 << 4,
5543 : kRightmostEdgeIsSurrogate = 1 << 5
5544 : };
5545 :
5546 : static const uint8_t kInitialState = 0;
5547 :
5548 : static inline bool EndsWithSurrogate(uint8_t state) {
5549 1803845 : return state & kEndsWithLeadingSurrogate;
5550 : }
5551 :
5552 : static inline bool StartsWithSurrogate(uint8_t state) {
5553 1222559 : return state & kStartsWithTrailingSurrogate;
5554 : }
5555 :
5556 : class Visitor {
5557 : public:
5558 13598229 : Visitor() : utf8_length_(0), state_(kInitialState) {}
5559 :
5560 : void VisitOneByteString(const uint8_t* chars, int length) {
5561 : int utf8_length = 0;
5562 : // Add in length 1 for each non-Latin1 character.
5563 112517937 : for (int i = 0; i < length; i++) {
5564 112517937 : utf8_length += *chars++ >> 7;
5565 : }
5566 : // Add in length 1 for each character.
5567 12162713 : utf8_length_ = utf8_length + length;
5568 12162713 : state_ = kInitialState;
5569 : }
5570 :
5571 441474 : void VisitTwoByteString(const uint16_t* chars, int length) {
5572 : int utf8_length = 0;
5573 : int last_character = unibrow::Utf16::kNoPreviousCharacter;
5574 4030694 : for (int i = 0; i < length; i++) {
5575 3589220 : uint16_t c = chars[i];
5576 3589220 : utf8_length += unibrow::Utf8::Length(c, last_character);
5577 3589220 : last_character = c;
5578 : }
5579 441474 : utf8_length_ = utf8_length;
5580 : uint8_t state = 0;
5581 882948 : if (unibrow::Utf16::IsTrailSurrogate(chars[0])) {
5582 : state |= kStartsWithTrailingSurrogate;
5583 : }
5584 882948 : if (unibrow::Utf16::IsLeadSurrogate(chars[length-1])) {
5585 476 : state |= kEndsWithLeadingSurrogate;
5586 : }
5587 441474 : state_ = state;
5588 441474 : }
5589 :
5590 : static i::ConsString* VisitFlat(i::String* string,
5591 : int* length,
5592 : uint8_t* state) {
5593 : Visitor visitor;
5594 13598229 : i::ConsString* cons_string = i::String::VisitFlat(&visitor, string);
5595 13598229 : *length = visitor.utf8_length_;
5596 1988084 : *state = visitor.state_;
5597 : return cons_string;
5598 : }
5599 :
5600 : private:
5601 : int utf8_length_;
5602 : uint8_t state_;
5603 : DISALLOW_COPY_AND_ASSIGN(Visitor);
5604 : };
5605 :
5606 581475 : static inline void MergeLeafLeft(int* length,
5607 : uint8_t* state,
5608 : uint8_t leaf_state) {
5609 : bool edge_surrogate = StartsWithSurrogate(leaf_state);
5610 581475 : if (!(*state & kLeftmostEdgeIsCalculated)) {
5611 : DCHECK(!(*state & kLeftmostEdgeIsSurrogate));
5612 : *state |= kLeftmostEdgeIsCalculated
5613 228328 : | (edge_surrogate ? kLeftmostEdgeIsSurrogate : 0);
5614 353147 : } else if (EndsWithSurrogate(*state) && edge_surrogate) {
5615 14 : *length -= unibrow::Utf8::kBytesSavedByCombiningSurrogates;
5616 : }
5617 581475 : if (EndsWithSurrogate(leaf_state)) {
5618 210 : *state |= kEndsWithLeadingSurrogate;
5619 : } else {
5620 581265 : *state &= ~kEndsWithLeadingSurrogate;
5621 : }
5622 581475 : }
5623 :
5624 640895 : static inline void MergeLeafRight(int* length,
5625 : uint8_t* state,
5626 : uint8_t leaf_state) {
5627 : bool edge_surrogate = EndsWithSurrogate(leaf_state);
5628 640895 : if (!(*state & kRightmostEdgeIsCalculated)) {
5629 : DCHECK(!(*state & kRightmostEdgeIsSurrogate));
5630 : *state |= (kRightmostEdgeIsCalculated
5631 228328 : | (edge_surrogate ? kRightmostEdgeIsSurrogate : 0));
5632 412623 : } else if (edge_surrogate && StartsWithSurrogate(*state)) {
5633 21 : *length -= unibrow::Utf8::kBytesSavedByCombiningSurrogates;
5634 : }
5635 640895 : if (StartsWithSurrogate(leaf_state)) {
5636 238 : *state |= kStartsWithTrailingSurrogate;
5637 : } else {
5638 640657 : *state &= ~kStartsWithTrailingSurrogate;
5639 : }
5640 640895 : }
5641 :
5642 228328 : static inline void MergeTerminal(int* length,
5643 : uint8_t state,
5644 : uint8_t* state_out) {
5645 : DCHECK((state & kLeftmostEdgeIsCalculated) &&
5646 : (state & kRightmostEdgeIsCalculated));
5647 228461 : if (EndsWithSurrogate(state) && StartsWithSurrogate(state)) {
5648 0 : *length -= unibrow::Utf8::kBytesSavedByCombiningSurrogates;
5649 : }
5650 : *state_out = kInitialState |
5651 228328 : (state & kLeftmostEdgeIsSurrogate ? kStartsWithTrailingSurrogate : 0) |
5652 228328 : (state & kRightmostEdgeIsSurrogate ? kEndsWithLeadingSurrogate : 0);
5653 228328 : }
5654 :
5655 228328 : static int Calculate(i::ConsString* current, uint8_t* state_out) {
5656 : using internal::ConsString;
5657 228328 : int total_length = 0;
5658 228328 : uint8_t state = kInitialState;
5659 : while (true) {
5660 : i::String* left = current->first();
5661 : i::String* right = current->second();
5662 : uint8_t right_leaf_state;
5663 : uint8_t left_leaf_state;
5664 : int leaf_length;
5665 : ConsString* left_as_cons =
5666 : Visitor::VisitFlat(left, &leaf_length, &left_leaf_state);
5667 994042 : if (left_as_cons == NULL) {
5668 578381 : total_length += leaf_length;
5669 578381 : MergeLeafLeft(&total_length, &state, left_leaf_state);
5670 : }
5671 : ConsString* right_as_cons =
5672 : Visitor::VisitFlat(right, &leaf_length, &right_leaf_state);
5673 994042 : if (right_as_cons == NULL) {
5674 639165 : total_length += leaf_length;
5675 639165 : MergeLeafRight(&total_length, &state, right_leaf_state);
5676 639165 : if (left_as_cons != NULL) {
5677 : // 1 Leaf node. Descend in place.
5678 : current = left_as_cons;
5679 760890 : continue;
5680 : } else {
5681 : // Terminal node.
5682 228328 : MergeTerminal(&total_length, state, state_out);
5683 228328 : return total_length;
5684 : }
5685 354877 : } else if (left_as_cons == NULL) {
5686 : // 1 Leaf node. Descend in place.
5687 : current = right_as_cons;
5688 : continue;
5689 : }
5690 : // Both strings are ConsStrings.
5691 : // Recurse on smallest.
5692 4824 : if (left->length() < right->length()) {
5693 3094 : total_length += Calculate(left_as_cons, &left_leaf_state);
5694 3094 : MergeLeafLeft(&total_length, &state, left_leaf_state);
5695 : current = right_as_cons;
5696 : } else {
5697 1730 : total_length += Calculate(right_as_cons, &right_leaf_state);
5698 1730 : MergeLeafRight(&total_length, &state, right_leaf_state);
5699 : current = left_as_cons;
5700 : }
5701 : }
5702 : UNREACHABLE();
5703 : return 0;
5704 : }
5705 :
5706 : static inline int Calculate(i::ConsString* current) {
5707 223504 : uint8_t state = kInitialState;
5708 223504 : return Calculate(current, &state);
5709 : }
5710 :
5711 : private:
5712 : DISALLOW_IMPLICIT_CONSTRUCTORS(Utf8LengthHelper);
5713 : };
5714 :
5715 :
5716 11617265 : static int Utf8Length(i::String* str, i::Isolate* isolate) {
5717 : int length = str->length();
5718 11617265 : if (length == 0) return 0;
5719 : uint8_t state;
5720 : i::ConsString* cons_string =
5721 : Utf8LengthHelper::Visitor::VisitFlat(str, &length, &state);
5722 11610145 : if (cons_string == NULL) return length;
5723 : return Utf8LengthHelper::Calculate(cons_string);
5724 : }
5725 :
5726 :
5727 670 : int String::Utf8Length() const {
5728 : i::Handle<i::String> str = Utils::OpenHandle(this);
5729 : i::Isolate* isolate = str->GetIsolate();
5730 670 : return v8::Utf8Length(*str, isolate);
5731 : }
5732 :
5733 :
5734 : class Utf8WriterVisitor {
5735 : public:
5736 : Utf8WriterVisitor(
5737 : char* buffer,
5738 : int capacity,
5739 : bool skip_capacity_check,
5740 : bool replace_invalid_utf8)
5741 : : early_termination_(false),
5742 : last_character_(unibrow::Utf16::kNoPreviousCharacter),
5743 : buffer_(buffer),
5744 : start_(buffer),
5745 : capacity_(capacity),
5746 123 : skip_capacity_check_(capacity == -1 || skip_capacity_check),
5747 : replace_invalid_utf8_(replace_invalid_utf8),
5748 11616907 : utf16_chars_read_(0) {
5749 : }
5750 :
5751 260 : static int WriteEndCharacter(uint16_t character,
5752 : int last_character,
5753 : int remaining,
5754 : char* const buffer,
5755 : bool replace_invalid_utf8) {
5756 : DCHECK_GT(remaining, 0);
5757 : // We can't use a local buffer here because Encode needs to modify
5758 : // previous characters in the stream. We know, however, that
5759 : // exactly one character will be advanced.
5760 520 : if (unibrow::Utf16::IsSurrogatePair(last_character, character)) {
5761 : int written = unibrow::Utf8::Encode(buffer, character, last_character,
5762 0 : replace_invalid_utf8);
5763 : DCHECK_EQ(written, 1);
5764 0 : return written;
5765 : }
5766 : // Use a scratch buffer to check the required characters.
5767 : char temp_buffer[unibrow::Utf8::kMaxEncodedSize];
5768 : // Can't encode using last_character as gcc has array bounds issues.
5769 : int written = unibrow::Utf8::Encode(temp_buffer, character,
5770 : unibrow::Utf16::kNoPreviousCharacter,
5771 260 : replace_invalid_utf8);
5772 : // Won't fit.
5773 260 : if (written > remaining) return 0;
5774 : // Copy over the character from temp_buffer.
5775 290 : for (int j = 0; j < written; j++) {
5776 290 : buffer[j] = temp_buffer[j];
5777 : }
5778 : return written;
5779 : }
5780 :
5781 : // Visit writes out a group of code units (chars) of a v8::String to the
5782 : // internal buffer_. This is done in two phases. The first phase calculates a
5783 : // pesimistic estimate (writable_length) on how many code units can be safely
5784 : // written without exceeding the buffer capacity and without writing the last
5785 : // code unit (it could be a lead surrogate). The estimated number of code
5786 : // units is then written out in one go, and the reported byte usage is used
5787 : // to correct the estimate. This is repeated until the estimate becomes <= 0
5788 : // or all code units have been written out. The second phase writes out code
5789 : // units until the buffer capacity is reached, would be exceeded by the next
5790 : // unit, or all units have been written out.
5791 : template<typename Char>
5792 12319647 : void Visit(const Char* chars, const int length) {
5793 : DCHECK(!early_termination_);
5794 12319647 : if (length == 0) return;
5795 : // Copy state to stack.
5796 12310935 : char* buffer = buffer_;
5797 : int last_character = sizeof(Char) == 1
5798 : ? unibrow::Utf16::kNoPreviousCharacter
5799 151656 : : last_character_;
5800 : int i = 0;
5801 : // Do a fast loop where there is no exit capacity check.
5802 : while (true) {
5803 : int fast_length;
5804 12310992 : if (skip_capacity_check_) {
5805 : fast_length = length;
5806 : } else {
5807 173 : int remaining_capacity = capacity_ - static_cast<int>(buffer - start_);
5808 : // Need enough space to write everything but one character.
5809 : STATIC_ASSERT(unibrow::Utf16::kMaxExtraUtf8BytesForOneUtf16CodeUnit ==
5810 : 3);
5811 : int max_size_per_char = sizeof(Char) == 1 ? 2 : 3;
5812 : int writable_length =
5813 173 : (remaining_capacity - max_size_per_char)/max_size_per_char;
5814 : // Need to drop into slow loop.
5815 173 : if (writable_length <= 0) break;
5816 57 : fast_length = i + writable_length;
5817 57 : if (fast_length > length) fast_length = length;
5818 : }
5819 : // Write the characters to the stream.
5820 : if (sizeof(Char) == 1) {
5821 112500791 : for (; i < fast_length; i++) {
5822 112500791 : buffer += unibrow::Utf8::EncodeOneByte(
5823 112500791 : buffer, static_cast<uint8_t>(*chars++));
5824 : DCHECK(capacity_ == -1 || (buffer - start_) <= capacity_);
5825 : }
5826 : } else {
5827 3395392 : for (; i < fast_length; i++) {
5828 3395392 : uint16_t character = *chars++;
5829 3395392 : buffer += unibrow::Utf8::Encode(buffer, character, last_character,
5830 3395392 : replace_invalid_utf8_);
5831 3395392 : last_character = character;
5832 : DCHECK(capacity_ == -1 || (buffer - start_) <= capacity_);
5833 : }
5834 : }
5835 : // Array is fully written. Exit.
5836 12310876 : if (fast_length == length) {
5837 : // Write state back out to object.
5838 12310819 : last_character_ = last_character;
5839 12310819 : buffer_ = buffer;
5840 12310819 : utf16_chars_read_ += length;
5841 12310819 : return;
5842 : }
5843 : }
5844 : DCHECK(!skip_capacity_check_);
5845 : // Slow loop. Must check capacity on each iteration.
5846 : int remaining_capacity = capacity_ - static_cast<int>(buffer - start_);
5847 : DCHECK_GE(remaining_capacity, 0);
5848 209 : for (; i < length && remaining_capacity > 0; i++) {
5849 267 : uint16_t character = *chars++;
5850 : // remaining_capacity is <= 3 bytes at this point, so we do not write out
5851 : // an umatched lead surrogate.
5852 274 : if (replace_invalid_utf8_ && unibrow::Utf16::IsLeadSurrogate(character)) {
5853 7 : early_termination_ = true;
5854 7 : break;
5855 : }
5856 : int written = WriteEndCharacter(character,
5857 : last_character,
5858 : remaining_capacity,
5859 : buffer,
5860 260 : replace_invalid_utf8_);
5861 260 : if (written == 0) {
5862 51 : early_termination_ = true;
5863 51 : break;
5864 : }
5865 209 : buffer += written;
5866 209 : remaining_capacity -= written;
5867 : last_character = character;
5868 : }
5869 : // Write state back out to object.
5870 116 : last_character_ = last_character;
5871 116 : buffer_ = buffer;
5872 116 : utf16_chars_read_ += i;
5873 : }
5874 :
5875 : inline bool IsDone() {
5876 : return early_termination_;
5877 : }
5878 :
5879 : inline void VisitOneByteString(const uint8_t* chars, int length) {
5880 12167991 : Visit(chars, length);
5881 : }
5882 :
5883 : inline void VisitTwoByteString(const uint16_t* chars, int length) {
5884 151656 : Visit(chars, length);
5885 : }
5886 :
5887 11616777 : int CompleteWrite(bool write_null, int* utf16_chars_read_out) {
5888 : // Write out number of utf16 characters written to the stream.
5889 11616777 : if (utf16_chars_read_out != NULL) {
5890 198 : *utf16_chars_read_out = utf16_chars_read_;
5891 : }
5892 : // Only null terminate if all of the string was written and there's space.
5893 23233506 : if (write_null &&
5894 23233400 : !early_termination_ &&
5895 11616757 : (capacity_ == -1 || (buffer_ - start_) < capacity_)) {
5896 11616620 : *buffer_++ = '\0';
5897 : }
5898 11616777 : return static_cast<int>(buffer_ - start_);
5899 : }
5900 :
5901 : private:
5902 : bool early_termination_;
5903 : int last_character_;
5904 : char* buffer_;
5905 : char* const start_;
5906 : int capacity_;
5907 : bool const skip_capacity_check_;
5908 : bool const replace_invalid_utf8_;
5909 : int utf16_chars_read_;
5910 : DISALLOW_IMPLICIT_CONSTRUCTORS(Utf8WriterVisitor);
5911 : };
5912 :
5913 :
5914 12320231 : static bool RecursivelySerializeToUtf8(i::String* current,
5915 13023101 : Utf8WriterVisitor* writer,
5916 : int recursion_budget) {
5917 25343332 : while (!writer->IsDone()) {
5918 13023101 : i::ConsString* cons_string = i::String::VisitFlat(writer, current);
5919 13023101 : if (cons_string == NULL) return true; // Leaf node.
5920 703577 : if (recursion_budget <= 0) return false;
5921 : // Must write the left branch first.
5922 : i::String* first = cons_string->first();
5923 : bool success = RecursivelySerializeToUtf8(first,
5924 : writer,
5925 703570 : recursion_budget - 1);
5926 703570 : if (!success) return false;
5927 : // Inline tail recurse for right branch.
5928 : current = cons_string->second();
5929 : }
5930 : return true;
5931 : }
5932 :
5933 :
5934 11616810 : int String::WriteUtf8(char* buffer,
5935 : int capacity,
5936 : int* nchars_ref,
5937 : int options) const {
5938 : i::Handle<i::String> str = Utils::OpenHandle(this);
5939 11616810 : i::Isolate* isolate = str->GetIsolate();
5940 23233620 : LOG_API(isolate, String, WriteUtf8);
5941 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
5942 11616810 : if (options & HINT_MANY_WRITES_EXPECTED) {
5943 0 : str = i::String::Flatten(str); // Flatten the string for efficiency.
5944 : }
5945 : const int string_length = str->length();
5946 11616810 : bool write_null = !(options & NO_NULL_TERMINATION);
5947 11616810 : bool replace_invalid_utf8 = (options & REPLACE_INVALID_UTF8);
5948 : int max16BitCodeUnitSize = unibrow::Utf8::kMax16BitCodeUnitSize;
5949 : // First check if we can just write the string without checking capacity.
5950 11616810 : if (capacity == -1 || capacity / max16BitCodeUnitSize >= string_length) {
5951 : Utf8WriterVisitor writer(buffer, capacity, true, replace_invalid_utf8);
5952 : const int kMaxRecursion = 100;
5953 11616661 : bool success = RecursivelySerializeToUtf8(*str, &writer, kMaxRecursion);
5954 11616661 : if (success) return writer.CompleteWrite(write_null, nchars_ref);
5955 149 : } else if (capacity >= string_length) {
5956 : // First check that the buffer is large enough.
5957 91 : int utf8_bytes = v8::Utf8Length(*str, isolate);
5958 91 : if (utf8_bytes <= capacity) {
5959 : // one-byte fast path.
5960 33 : if (utf8_bytes == string_length) {
5961 : WriteOneByte(reinterpret_cast<uint8_t*>(buffer), 0, capacity, options);
5962 0 : if (nchars_ref != NULL) *nchars_ref = string_length;
5963 0 : if (write_null && (utf8_bytes+1 <= capacity)) {
5964 0 : return string_length + 1;
5965 : }
5966 : return string_length;
5967 : }
5968 33 : if (write_null && (utf8_bytes+1 > capacity)) {
5969 27 : options |= NO_NULL_TERMINATION;
5970 : }
5971 : // Recurse once without a capacity limit.
5972 : // This will get into the first branch above.
5973 : // TODO(dcarney) Check max left rec. in Utf8Length and fall through.
5974 33 : return WriteUtf8(buffer, -1, nchars_ref, options);
5975 : }
5976 : }
5977 : // Recursive slow path can potentially be unreasonable slow. Flatten.
5978 123 : str = i::String::Flatten(str);
5979 : Utf8WriterVisitor writer(buffer, capacity, false, replace_invalid_utf8);
5980 123 : i::String::VisitFlat(&writer, *str);
5981 123 : return writer.CompleteWrite(write_null, nchars_ref);
5982 : }
5983 :
5984 :
5985 : template<typename CharType>
5986 66905850 : static inline int WriteHelper(const String* string,
5987 : CharType* buffer,
5988 : int start,
5989 : int length,
5990 : int options) {
5991 66905850 : i::Isolate* isolate = Utils::OpenHandle(string)->GetIsolate();
5992 133811700 : LOG_API(isolate, String, Write);
5993 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
5994 : DCHECK(start >= 0 && length >= -1);
5995 : i::Handle<i::String> str = Utils::OpenHandle(string);
5996 66905850 : if (options & String::HINT_MANY_WRITES_EXPECTED) {
5997 : // Flatten the string for efficiency. This applies whether we are
5998 : // using StringCharacterStream or Get(i) to access the characters.
5999 0 : str = i::String::Flatten(str);
6000 : }
6001 66905850 : int end = start + length;
6002 133811645 : if ((length == -1) || (length > str->length() - start) )
6003 : end = str->length();
6004 66905850 : if (end < 0) return 0;
6005 66905850 : i::String::WriteToFlat(*str, buffer, start, end);
6006 66905849 : if (!(options & String::NO_NULL_TERMINATION) &&
6007 : (length == -1 || end - start < length)) {
6008 83 : buffer[end - start] = '\0';
6009 : }
6010 66905849 : return end - start;
6011 : }
6012 :
6013 :
6014 120 : int String::WriteOneByte(uint8_t* buffer,
6015 : int start,
6016 : int length,
6017 : int options) const {
6018 133 : return WriteHelper(this, buffer, start, length, options);
6019 : }
6020 :
6021 :
6022 66905710 : int String::Write(uint16_t* buffer,
6023 : int start,
6024 : int length,
6025 : int options) const {
6026 66905717 : return WriteHelper(this, buffer, start, length, options);
6027 : }
6028 :
6029 :
6030 164 : bool v8::String::IsExternal() const {
6031 : i::Handle<i::String> str = Utils::OpenHandle(this);
6032 164 : return i::StringShape(*str).IsExternalTwoByte();
6033 : }
6034 :
6035 :
6036 116 : bool v8::String::IsExternalOneByte() const {
6037 : i::Handle<i::String> str = Utils::OpenHandle(this);
6038 116 : return i::StringShape(*str).IsExternalOneByte();
6039 : }
6040 :
6041 :
6042 0 : void v8::String::VerifyExternalStringResource(
6043 : v8::String::ExternalStringResource* value) const {
6044 : i::Handle<i::String> str = Utils::OpenHandle(this);
6045 : const v8::String::ExternalStringResource* expected;
6046 0 : if (i::StringShape(*str).IsExternalTwoByte()) {
6047 : const void* resource =
6048 : i::Handle<i::ExternalTwoByteString>::cast(str)->resource();
6049 : expected = reinterpret_cast<const ExternalStringResource*>(resource);
6050 : } else {
6051 : expected = NULL;
6052 : }
6053 0 : CHECK_EQ(expected, value);
6054 0 : }
6055 :
6056 0 : void v8::String::VerifyExternalStringResourceBase(
6057 : v8::String::ExternalStringResourceBase* value, Encoding encoding) const {
6058 : i::Handle<i::String> str = Utils::OpenHandle(this);
6059 : const v8::String::ExternalStringResourceBase* expected;
6060 : Encoding expectedEncoding;
6061 0 : if (i::StringShape(*str).IsExternalOneByte()) {
6062 : const void* resource =
6063 : i::Handle<i::ExternalOneByteString>::cast(str)->resource();
6064 : expected = reinterpret_cast<const ExternalStringResourceBase*>(resource);
6065 : expectedEncoding = ONE_BYTE_ENCODING;
6066 0 : } else if (i::StringShape(*str).IsExternalTwoByte()) {
6067 : const void* resource =
6068 : i::Handle<i::ExternalTwoByteString>::cast(str)->resource();
6069 : expected = reinterpret_cast<const ExternalStringResourceBase*>(resource);
6070 : expectedEncoding = TWO_BYTE_ENCODING;
6071 : } else {
6072 : expected = NULL;
6073 : expectedEncoding =
6074 0 : str->IsOneByteRepresentation() ? ONE_BYTE_ENCODING : TWO_BYTE_ENCODING;
6075 : }
6076 0 : CHECK_EQ(expected, value);
6077 0 : CHECK_EQ(expectedEncoding, encoding);
6078 0 : }
6079 :
6080 : const v8::String::ExternalOneByteStringResource*
6081 13 : v8::String::GetExternalOneByteStringResource() const {
6082 : i::Handle<i::String> str = Utils::OpenHandle(this);
6083 13 : if (i::StringShape(*str).IsExternalOneByte()) {
6084 : const void* resource =
6085 : i::Handle<i::ExternalOneByteString>::cast(str)->resource();
6086 13 : return reinterpret_cast<const ExternalOneByteStringResource*>(resource);
6087 : } else {
6088 : return NULL;
6089 : }
6090 : }
6091 :
6092 :
6093 215 : Local<Value> Symbol::Name() const {
6094 : i::Handle<i::Symbol> sym = Utils::OpenHandle(this);
6095 : i::Handle<i::Object> name(sym->name(), sym->GetIsolate());
6096 215 : return Utils::ToLocal(name);
6097 : }
6098 :
6099 :
6100 14 : Local<Value> Private::Name() const {
6101 14 : return reinterpret_cast<const Symbol*>(this)->Name();
6102 : }
6103 :
6104 :
6105 1478568 : double Number::Value() const {
6106 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
6107 1478568 : return obj->Number();
6108 : }
6109 :
6110 :
6111 13938425 : bool Boolean::Value() const {
6112 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
6113 13938425 : return obj->IsTrue(i::HeapObject::cast(*obj)->GetIsolate());
6114 : }
6115 :
6116 :
6117 1786 : int64_t Integer::Value() const {
6118 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
6119 95151 : if (obj->IsSmi()) {
6120 95123 : return i::Smi::cast(*obj)->value();
6121 : } else {
6122 28 : return static_cast<int64_t>(obj->Number());
6123 : }
6124 : }
6125 :
6126 :
6127 287985 : int32_t Int32::Value() const {
6128 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
6129 287985 : if (obj->IsSmi()) {
6130 287985 : return i::Smi::cast(*obj)->value();
6131 : } else {
6132 0 : return static_cast<int32_t>(obj->Number());
6133 : }
6134 : }
6135 :
6136 :
6137 49 : uint32_t Uint32::Value() const {
6138 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
6139 49 : if (obj->IsSmi()) {
6140 28 : return i::Smi::cast(*obj)->value();
6141 : } else {
6142 21 : return static_cast<uint32_t>(obj->Number());
6143 : }
6144 : }
6145 :
6146 2862 : int v8::Object::InternalFieldCount() {
6147 : i::Handle<i::JSReceiver> self = Utils::OpenHandle(this);
6148 2862 : if (!self->IsJSObject()) return 0;
6149 2862 : return i::Handle<i::JSObject>::cast(self)->GetEmbedderFieldCount();
6150 : }
6151 :
6152 2013 : static bool InternalFieldOK(i::Handle<i::JSReceiver> obj, int index,
6153 : const char* location) {
6154 : return Utils::ApiCheck(
6155 4026 : obj->IsJSObject() &&
6156 2013 : (index < i::Handle<i::JSObject>::cast(obj)->GetEmbedderFieldCount()),
6157 2013 : location, "Internal field out of bounds");
6158 : }
6159 :
6160 658 : Local<Value> v8::Object::SlowGetInternalField(int index) {
6161 : i::Handle<i::JSReceiver> obj = Utils::OpenHandle(this);
6162 : const char* location = "v8::Object::GetInternalField()";
6163 658 : if (!InternalFieldOK(obj, index, location)) return Local<Value>();
6164 : i::Handle<i::Object> value(
6165 : i::Handle<i::JSObject>::cast(obj)->GetEmbedderField(index),
6166 : obj->GetIsolate());
6167 : return Utils::ToLocal(value);
6168 : }
6169 :
6170 102 : void v8::Object::SetInternalField(int index, v8::Local<Value> value) {
6171 : i::Handle<i::JSReceiver> obj = Utils::OpenHandle(this);
6172 : const char* location = "v8::Object::SetInternalField()";
6173 204 : if (!InternalFieldOK(obj, index, location)) return;
6174 : i::Handle<i::Object> val = Utils::OpenHandle(*value);
6175 102 : i::Handle<i::JSObject>::cast(obj)->SetEmbedderField(index, *val);
6176 : }
6177 :
6178 24 : void* v8::Object::SlowGetAlignedPointerFromInternalField(int index) {
6179 : i::Handle<i::JSReceiver> obj = Utils::OpenHandle(this);
6180 : const char* location = "v8::Object::GetAlignedPointerFromInternalField()";
6181 24 : if (!InternalFieldOK(obj, index, location)) return NULL;
6182 : return DecodeSmiToAligned(
6183 : i::Handle<i::JSObject>::cast(obj)->GetEmbedderField(index), location);
6184 : }
6185 :
6186 1229 : void v8::Object::SetAlignedPointerInInternalField(int index, void* value) {
6187 : i::Handle<i::JSReceiver> obj = Utils::OpenHandle(this);
6188 : const char* location = "v8::Object::SetAlignedPointerInInternalField()";
6189 2458 : if (!InternalFieldOK(obj, index, location)) return;
6190 : i::Handle<i::JSObject>::cast(obj)->SetEmbedderField(
6191 : index, EncodeAlignedAsSmi(value, location));
6192 : DCHECK_EQ(value, GetAlignedPointerFromInternalField(index));
6193 : }
6194 :
6195 14 : void v8::Object::SetAlignedPointerInInternalFields(int argc, int indices[],
6196 : void* values[]) {
6197 : i::Handle<i::JSReceiver> obj = Utils::OpenHandle(this);
6198 : const char* location = "v8::Object::SetAlignedPointerInInternalFields()";
6199 : i::DisallowHeapAllocation no_gc;
6200 : i::JSObject* object = i::JSObject::cast(*obj);
6201 14 : int nof_embedder_fields = object->GetEmbedderFieldCount();
6202 42 : for (int i = 0; i < argc; i++) {
6203 28 : int index = indices[i];
6204 28 : if (!Utils::ApiCheck(index < nof_embedder_fields, location,
6205 28 : "Internal field out of bounds")) {
6206 14 : return;
6207 : }
6208 28 : void* value = values[i];
6209 : object->SetEmbedderField(index, EncodeAlignedAsSmi(value, location));
6210 : DCHECK_EQ(value, GetAlignedPointerFromInternalField(index));
6211 : }
6212 : }
6213 :
6214 17107652 : static void* ExternalValue(i::Object* obj) {
6215 : // Obscure semantics for undefined, but somehow checked in our unit tests...
6216 34215304 : if (!obj->IsSmi() &&
6217 : obj->IsUndefined(i::HeapObject::cast(obj)->GetIsolate())) {
6218 : return NULL;
6219 : }
6220 : i::Object* foreign = i::JSObject::cast(obj)->GetEmbedderField(0);
6221 17107652 : return i::Foreign::cast(foreign)->foreign_address();
6222 : }
6223 :
6224 :
6225 : // --- E n v i r o n m e n t ---
6226 :
6227 :
6228 59461 : void v8::V8::InitializePlatform(Platform* platform) {
6229 59461 : i::V8::InitializePlatform(platform);
6230 59461 : }
6231 :
6232 :
6233 58744 : void v8::V8::ShutdownPlatform() {
6234 58744 : i::V8::ShutdownPlatform();
6235 58744 : }
6236 :
6237 :
6238 59923 : bool v8::V8::Initialize() {
6239 59923 : i::V8::Initialize();
6240 : #ifdef V8_USE_EXTERNAL_STARTUP_DATA
6241 59923 : i::ReadNatives();
6242 : #endif
6243 59923 : return true;
6244 : }
6245 :
6246 : #if V8_OS_LINUX && V8_TARGET_ARCH_X64 && !V8_OS_ANDROID
6247 0 : bool V8::TryHandleSignal(int signum, void* info, void* context) {
6248 : return v8::internal::trap_handler::TryHandleSignal(
6249 0 : signum, static_cast<siginfo_t*>(info), static_cast<ucontext_t*>(context));
6250 : }
6251 : #endif // V8_OS_LINUX
6252 :
6253 4618 : bool V8::RegisterDefaultSignalHandler() {
6254 4618 : return v8::internal::trap_handler::RegisterDefaultSignalHandler();
6255 : }
6256 :
6257 0 : void v8::V8::SetEntropySource(EntropySource entropy_source) {
6258 0 : base::RandomNumberGenerator::SetEntropySource(entropy_source);
6259 0 : }
6260 :
6261 :
6262 0 : void v8::V8::SetReturnAddressLocationResolver(
6263 : ReturnAddressLocationResolver return_address_resolver) {
6264 0 : i::StackFrame::SetReturnAddressLocationResolver(return_address_resolver);
6265 0 : }
6266 :
6267 :
6268 32496 : bool v8::V8::Dispose() {
6269 32496 : i::V8::TearDown();
6270 : #ifdef V8_USE_EXTERNAL_STARTUP_DATA
6271 32496 : i::DisposeNatives();
6272 : #endif
6273 32496 : return true;
6274 : }
6275 :
6276 7 : HeapStatistics::HeapStatistics()
6277 : : total_heap_size_(0),
6278 : total_heap_size_executable_(0),
6279 : total_physical_size_(0),
6280 : total_available_size_(0),
6281 : used_heap_size_(0),
6282 : heap_size_limit_(0),
6283 : malloced_memory_(0),
6284 : peak_malloced_memory_(0),
6285 7 : does_zap_garbage_(0) {}
6286 :
6287 0 : HeapSpaceStatistics::HeapSpaceStatistics(): space_name_(0),
6288 : space_size_(0),
6289 : space_used_size_(0),
6290 : space_available_size_(0),
6291 0 : physical_space_size_(0) { }
6292 :
6293 :
6294 0 : HeapObjectStatistics::HeapObjectStatistics()
6295 : : object_type_(nullptr),
6296 : object_sub_type_(nullptr),
6297 : object_count_(0),
6298 0 : object_size_(0) {}
6299 :
6300 0 : HeapCodeStatistics::HeapCodeStatistics()
6301 0 : : code_and_metadata_size_(0), bytecode_and_metadata_size_(0) {}
6302 :
6303 0 : bool v8::V8::InitializeICU(const char* icu_data_file) {
6304 0 : return i::InitializeICU(icu_data_file);
6305 : }
6306 :
6307 56904 : bool v8::V8::InitializeICUDefaultLocation(const char* exec_path,
6308 : const char* icu_data_file) {
6309 56904 : return i::InitializeICUDefaultLocation(exec_path, icu_data_file);
6310 : }
6311 :
6312 59466 : void v8::V8::InitializeExternalStartupData(const char* directory_path) {
6313 59466 : i::InitializeExternalStartupData(directory_path);
6314 59466 : }
6315 :
6316 :
6317 0 : void v8::V8::InitializeExternalStartupData(const char* natives_blob,
6318 : const char* snapshot_blob) {
6319 0 : i::InitializeExternalStartupData(natives_blob, snapshot_blob);
6320 0 : }
6321 :
6322 :
6323 52 : const char* v8::V8::GetVersion() {
6324 52 : return i::Version::GetVersion();
6325 : }
6326 :
6327 : template <typename ObjectType>
6328 : struct InvokeBootstrapper;
6329 :
6330 : template <>
6331 : struct InvokeBootstrapper<i::Context> {
6332 : i::Handle<i::Context> Invoke(
6333 100278 : i::Isolate* isolate, i::MaybeHandle<i::JSGlobalProxy> maybe_global_proxy,
6334 : v8::Local<v8::ObjectTemplate> global_object_template,
6335 : v8::ExtensionConfiguration* extensions, size_t context_snapshot_index,
6336 : v8::DeserializeInternalFieldsCallback embedder_fields_deserializer) {
6337 : return isolate->bootstrapper()->CreateEnvironment(
6338 : maybe_global_proxy, global_object_template, extensions,
6339 200556 : context_snapshot_index, embedder_fields_deserializer);
6340 : }
6341 : };
6342 :
6343 : template <>
6344 : struct InvokeBootstrapper<i::JSGlobalProxy> {
6345 : i::Handle<i::JSGlobalProxy> Invoke(
6346 24 : i::Isolate* isolate, i::MaybeHandle<i::JSGlobalProxy> maybe_global_proxy,
6347 : v8::Local<v8::ObjectTemplate> global_object_template,
6348 : v8::ExtensionConfiguration* extensions, size_t context_snapshot_index,
6349 : v8::DeserializeInternalFieldsCallback embedder_fields_deserializer) {
6350 : USE(extensions);
6351 : USE(context_snapshot_index);
6352 : return isolate->bootstrapper()->NewRemoteContext(maybe_global_proxy,
6353 48 : global_object_template);
6354 : }
6355 : };
6356 :
6357 : template <typename ObjectType>
6358 100302 : static i::Handle<ObjectType> CreateEnvironment(
6359 : i::Isolate* isolate, v8::ExtensionConfiguration* extensions,
6360 : v8::MaybeLocal<ObjectTemplate> maybe_global_template,
6361 : v8::MaybeLocal<Value> maybe_global_proxy, size_t context_snapshot_index,
6362 : v8::DeserializeInternalFieldsCallback embedder_fields_deserializer) {
6363 : i::Handle<ObjectType> result;
6364 :
6365 : {
6366 : ENTER_V8_FOR_NEW_CONTEXT(isolate);
6367 : v8::Local<ObjectTemplate> proxy_template;
6368 : i::Handle<i::FunctionTemplateInfo> proxy_constructor;
6369 : i::Handle<i::FunctionTemplateInfo> global_constructor;
6370 : i::Handle<i::Object> named_interceptor(
6371 : isolate->factory()->undefined_value());
6372 : i::Handle<i::Object> indexed_interceptor(
6373 : isolate->factory()->undefined_value());
6374 :
6375 100302 : if (!maybe_global_template.IsEmpty()) {
6376 : v8::Local<v8::ObjectTemplate> global_template =
6377 : maybe_global_template.ToLocalChecked();
6378 : // Make sure that the global_template has a constructor.
6379 64799 : global_constructor = EnsureConstructor(isolate, *global_template);
6380 :
6381 : // Create a fresh template for the global proxy object.
6382 : proxy_template = ObjectTemplate::New(
6383 : reinterpret_cast<v8::Isolate*>(isolate));
6384 64799 : proxy_constructor = EnsureConstructor(isolate, *proxy_template);
6385 :
6386 : // Set the global template to be the prototype template of
6387 : // global proxy template.
6388 64799 : proxy_constructor->set_prototype_template(
6389 : *Utils::OpenHandle(*global_template));
6390 :
6391 64799 : proxy_template->SetInternalFieldCount(
6392 : global_template->InternalFieldCount());
6393 :
6394 : // Migrate security handlers from global_template to
6395 : // proxy_template. Temporarily removing access check
6396 : // information from the global template.
6397 64799 : if (!global_constructor->access_check_info()->IsUndefined(isolate)) {
6398 181 : proxy_constructor->set_access_check_info(
6399 : global_constructor->access_check_info());
6400 : proxy_constructor->set_needs_access_check(
6401 : global_constructor->needs_access_check());
6402 : global_constructor->set_needs_access_check(false);
6403 181 : global_constructor->set_access_check_info(
6404 181 : isolate->heap()->undefined_value());
6405 : }
6406 :
6407 : // Same for other interceptors. If the global constructor has
6408 : // interceptors, we need to replace them temporarily with noop
6409 : // interceptors, so the map is correctly marked as having interceptors,
6410 : // but we don't invoke any.
6411 64799 : if (!global_constructor->named_property_handler()->IsUndefined(isolate)) {
6412 : named_interceptor =
6413 : handle(global_constructor->named_property_handler(), isolate);
6414 163 : global_constructor->set_named_property_handler(
6415 163 : isolate->heap()->noop_interceptor_info());
6416 : }
6417 64799 : if (!global_constructor->indexed_property_handler()->IsUndefined(
6418 : isolate)) {
6419 : indexed_interceptor =
6420 : handle(global_constructor->indexed_property_handler(), isolate);
6421 0 : global_constructor->set_indexed_property_handler(
6422 0 : isolate->heap()->noop_interceptor_info());
6423 : }
6424 : }
6425 :
6426 : i::MaybeHandle<i::JSGlobalProxy> maybe_proxy;
6427 100302 : if (!maybe_global_proxy.IsEmpty()) {
6428 : maybe_proxy = i::Handle<i::JSGlobalProxy>::cast(
6429 : Utils::OpenHandle(*maybe_global_proxy.ToLocalChecked()));
6430 : }
6431 : // Create the environment.
6432 : InvokeBootstrapper<ObjectType> invoke;
6433 : result =
6434 : invoke.Invoke(isolate, maybe_proxy, proxy_template, extensions,
6435 : context_snapshot_index, embedder_fields_deserializer);
6436 :
6437 : // Restore the access check info and interceptors on the global template.
6438 100301 : if (!maybe_global_template.IsEmpty()) {
6439 : DCHECK(!global_constructor.is_null());
6440 : DCHECK(!proxy_constructor.is_null());
6441 64799 : global_constructor->set_access_check_info(
6442 : proxy_constructor->access_check_info());
6443 : global_constructor->set_needs_access_check(
6444 : proxy_constructor->needs_access_check());
6445 64799 : global_constructor->set_named_property_handler(*named_interceptor);
6446 64799 : global_constructor->set_indexed_property_handler(*indexed_interceptor);
6447 : }
6448 : }
6449 : // Leave V8.
6450 :
6451 100301 : return result;
6452 : }
6453 :
6454 100278 : Local<Context> NewContext(
6455 : v8::Isolate* external_isolate, v8::ExtensionConfiguration* extensions,
6456 : v8::MaybeLocal<ObjectTemplate> global_template,
6457 : v8::MaybeLocal<Value> global_object, size_t context_snapshot_index,
6458 : v8::DeserializeInternalFieldsCallback embedder_fields_deserializer) {
6459 100278 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(external_isolate);
6460 200556 : TRACE_EVENT_CALL_STATS_SCOPED(isolate, "v8", "V8.NewContext");
6461 200556 : LOG_API(isolate, Context, New);
6462 : i::HandleScope scope(isolate);
6463 : ExtensionConfiguration no_extensions;
6464 100278 : if (extensions == NULL) extensions = &no_extensions;
6465 : i::Handle<i::Context> env = CreateEnvironment<i::Context>(
6466 : isolate, extensions, global_template, global_object,
6467 100278 : context_snapshot_index, embedder_fields_deserializer);
6468 100277 : if (env.is_null()) {
6469 78 : if (isolate->has_pending_exception()) isolate->clear_pending_exception();
6470 78 : return Local<Context>();
6471 : }
6472 200476 : return Utils::ToLocal(scope.CloseAndEscape(env));
6473 : }
6474 :
6475 100163 : Local<Context> v8::Context::New(v8::Isolate* external_isolate,
6476 : v8::ExtensionConfiguration* extensions,
6477 : v8::MaybeLocal<ObjectTemplate> global_template,
6478 : v8::MaybeLocal<Value> global_object) {
6479 : return NewContext(external_isolate, extensions, global_template,
6480 100248 : global_object, 0, DeserializeInternalFieldsCallback());
6481 : }
6482 :
6483 36 : MaybeLocal<Context> v8::Context::FromSnapshot(
6484 : v8::Isolate* external_isolate, size_t context_snapshot_index,
6485 : v8::DeserializeInternalFieldsCallback embedder_fields_deserializer,
6486 : v8::ExtensionConfiguration* extensions, MaybeLocal<Value> global_object) {
6487 36 : size_t index_including_default_context = context_snapshot_index + 1;
6488 36 : if (!i::Snapshot::HasContextSnapshot(
6489 : reinterpret_cast<i::Isolate*>(external_isolate),
6490 36 : index_including_default_context)) {
6491 6 : return MaybeLocal<Context>();
6492 : }
6493 : return NewContext(external_isolate, extensions, MaybeLocal<ObjectTemplate>(),
6494 : global_object, index_including_default_context,
6495 30 : embedder_fields_deserializer);
6496 : }
6497 :
6498 24 : MaybeLocal<Object> v8::Context::NewRemoteContext(
6499 : v8::Isolate* external_isolate, v8::Local<ObjectTemplate> global_template,
6500 : v8::MaybeLocal<v8::Value> global_object) {
6501 24 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(external_isolate);
6502 48 : LOG_API(isolate, Context, NewRemoteContext);
6503 : i::HandleScope scope(isolate);
6504 : i::Handle<i::FunctionTemplateInfo> global_constructor =
6505 24 : EnsureConstructor(isolate, *global_template);
6506 : Utils::ApiCheck(global_constructor->needs_access_check(),
6507 : "v8::Context::NewRemoteContext",
6508 : "Global template needs to have access checks enabled.");
6509 : i::Handle<i::AccessCheckInfo> access_check_info = i::handle(
6510 : i::AccessCheckInfo::cast(global_constructor->access_check_info()),
6511 : isolate);
6512 : Utils::ApiCheck(access_check_info->named_interceptor() != nullptr,
6513 : "v8::Context::NewRemoteContext",
6514 : "Global template needs to have access check handlers.");
6515 : i::Handle<i::JSGlobalProxy> global_proxy =
6516 : CreateEnvironment<i::JSGlobalProxy>(isolate, nullptr, global_template,
6517 : global_object, 0,
6518 24 : DeserializeInternalFieldsCallback());
6519 24 : if (global_proxy.is_null()) {
6520 0 : if (isolate->has_pending_exception()) isolate->clear_pending_exception();
6521 0 : return MaybeLocal<Object>();
6522 : }
6523 : return Utils::ToLocal(
6524 24 : scope.CloseAndEscape(i::Handle<i::JSObject>::cast(global_proxy)));
6525 : }
6526 :
6527 305 : void v8::Context::SetSecurityToken(Local<Value> token) {
6528 : i::Handle<i::Context> env = Utils::OpenHandle(this);
6529 : i::Handle<i::Object> token_handle = Utils::OpenHandle(*token);
6530 : env->set_security_token(*token_handle);
6531 305 : }
6532 :
6533 :
6534 0 : void v8::Context::UseDefaultSecurityToken() {
6535 : i::Handle<i::Context> env = Utils::OpenHandle(this);
6536 0 : env->set_security_token(env->global_object());
6537 0 : }
6538 :
6539 :
6540 15 : Local<Value> v8::Context::GetSecurityToken() {
6541 : i::Handle<i::Context> env = Utils::OpenHandle(this);
6542 : i::Isolate* isolate = env->GetIsolate();
6543 : i::Object* security_token = env->security_token();
6544 : i::Handle<i::Object> token_handle(security_token, isolate);
6545 15 : return Utils::ToLocal(token_handle);
6546 : }
6547 :
6548 :
6549 14462072 : v8::Isolate* Context::GetIsolate() {
6550 : i::Handle<i::Context> env = Utils::OpenHandle(this);
6551 14462072 : return reinterpret_cast<Isolate*>(env->GetIsolate());
6552 : }
6553 :
6554 849381 : v8::Local<v8::Object> Context::Global() {
6555 : i::Handle<i::Context> context = Utils::OpenHandle(this);
6556 : i::Isolate* isolate = context->GetIsolate();
6557 849381 : i::Handle<i::Object> global(context->global_proxy(), isolate);
6558 : // TODO(dcarney): This should always return the global proxy
6559 : // but can't presently as calls to GetProtoype will return the wrong result.
6560 849381 : if (i::Handle<i::JSGlobalProxy>::cast(
6561 849381 : global)->IsDetachedFrom(context->global_object())) {
6562 78 : global = i::Handle<i::Object>(context->global_object(), isolate);
6563 : }
6564 849381 : return Utils::ToLocal(i::Handle<i::JSObject>::cast(global));
6565 : }
6566 :
6567 :
6568 65 : void Context::DetachGlobal() {
6569 : i::Handle<i::Context> context = Utils::OpenHandle(this);
6570 65 : i::Isolate* isolate = context->GetIsolate();
6571 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
6572 65 : isolate->bootstrapper()->DetachGlobal(context);
6573 65 : }
6574 :
6575 :
6576 24 : Local<v8::Object> Context::GetExtrasBindingObject() {
6577 : i::Handle<i::Context> context = Utils::OpenHandle(this);
6578 : i::Isolate* isolate = context->GetIsolate();
6579 : i::Handle<i::JSObject> binding(context->extras_binding_object(), isolate);
6580 24 : return Utils::ToLocal(binding);
6581 : }
6582 :
6583 :
6584 39 : void Context::AllowCodeGenerationFromStrings(bool allow) {
6585 : i::Handle<i::Context> context = Utils::OpenHandle(this);
6586 : i::Isolate* isolate = context->GetIsolate();
6587 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
6588 : context->set_allow_code_gen_from_strings(
6589 39 : allow ? isolate->heap()->true_value() : isolate->heap()->false_value());
6590 39 : }
6591 :
6592 :
6593 4767 : bool Context::IsCodeGenerationFromStringsAllowed() {
6594 : i::Handle<i::Context> context = Utils::OpenHandle(this);
6595 : return !context->allow_code_gen_from_strings()->IsFalse(
6596 4767 : context->GetIsolate());
6597 : }
6598 :
6599 :
6600 6 : void Context::SetErrorMessageForCodeGenerationFromStrings(Local<String> error) {
6601 : i::Handle<i::Context> context = Utils::OpenHandle(this);
6602 : i::Handle<i::String> error_handle = Utils::OpenHandle(*error);
6603 : context->set_error_message_for_code_gen_from_strings(*error_handle);
6604 6 : }
6605 :
6606 0 : size_t Context::EstimatedSize() { return 0; }
6607 :
6608 2795 : MaybeLocal<v8::Object> ObjectTemplate::NewInstance(Local<Context> context) {
6609 11180 : PREPARE_FOR_EXECUTION(context, ObjectTemplate, NewInstance, Object);
6610 2795 : auto self = Utils::OpenHandle(this);
6611 : Local<Object> result;
6612 : has_pending_exception =
6613 5590 : !ToLocal<Object>(i::ApiNatives::InstantiateObject(self), &result);
6614 2795 : RETURN_ON_FAILED_EXECUTION(Object);
6615 2795 : RETURN_ESCAPED(result);
6616 : }
6617 :
6618 :
6619 0 : Local<v8::Object> ObjectTemplate::NewInstance() {
6620 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
6621 0 : RETURN_TO_LOCAL_UNCHECKED(NewInstance(context), Object);
6622 : }
6623 :
6624 :
6625 52848 : MaybeLocal<v8::Function> FunctionTemplate::GetFunction(Local<Context> context) {
6626 211392 : PREPARE_FOR_EXECUTION(context, FunctionTemplate, GetFunction, Function);
6627 52848 : auto self = Utils::OpenHandle(this);
6628 : Local<Function> result;
6629 : has_pending_exception =
6630 105696 : !ToLocal<Function>(i::ApiNatives::InstantiateFunction(self), &result);
6631 52848 : RETURN_ON_FAILED_EXECUTION(Function);
6632 52848 : RETURN_ESCAPED(result);
6633 : }
6634 :
6635 :
6636 0 : Local<v8::Function> FunctionTemplate::GetFunction() {
6637 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
6638 0 : RETURN_TO_LOCAL_UNCHECKED(GetFunction(context), Function);
6639 : }
6640 :
6641 10 : MaybeLocal<v8::Object> FunctionTemplate::NewRemoteInstance() {
6642 : auto self = Utils::OpenHandle(this);
6643 10 : i::Isolate* isolate = self->GetIsolate();
6644 20 : LOG_API(isolate, FunctionTemplate, NewRemoteInstance);
6645 : i::HandleScope scope(isolate);
6646 : i::Handle<i::FunctionTemplateInfo> constructor =
6647 20 : EnsureConstructor(isolate, *InstanceTemplate());
6648 : Utils::ApiCheck(constructor->needs_access_check(),
6649 : "v8::FunctionTemplate::NewRemoteInstance",
6650 : "InstanceTemplate needs to have access checks enabled.");
6651 : i::Handle<i::AccessCheckInfo> access_check_info = i::handle(
6652 : i::AccessCheckInfo::cast(constructor->access_check_info()), isolate);
6653 : Utils::ApiCheck(access_check_info->named_interceptor() != nullptr,
6654 : "v8::FunctionTemplate::NewRemoteInstance",
6655 : "InstanceTemplate needs to have access check handlers.");
6656 : i::Handle<i::JSObject> object;
6657 10 : if (!i::ApiNatives::InstantiateRemoteObject(
6658 20 : Utils::OpenHandle(*InstanceTemplate()))
6659 20 : .ToHandle(&object)) {
6660 0 : if (isolate->has_pending_exception()) {
6661 0 : isolate->OptionalRescheduleException(true);
6662 : }
6663 0 : return MaybeLocal<Object>();
6664 : }
6665 10 : return Utils::ToLocal(scope.CloseAndEscape(object));
6666 : }
6667 :
6668 51 : bool FunctionTemplate::HasInstance(v8::Local<v8::Value> value) {
6669 : auto self = Utils::OpenHandle(this);
6670 : auto obj = Utils::OpenHandle(*value);
6671 102 : if (obj->IsJSObject() && self->IsTemplateFor(i::JSObject::cast(*obj))) {
6672 : return true;
6673 : }
6674 23 : if (obj->IsJSGlobalProxy()) {
6675 : // If it's a global proxy, then test with the global object. Note that the
6676 : // inner global object may not necessarily be a JSGlobalObject.
6677 2 : i::PrototypeIterator iter(i::JSObject::cast(*obj)->map());
6678 : // The global proxy should always have a prototype, as it is a bug to call
6679 : // this on a detached JSGlobalProxy.
6680 : DCHECK(!iter.IsAtEnd());
6681 4 : return self->IsTemplateFor(iter.GetCurrent<i::JSObject>());
6682 : }
6683 : return false;
6684 : }
6685 :
6686 :
6687 11483 : Local<External> v8::External::New(Isolate* isolate, void* value) {
6688 : STATIC_ASSERT(sizeof(value) == sizeof(i::Address));
6689 11483 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6690 22966 : LOG_API(i_isolate, External, New);
6691 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
6692 11483 : i::Handle<i::JSObject> external = i_isolate->factory()->NewExternal(value);
6693 11483 : return Utils::ExternalToLocal(external);
6694 : }
6695 :
6696 :
6697 17107652 : void* External::Value() const {
6698 17107652 : return ExternalValue(*Utils::OpenHandle(this));
6699 : }
6700 :
6701 :
6702 : // anonymous namespace for string creation helper functions
6703 : namespace {
6704 :
6705 : inline int StringLength(const char* string) {
6706 : return i::StrLength(string);
6707 : }
6708 :
6709 :
6710 : inline int StringLength(const uint8_t* string) {
6711 : return i::StrLength(reinterpret_cast<const char*>(string));
6712 : }
6713 :
6714 :
6715 : inline int StringLength(const uint16_t* string) {
6716 : int length = 0;
6717 4827 : while (string[length] != '\0')
6718 4770 : length++;
6719 : return length;
6720 : }
6721 :
6722 :
6723 : MUST_USE_RESULT
6724 26636563 : inline i::MaybeHandle<i::String> NewString(i::Factory* factory,
6725 : v8::NewStringType type,
6726 : i::Vector<const char> string) {
6727 26636563 : if (type == v8::NewStringType::kInternalized) {
6728 15939379 : return factory->InternalizeUtf8String(string);
6729 : }
6730 10697184 : return factory->NewStringFromUtf8(string);
6731 : }
6732 :
6733 :
6734 : MUST_USE_RESULT
6735 489 : inline i::MaybeHandle<i::String> NewString(i::Factory* factory,
6736 : v8::NewStringType type,
6737 : i::Vector<const uint8_t> string) {
6738 489 : if (type == v8::NewStringType::kInternalized) {
6739 390 : return factory->InternalizeOneByteString(string);
6740 : }
6741 99 : return factory->NewStringFromOneByte(string);
6742 : }
6743 :
6744 :
6745 : MUST_USE_RESULT
6746 1707618 : inline i::MaybeHandle<i::String> NewString(i::Factory* factory,
6747 : v8::NewStringType type,
6748 : i::Vector<const uint16_t> string) {
6749 1707618 : if (type == v8::NewStringType::kInternalized) {
6750 0 : return factory->InternalizeTwoByteString(string);
6751 : }
6752 1707618 : return factory->NewStringFromTwoByte(string);
6753 : }
6754 :
6755 :
6756 : STATIC_ASSERT(v8::String::kMaxLength == i::String::kMaxLength);
6757 :
6758 : } // anonymous namespace
6759 :
6760 : // TODO(dcarney): throw a context free exception.
6761 : #define NEW_STRING(isolate, class_name, function_name, Char, data, type, \
6762 : length) \
6763 : MaybeLocal<String> result; \
6764 : if (length == 0) { \
6765 : result = String::Empty(isolate); \
6766 : } else if (length > i::String::kMaxLength) { \
6767 : result = MaybeLocal<String>(); \
6768 : } else { \
6769 : i::Isolate* i_isolate = reinterpret_cast<internal::Isolate*>(isolate); \
6770 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate); \
6771 : LOG_API(i_isolate, class_name, function_name); \
6772 : if (length < 0) length = StringLength(data); \
6773 : i::Handle<i::String> handle_result = \
6774 : NewString(i_isolate->factory(), type, \
6775 : i::Vector<const Char>(data, length)) \
6776 : .ToHandleChecked(); \
6777 : result = Utils::ToLocal(handle_result); \
6778 : }
6779 :
6780 0 : Local<String> String::NewFromUtf8(Isolate* isolate,
6781 : const char* data,
6782 : NewStringType type,
6783 : int length) {
6784 0 : NEW_STRING(isolate, String, NewFromUtf8, char, data,
6785 : static_cast<v8::NewStringType>(type), length);
6786 0 : RETURN_TO_LOCAL_UNCHECKED(result, String);
6787 : }
6788 :
6789 :
6790 26636575 : MaybeLocal<String> String::NewFromUtf8(Isolate* isolate, const char* data,
6791 : v8::NewStringType type, int length) {
6792 133182833 : NEW_STRING(isolate, String, NewFromUtf8, char, data, type, length);
6793 26636575 : return result;
6794 : }
6795 :
6796 :
6797 0 : Local<String> String::NewFromOneByte(Isolate* isolate,
6798 : const uint8_t* data,
6799 : NewStringType type,
6800 : int length) {
6801 0 : NEW_STRING(isolate, String, NewFromOneByte, uint8_t, data,
6802 : static_cast<v8::NewStringType>(type), length);
6803 0 : RETURN_TO_LOCAL_UNCHECKED(result, String);
6804 : }
6805 :
6806 :
6807 507 : MaybeLocal<String> String::NewFromOneByte(Isolate* isolate, const uint8_t* data,
6808 : v8::NewStringType type, int length) {
6809 2469 : NEW_STRING(isolate, String, NewFromOneByte, uint8_t, data, type, length);
6810 507 : return result;
6811 : }
6812 :
6813 :
6814 0 : Local<String> String::NewFromTwoByte(Isolate* isolate,
6815 : const uint16_t* data,
6816 : NewStringType type,
6817 : int length) {
6818 0 : NEW_STRING(isolate, String, NewFromTwoByte, uint16_t, data,
6819 : static_cast<v8::NewStringType>(type), length);
6820 0 : RETURN_TO_LOCAL_UNCHECKED(result, String);
6821 : }
6822 :
6823 :
6824 1748798 : MaybeLocal<String> String::NewFromTwoByte(Isolate* isolate,
6825 : const uint16_t* data,
6826 : v8::NewStringType type, int length) {
6827 8579280 : NEW_STRING(isolate, String, NewFromTwoByte, uint16_t, data, type, length);
6828 1748800 : return result;
6829 : }
6830 :
6831 :
6832 231313 : Local<String> v8::String::Concat(Local<String> left, Local<String> right) {
6833 : i::Handle<i::String> left_string = Utils::OpenHandle(*left);
6834 231313 : i::Isolate* isolate = left_string->GetIsolate();
6835 : ENTER_V8(isolate);
6836 462626 : LOG_API(isolate, String, Concat);
6837 : i::Handle<i::String> right_string = Utils::OpenHandle(*right);
6838 : // If we are steering towards a range error, do not wait for the error to be
6839 : // thrown, and return the null handle instead.
6840 231313 : if (left_string->length() + right_string->length() > i::String::kMaxLength) {
6841 6 : return Local<String>();
6842 : }
6843 : i::Handle<i::String> result = isolate->factory()->NewConsString(
6844 462614 : left_string, right_string).ToHandleChecked();
6845 : return Utils::ToLocal(result);
6846 : }
6847 :
6848 :
6849 22686 : MaybeLocal<String> v8::String::NewExternalTwoByte(
6850 : Isolate* isolate, v8::String::ExternalStringResource* resource) {
6851 22686 : CHECK(resource && resource->data());
6852 : // TODO(dcarney): throw a context free exception.
6853 22686 : if (resource->length() > static_cast<size_t>(i::String::kMaxLength)) {
6854 7 : return MaybeLocal<String>();
6855 : }
6856 22679 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6857 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
6858 45358 : LOG_API(i_isolate, String, NewExternalTwoByte);
6859 22679 : if (resource->length() > 0) {
6860 : i::Handle<i::String> string = i_isolate->factory()
6861 : ->NewExternalStringFromTwoByte(resource)
6862 45334 : .ToHandleChecked();
6863 : i_isolate->heap()->RegisterExternalString(*string);
6864 22667 : return Utils::ToLocal(string);
6865 : } else {
6866 : // The resource isn't going to be used, free it immediately.
6867 12 : resource->Dispose();
6868 12 : return Utils::ToLocal(i_isolate->factory()->empty_string());
6869 : }
6870 : }
6871 :
6872 :
6873 0 : Local<String> v8::String::NewExternal(
6874 : Isolate* isolate, v8::String::ExternalStringResource* resource) {
6875 0 : RETURN_TO_LOCAL_UNCHECKED(NewExternalTwoByte(isolate, resource), String);
6876 : }
6877 :
6878 :
6879 1500 : MaybeLocal<String> v8::String::NewExternalOneByte(
6880 : Isolate* isolate, v8::String::ExternalOneByteStringResource* resource) {
6881 1500 : CHECK(resource && resource->data());
6882 : // TODO(dcarney): throw a context free exception.
6883 1500 : if (resource->length() > static_cast<size_t>(i::String::kMaxLength)) {
6884 7 : return MaybeLocal<String>();
6885 : }
6886 1493 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6887 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
6888 2986 : LOG_API(i_isolate, String, NewExternalOneByte);
6889 1493 : if (resource->length() > 0) {
6890 : i::Handle<i::String> string = i_isolate->factory()
6891 : ->NewExternalStringFromOneByte(resource)
6892 2974 : .ToHandleChecked();
6893 : i_isolate->heap()->RegisterExternalString(*string);
6894 1487 : return Utils::ToLocal(string);
6895 : } else {
6896 : // The resource isn't going to be used, free it immediately.
6897 6 : resource->Dispose();
6898 6 : return Utils::ToLocal(i_isolate->factory()->empty_string());
6899 : }
6900 : }
6901 :
6902 :
6903 0 : Local<String> v8::String::NewExternal(
6904 : Isolate* isolate, v8::String::ExternalOneByteStringResource* resource) {
6905 0 : RETURN_TO_LOCAL_UNCHECKED(NewExternalOneByte(isolate, resource), String);
6906 : }
6907 :
6908 :
6909 31 : bool v8::String::MakeExternal(v8::String::ExternalStringResource* resource) {
6910 : i::Handle<i::String> obj = Utils::OpenHandle(this);
6911 : i::Isolate* isolate = obj->GetIsolate();
6912 31 : if (i::StringShape(*obj).IsExternal()) {
6913 : return false; // Already an external string.
6914 : }
6915 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
6916 31 : if (isolate->heap()->IsInGCPostProcessing()) {
6917 : return false;
6918 : }
6919 31 : CHECK(resource && resource->data());
6920 :
6921 31 : bool result = obj->MakeExternal(resource);
6922 : // Assert that if CanMakeExternal(), then externalizing actually succeeds.
6923 : DCHECK(!CanMakeExternal() || result);
6924 31 : if (result) {
6925 : DCHECK(obj->IsExternalString());
6926 : isolate->heap()->RegisterExternalString(*obj);
6927 : }
6928 31 : return result;
6929 : }
6930 :
6931 :
6932 37 : bool v8::String::MakeExternal(
6933 : v8::String::ExternalOneByteStringResource* resource) {
6934 : i::Handle<i::String> obj = Utils::OpenHandle(this);
6935 : i::Isolate* isolate = obj->GetIsolate();
6936 37 : if (i::StringShape(*obj).IsExternal()) {
6937 : return false; // Already an external string.
6938 : }
6939 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
6940 37 : if (isolate->heap()->IsInGCPostProcessing()) {
6941 : return false;
6942 : }
6943 37 : CHECK(resource && resource->data());
6944 :
6945 37 : bool result = obj->MakeExternal(resource);
6946 : // Assert that if CanMakeExternal(), then externalizing actually succeeds.
6947 : DCHECK(!CanMakeExternal() || result);
6948 37 : if (result) {
6949 : DCHECK(obj->IsExternalString());
6950 : isolate->heap()->RegisterExternalString(*obj);
6951 : }
6952 37 : return result;
6953 : }
6954 :
6955 :
6956 24 : bool v8::String::CanMakeExternal() {
6957 : i::Handle<i::String> obj = Utils::OpenHandle(this);
6958 24 : if (obj->IsExternalString()) return false;
6959 :
6960 : // Old space strings should be externalized.
6961 : i::Isolate* isolate = obj->GetIsolate();
6962 24 : return !isolate->heap()->new_space()->Contains(*obj);
6963 : }
6964 :
6965 :
6966 0 : Isolate* v8::Object::GetIsolate() {
6967 : i::Isolate* i_isolate = Utils::OpenHandle(this)->GetIsolate();
6968 0 : return reinterpret_cast<Isolate*>(i_isolate);
6969 : }
6970 :
6971 :
6972 88085 : Local<v8::Object> v8::Object::New(Isolate* isolate) {
6973 88085 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6974 176170 : LOG_API(i_isolate, Object, New);
6975 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
6976 : i::Handle<i::JSObject> obj =
6977 88085 : i_isolate->factory()->NewJSObject(i_isolate->object_function());
6978 88085 : return Utils::ToLocal(obj);
6979 : }
6980 :
6981 :
6982 7 : Local<v8::Value> v8::NumberObject::New(Isolate* isolate, double value) {
6983 7 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
6984 14 : LOG_API(i_isolate, NumberObject, New);
6985 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
6986 7 : i::Handle<i::Object> number = i_isolate->factory()->NewNumber(value);
6987 : i::Handle<i::Object> obj =
6988 14 : i::Object::ToObject(i_isolate, number).ToHandleChecked();
6989 7 : return Utils::ToLocal(obj);
6990 : }
6991 :
6992 :
6993 34 : double v8::NumberObject::ValueOf() const {
6994 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
6995 : i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
6996 34 : i::Isolate* isolate = jsvalue->GetIsolate();
6997 68 : LOG_API(isolate, NumberObject, NumberValue);
6998 34 : return jsvalue->value()->Number();
6999 : }
7000 :
7001 :
7002 28 : Local<v8::Value> v8::BooleanObject::New(Isolate* isolate, bool value) {
7003 28 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7004 56 : LOG_API(i_isolate, BooleanObject, New);
7005 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
7006 14 : i::Handle<i::Object> boolean(value ? i_isolate->heap()->true_value()
7007 14 : : i_isolate->heap()->false_value(),
7008 28 : i_isolate);
7009 : i::Handle<i::Object> obj =
7010 56 : i::Object::ToObject(i_isolate, boolean).ToHandleChecked();
7011 28 : return Utils::ToLocal(obj);
7012 : }
7013 :
7014 :
7015 0 : Local<v8::Value> v8::BooleanObject::New(bool value) {
7016 0 : return New(Isolate::GetCurrent(), value);
7017 : }
7018 :
7019 :
7020 55 : bool v8::BooleanObject::ValueOf() const {
7021 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
7022 : i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
7023 55 : i::Isolate* isolate = jsvalue->GetIsolate();
7024 110 : LOG_API(isolate, BooleanObject, BooleanValue);
7025 55 : return jsvalue->value()->IsTrue(isolate);
7026 : }
7027 :
7028 :
7029 14 : Local<v8::Value> v8::StringObject::New(Local<String> value) {
7030 : i::Handle<i::String> string = Utils::OpenHandle(*value);
7031 14 : i::Isolate* isolate = string->GetIsolate();
7032 28 : LOG_API(isolate, StringObject, New);
7033 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
7034 : i::Handle<i::Object> obj =
7035 28 : i::Object::ToObject(isolate, string).ToHandleChecked();
7036 14 : return Utils::ToLocal(obj);
7037 : }
7038 :
7039 :
7040 34 : Local<v8::String> v8::StringObject::ValueOf() const {
7041 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
7042 : i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
7043 34 : i::Isolate* isolate = jsvalue->GetIsolate();
7044 68 : LOG_API(isolate, StringObject, StringValue);
7045 : return Utils::ToLocal(
7046 34 : i::Handle<i::String>(i::String::cast(jsvalue->value())));
7047 : }
7048 :
7049 :
7050 7 : Local<v8::Value> v8::SymbolObject::New(Isolate* isolate, Local<Symbol> value) {
7051 7 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7052 14 : LOG_API(i_isolate, SymbolObject, New);
7053 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
7054 : i::Handle<i::Object> obj = i::Object::ToObject(
7055 14 : i_isolate, Utils::OpenHandle(*value)).ToHandleChecked();
7056 7 : return Utils::ToLocal(obj);
7057 : }
7058 :
7059 :
7060 13 : Local<v8::Symbol> v8::SymbolObject::ValueOf() const {
7061 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
7062 : i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
7063 13 : i::Isolate* isolate = jsvalue->GetIsolate();
7064 26 : LOG_API(isolate, SymbolObject, SymbolValue);
7065 : return Utils::ToLocal(
7066 13 : i::Handle<i::Symbol>(i::Symbol::cast(jsvalue->value())));
7067 : }
7068 :
7069 :
7070 154 : MaybeLocal<v8::Value> v8::Date::New(Local<Context> context, double time) {
7071 154 : if (std::isnan(time)) {
7072 : // Introduce only canonical NaN value into the VM, to avoid signaling NaNs.
7073 : time = std::numeric_limits<double>::quiet_NaN();
7074 : }
7075 616 : PREPARE_FOR_EXECUTION(context, Date, New, Value);
7076 : Local<Value> result;
7077 : has_pending_exception = !ToLocal<Value>(
7078 : i::JSDate::New(isolate->date_function(), isolate->date_function(), time),
7079 462 : &result);
7080 154 : RETURN_ON_FAILED_EXECUTION(Value);
7081 154 : RETURN_ESCAPED(result);
7082 : }
7083 :
7084 :
7085 0 : Local<v8::Value> v8::Date::New(Isolate* isolate, double time) {
7086 0 : auto context = isolate->GetCurrentContext();
7087 0 : RETURN_TO_LOCAL_UNCHECKED(New(context, time), Value);
7088 : }
7089 :
7090 :
7091 11 : double v8::Date::ValueOf() const {
7092 : i::Handle<i::Object> obj = Utils::OpenHandle(this);
7093 : i::Handle<i::JSDate> jsdate = i::Handle<i::JSDate>::cast(obj);
7094 11 : i::Isolate* isolate = jsdate->GetIsolate();
7095 22 : LOG_API(isolate, Date, NumberValue);
7096 11 : return jsdate->value()->Number();
7097 : }
7098 :
7099 :
7100 7 : void v8::Date::DateTimeConfigurationChangeNotification(Isolate* isolate) {
7101 21 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7102 14 : LOG_API(i_isolate, Date, DateTimeConfigurationChangeNotification);
7103 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
7104 7 : i_isolate->date_cache()->ResetDateCache();
7105 7 : if (!i_isolate->eternal_handles()->Exists(
7106 : i::EternalHandles::DATE_CACHE_VERSION)) {
7107 7 : return;
7108 : }
7109 : i::Handle<i::FixedArray> date_cache_version =
7110 : i::Handle<i::FixedArray>::cast(i_isolate->eternal_handles()->GetSingleton(
7111 : i::EternalHandles::DATE_CACHE_VERSION));
7112 : DCHECK_EQ(1, date_cache_version->length());
7113 7 : CHECK(date_cache_version->get(0)->IsSmi());
7114 : date_cache_version->set(
7115 : 0,
7116 7 : i::Smi::FromInt(i::Smi::cast(date_cache_version->get(0))->value() + 1));
7117 : }
7118 :
7119 :
7120 104 : MaybeLocal<v8::RegExp> v8::RegExp::New(Local<Context> context,
7121 : Local<String> pattern, Flags flags) {
7122 416 : PREPARE_FOR_EXECUTION(context, RegExp, New, RegExp);
7123 : Local<v8::RegExp> result;
7124 : has_pending_exception =
7125 : !ToLocal<RegExp>(i::JSRegExp::New(Utils::OpenHandle(*pattern),
7126 : static_cast<i::JSRegExp::Flags>(flags)),
7127 312 : &result);
7128 111 : RETURN_ON_FAILED_EXECUTION(RegExp);
7129 97 : RETURN_ESCAPED(result);
7130 : }
7131 :
7132 :
7133 0 : Local<v8::RegExp> v8::RegExp::New(Local<String> pattern, Flags flags) {
7134 : auto isolate =
7135 : reinterpret_cast<Isolate*>(Utils::OpenHandle(*pattern)->GetIsolate());
7136 0 : auto context = isolate->GetCurrentContext();
7137 0 : RETURN_TO_LOCAL_UNCHECKED(New(context, pattern, flags), RegExp);
7138 : }
7139 :
7140 :
7141 48 : Local<v8::String> v8::RegExp::GetSource() const {
7142 : i::Handle<i::JSRegExp> obj = Utils::OpenHandle(this);
7143 48 : return Utils::ToLocal(i::Handle<i::String>(obj->Pattern()));
7144 : }
7145 :
7146 :
7147 : // Assert that the static flags cast in GetFlags is valid.
7148 : #define REGEXP_FLAG_ASSERT_EQ(flag) \
7149 : STATIC_ASSERT(static_cast<int>(v8::RegExp::flag) == \
7150 : static_cast<int>(i::JSRegExp::flag))
7151 : REGEXP_FLAG_ASSERT_EQ(kNone);
7152 : REGEXP_FLAG_ASSERT_EQ(kGlobal);
7153 : REGEXP_FLAG_ASSERT_EQ(kIgnoreCase);
7154 : REGEXP_FLAG_ASSERT_EQ(kMultiline);
7155 : REGEXP_FLAG_ASSERT_EQ(kSticky);
7156 : REGEXP_FLAG_ASSERT_EQ(kUnicode);
7157 : #undef REGEXP_FLAG_ASSERT_EQ
7158 :
7159 48 : v8::RegExp::Flags v8::RegExp::GetFlags() const {
7160 : i::Handle<i::JSRegExp> obj = Utils::OpenHandle(this);
7161 48 : return RegExp::Flags(static_cast<int>(obj->GetFlags()));
7162 : }
7163 :
7164 :
7165 94414 : Local<v8::Array> v8::Array::New(Isolate* isolate, int length) {
7166 94414 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7167 188828 : LOG_API(i_isolate, Array, New);
7168 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
7169 94414 : int real_length = length > 0 ? length : 0;
7170 94414 : i::Handle<i::JSArray> obj = i_isolate->factory()->NewJSArray(real_length);
7171 : i::Handle<i::Object> length_obj =
7172 94414 : i_isolate->factory()->NewNumberFromInt(real_length);
7173 94414 : obj->set_length(*length_obj);
7174 94414 : return Utils::ToLocal(obj);
7175 : }
7176 :
7177 :
7178 9985814 : uint32_t v8::Array::Length() const {
7179 : i::Handle<i::JSArray> obj = Utils::OpenHandle(this);
7180 : i::Object* length = obj->length();
7181 9985814 : if (length->IsSmi()) {
7182 9985814 : return i::Smi::cast(length)->value();
7183 : } else {
7184 0 : return static_cast<uint32_t>(length->Number());
7185 : }
7186 : }
7187 :
7188 :
7189 0 : MaybeLocal<Object> Array::CloneElementAt(Local<Context> context,
7190 : uint32_t index) {
7191 0 : PREPARE_FOR_EXECUTION(context, Array, CloneElementAt, Object);
7192 : auto self = Utils::OpenHandle(this);
7193 0 : if (!self->HasFastObjectElements()) return Local<Object>();
7194 : i::FixedArray* elms = i::FixedArray::cast(self->elements());
7195 0 : i::Object* paragon = elms->get(index);
7196 0 : if (!paragon->IsJSObject()) return Local<Object>();
7197 : i::Handle<i::JSObject> paragon_handle(i::JSObject::cast(paragon));
7198 : Local<Object> result;
7199 : has_pending_exception =
7200 : !ToLocal<Object>(isolate->factory()->CopyJSObject(paragon_handle),
7201 0 : &result);
7202 0 : RETURN_ON_FAILED_EXECUTION(Object);
7203 0 : RETURN_ESCAPED(result);
7204 : }
7205 :
7206 :
7207 0 : Local<Object> Array::CloneElementAt(uint32_t index) { return Local<Object>(); }
7208 :
7209 :
7210 6 : Local<v8::Map> v8::Map::New(Isolate* isolate) {
7211 6 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7212 12 : LOG_API(i_isolate, Map, New);
7213 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
7214 6 : i::Handle<i::JSMap> obj = i_isolate->factory()->NewJSMap();
7215 6 : return Utils::ToLocal(obj);
7216 : }
7217 :
7218 :
7219 42 : size_t v8::Map::Size() const {
7220 : i::Handle<i::JSMap> obj = Utils::OpenHandle(this);
7221 42 : return i::OrderedHashMap::cast(obj->table())->NumberOfElements();
7222 : }
7223 :
7224 :
7225 6 : void Map::Clear() {
7226 : auto self = Utils::OpenHandle(this);
7227 6 : i::Isolate* isolate = self->GetIsolate();
7228 12 : LOG_API(isolate, Map, Clear);
7229 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
7230 6 : i::JSMap::Clear(self);
7231 6 : }
7232 :
7233 :
7234 18 : MaybeLocal<Value> Map::Get(Local<Context> context, Local<Value> key) {
7235 72 : PREPARE_FOR_EXECUTION(context, Map, Get, Value);
7236 : auto self = Utils::OpenHandle(this);
7237 : Local<Value> result;
7238 18 : i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
7239 : has_pending_exception =
7240 : !ToLocal<Value>(i::Execution::Call(isolate, isolate->map_get(), self,
7241 : arraysize(argv), argv),
7242 54 : &result);
7243 18 : RETURN_ON_FAILED_EXECUTION(Value);
7244 18 : RETURN_ESCAPED(result);
7245 : }
7246 :
7247 :
7248 6 : MaybeLocal<Map> Map::Set(Local<Context> context, Local<Value> key,
7249 : Local<Value> value) {
7250 24 : PREPARE_FOR_EXECUTION(context, Map, Set, Map);
7251 : auto self = Utils::OpenHandle(this);
7252 : i::Handle<i::Object> result;
7253 : i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key),
7254 12 : Utils::OpenHandle(*value)};
7255 : has_pending_exception = !i::Execution::Call(isolate, isolate->map_set(), self,
7256 : arraysize(argv), argv)
7257 18 : .ToHandle(&result);
7258 6 : RETURN_ON_FAILED_EXECUTION(Map);
7259 6 : RETURN_ESCAPED(Local<Map>::Cast(Utils::ToLocal(result)));
7260 : }
7261 :
7262 :
7263 36 : Maybe<bool> Map::Has(Local<Context> context, Local<Value> key) {
7264 144 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Map, Has, bool);
7265 : auto self = Utils::OpenHandle(this);
7266 : i::Handle<i::Object> result;
7267 36 : i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
7268 : has_pending_exception = !i::Execution::Call(isolate, isolate->map_has(), self,
7269 : arraysize(argv), argv)
7270 108 : .ToHandle(&result);
7271 36 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
7272 : return Just(result->IsTrue(isolate));
7273 : }
7274 :
7275 :
7276 18 : Maybe<bool> Map::Delete(Local<Context> context, Local<Value> key) {
7277 72 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Map, Delete, bool);
7278 : auto self = Utils::OpenHandle(this);
7279 : i::Handle<i::Object> result;
7280 18 : i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
7281 : has_pending_exception = !i::Execution::Call(isolate, isolate->map_delete(),
7282 : self, arraysize(argv), argv)
7283 54 : .ToHandle(&result);
7284 18 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
7285 : return Just(result->IsTrue(isolate));
7286 : }
7287 :
7288 : namespace {
7289 140 : i::Handle<i::JSArray> MapAsArray(i::Isolate* isolate, i::Object* table_obj,
7290 : int offset, int kind) {
7291 : i::Factory* factory = isolate->factory();
7292 : i::Handle<i::OrderedHashMap> table(i::OrderedHashMap::cast(table_obj));
7293 140 : if (offset >= table->NumberOfElements()) return factory->NewJSArray(0);
7294 120 : int length = (table->NumberOfElements() - offset) *
7295 120 : (kind == i::JSMapIterator::kKindEntries ? 2 : 1);
7296 120 : i::Handle<i::FixedArray> result = factory->NewFixedArray(length);
7297 : int result_index = 0;
7298 : {
7299 : i::DisallowHeapAllocation no_gc;
7300 120 : int capacity = table->UsedCapacity();
7301 120 : i::Oddball* the_hole = isolate->heap()->the_hole_value();
7302 6390 : for (int i = 0; i < capacity; ++i) {
7303 6270 : i::Object* key = table->KeyAt(i);
7304 6270 : if (key == the_hole) continue;
7305 6264 : if (offset-- > 0) continue;
7306 12492 : if (kind == i::JSMapIterator::kKindEntries ||
7307 6246 : kind == i::JSMapIterator::kKindKeys) {
7308 12424 : result->set(result_index++, key);
7309 : }
7310 6246 : if (kind == i::JSMapIterator::kKindEntries ||
7311 : kind == i::JSMapIterator::kKindValues) {
7312 12424 : result->set(result_index++, table->ValueAt(i));
7313 : }
7314 : }
7315 : }
7316 : DCHECK_EQ(result_index, result->length());
7317 : DCHECK_EQ(result_index, length);
7318 120 : return factory->NewJSArrayWithElements(result, i::FAST_ELEMENTS, length);
7319 : }
7320 : } // namespace
7321 :
7322 62 : Local<Array> Map::AsArray() const {
7323 : i::Handle<i::JSMap> obj = Utils::OpenHandle(this);
7324 62 : i::Isolate* isolate = obj->GetIsolate();
7325 124 : LOG_API(isolate, Map, AsArray);
7326 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
7327 : return Utils::ToLocal(
7328 124 : MapAsArray(isolate, obj->table(), 0, i::JSMapIterator::kKindEntries));
7329 : }
7330 :
7331 :
7332 414 : Local<v8::Set> v8::Set::New(Isolate* isolate) {
7333 414 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7334 828 : LOG_API(i_isolate, Set, New);
7335 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
7336 414 : i::Handle<i::JSSet> obj = i_isolate->factory()->NewJSSet();
7337 414 : return Utils::ToLocal(obj);
7338 : }
7339 :
7340 :
7341 42 : size_t v8::Set::Size() const {
7342 : i::Handle<i::JSSet> obj = Utils::OpenHandle(this);
7343 42 : return i::OrderedHashSet::cast(obj->table())->NumberOfElements();
7344 : }
7345 :
7346 :
7347 6 : void Set::Clear() {
7348 : auto self = Utils::OpenHandle(this);
7349 6 : i::Isolate* isolate = self->GetIsolate();
7350 12 : LOG_API(isolate, Set, Clear);
7351 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
7352 6 : i::JSSet::Clear(self);
7353 6 : }
7354 :
7355 :
7356 6954 : MaybeLocal<Set> Set::Add(Local<Context> context, Local<Value> key) {
7357 27816 : PREPARE_FOR_EXECUTION(context, Set, Add, Set);
7358 : auto self = Utils::OpenHandle(this);
7359 : i::Handle<i::Object> result;
7360 6954 : i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
7361 : has_pending_exception = !i::Execution::Call(isolate, isolate->set_add(), self,
7362 : arraysize(argv), argv)
7363 20862 : .ToHandle(&result);
7364 6954 : RETURN_ON_FAILED_EXECUTION(Set);
7365 6954 : RETURN_ESCAPED(Local<Set>::Cast(Utils::ToLocal(result)));
7366 : }
7367 :
7368 :
7369 36 : Maybe<bool> Set::Has(Local<Context> context, Local<Value> key) {
7370 144 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Set, Has, bool);
7371 : auto self = Utils::OpenHandle(this);
7372 : i::Handle<i::Object> result;
7373 36 : i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
7374 : has_pending_exception = !i::Execution::Call(isolate, isolate->set_has(), self,
7375 : arraysize(argv), argv)
7376 108 : .ToHandle(&result);
7377 36 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
7378 : return Just(result->IsTrue(isolate));
7379 : }
7380 :
7381 :
7382 84 : Maybe<bool> Set::Delete(Local<Context> context, Local<Value> key) {
7383 336 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Set, Delete, bool);
7384 : auto self = Utils::OpenHandle(this);
7385 : i::Handle<i::Object> result;
7386 84 : i::Handle<i::Object> argv[] = {Utils::OpenHandle(*key)};
7387 : has_pending_exception = !i::Execution::Call(isolate, isolate->set_delete(),
7388 : self, arraysize(argv), argv)
7389 252 : .ToHandle(&result);
7390 84 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
7391 : return Just(result->IsTrue(isolate));
7392 : }
7393 :
7394 : namespace {
7395 510 : i::Handle<i::JSArray> SetAsArray(i::Isolate* isolate, i::Object* table_obj,
7396 : int offset) {
7397 : i::Factory* factory = isolate->factory();
7398 : i::Handle<i::OrderedHashSet> table(i::OrderedHashSet::cast(table_obj));
7399 510 : int length = table->NumberOfElements() - offset;
7400 510 : if (length <= 0) return factory->NewJSArray(0);
7401 504 : i::Handle<i::FixedArray> result = factory->NewFixedArray(length);
7402 : int result_index = 0;
7403 : {
7404 : i::DisallowHeapAllocation no_gc;
7405 504 : int capacity = table->UsedCapacity();
7406 504 : i::Oddball* the_hole = isolate->heap()->the_hole_value();
7407 13776 : for (int i = 0; i < capacity; ++i) {
7408 13272 : i::Object* key = table->KeyAt(i);
7409 13272 : if (key == the_hole) continue;
7410 13200 : if (offset-- > 0) continue;
7411 26364 : result->set(result_index++, key);
7412 : }
7413 : }
7414 : DCHECK_EQ(result_index, result->length());
7415 : DCHECK_EQ(result_index, length);
7416 504 : return factory->NewJSArrayWithElements(result, i::FAST_ELEMENTS, length);
7417 : }
7418 : } // namespace
7419 :
7420 474 : Local<Array> Set::AsArray() const {
7421 : i::Handle<i::JSSet> obj = Utils::OpenHandle(this);
7422 474 : i::Isolate* isolate = obj->GetIsolate();
7423 948 : LOG_API(isolate, Set, AsArray);
7424 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
7425 948 : return Utils::ToLocal(SetAsArray(isolate, obj->table(), 0));
7426 : }
7427 :
7428 :
7429 12486 : MaybeLocal<Promise::Resolver> Promise::Resolver::New(Local<Context> context) {
7430 49944 : PREPARE_FOR_EXECUTION(context, Promise_Resolver, New, Resolver);
7431 : i::Handle<i::Object> result;
7432 : has_pending_exception =
7433 : !i::Execution::Call(isolate, isolate->promise_internal_constructor(),
7434 : isolate->factory()->undefined_value(), 0, NULL)
7435 37458 : .ToHandle(&result);
7436 12501 : RETURN_ON_FAILED_EXECUTION(Promise::Resolver);
7437 12471 : RETURN_ESCAPED(Local<Promise::Resolver>::Cast(Utils::ToLocal(result)));
7438 : }
7439 :
7440 :
7441 0 : Local<Promise::Resolver> Promise::Resolver::New(Isolate* isolate) {
7442 0 : RETURN_TO_LOCAL_UNCHECKED(New(isolate->GetCurrentContext()),
7443 : Promise::Resolver);
7444 : }
7445 :
7446 :
7447 13395 : Local<Promise> Promise::Resolver::GetPromise() {
7448 : i::Handle<i::JSReceiver> promise = Utils::OpenHandle(this);
7449 13395 : return Local<Promise>::Cast(Utils::ToLocal(promise));
7450 : }
7451 :
7452 :
7453 960 : Maybe<bool> Promise::Resolver::Resolve(Local<Context> context,
7454 : Local<Value> value) {
7455 3840 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Promise_Resolver, Resolve, bool);
7456 : auto self = Utils::OpenHandle(this);
7457 960 : i::Handle<i::Object> argv[] = {self, Utils::OpenHandle(*value)};
7458 : has_pending_exception =
7459 : i::Execution::Call(isolate, isolate->promise_resolve(),
7460 : isolate->factory()->undefined_value(), arraysize(argv),
7461 : argv)
7462 2880 : .is_null();
7463 960 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
7464 : return Just(true);
7465 : }
7466 :
7467 :
7468 0 : void Promise::Resolver::Resolve(Local<Value> value) {
7469 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
7470 0 : USE(Resolve(context, value));
7471 0 : }
7472 :
7473 :
7474 10836 : Maybe<bool> Promise::Resolver::Reject(Local<Context> context,
7475 : Local<Value> value) {
7476 43344 : PREPARE_FOR_EXECUTION_PRIMITIVE(context, Promise_Resolver, Resolve, bool);
7477 : auto self = Utils::OpenHandle(this);
7478 :
7479 : // We pass true to trigger the debugger's on exception handler.
7480 : i::Handle<i::Object> argv[] = {self, Utils::OpenHandle(*value),
7481 10836 : isolate->factory()->ToBoolean(true)};
7482 : has_pending_exception =
7483 : i::Execution::Call(isolate, isolate->promise_internal_reject(),
7484 : isolate->factory()->undefined_value(), arraysize(argv),
7485 : argv)
7486 32508 : .is_null();
7487 10836 : RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
7488 : return Just(true);
7489 : }
7490 :
7491 :
7492 0 : void Promise::Resolver::Reject(Local<Value> value) {
7493 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
7494 0 : USE(Reject(context, value));
7495 0 : }
7496 :
7497 :
7498 432 : MaybeLocal<Promise> Promise::Catch(Local<Context> context,
7499 : Local<Function> handler) {
7500 1728 : PREPARE_FOR_EXECUTION(context, Promise, Catch, Promise);
7501 : auto self = Utils::OpenHandle(this);
7502 : i::Handle<i::Object> argv[] = { Utils::OpenHandle(*handler) };
7503 : i::Handle<i::Object> result;
7504 : has_pending_exception = !i::Execution::Call(isolate, isolate->promise_catch(),
7505 : self, arraysize(argv), argv)
7506 1296 : .ToHandle(&result);
7507 432 : RETURN_ON_FAILED_EXECUTION(Promise);
7508 432 : RETURN_ESCAPED(Local<Promise>::Cast(Utils::ToLocal(result)));
7509 : }
7510 :
7511 :
7512 0 : Local<Promise> Promise::Catch(Local<Function> handler) {
7513 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
7514 0 : RETURN_TO_LOCAL_UNCHECKED(Catch(context, handler), Promise);
7515 : }
7516 :
7517 :
7518 1296 : MaybeLocal<Promise> Promise::Then(Local<Context> context,
7519 : Local<Function> handler) {
7520 5184 : PREPARE_FOR_EXECUTION(context, Promise, Then, Promise);
7521 : auto self = Utils::OpenHandle(this);
7522 : i::Handle<i::Object> argv[] = { Utils::OpenHandle(*handler) };
7523 : i::Handle<i::Object> result;
7524 : has_pending_exception = !i::Execution::Call(isolate, isolate->promise_then(),
7525 : self, arraysize(argv), argv)
7526 3888 : .ToHandle(&result);
7527 1296 : RETURN_ON_FAILED_EXECUTION(Promise);
7528 1296 : RETURN_ESCAPED(Local<Promise>::Cast(Utils::ToLocal(result)));
7529 : }
7530 :
7531 :
7532 0 : Local<Promise> Promise::Then(Local<Function> handler) {
7533 0 : auto context = ContextFromHeapObject(Utils::OpenHandle(this));
7534 0 : RETURN_TO_LOCAL_UNCHECKED(Then(context, handler), Promise);
7535 : }
7536 :
7537 :
7538 372 : bool Promise::HasHandler() {
7539 : i::Handle<i::JSReceiver> promise = Utils::OpenHandle(this);
7540 372 : i::Isolate* isolate = promise->GetIsolate();
7541 744 : LOG_API(isolate, Promise, HasRejectHandler);
7542 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
7543 372 : if (promise->IsJSPromise()) {
7544 : i::Handle<i::JSPromise> js_promise = i::Handle<i::JSPromise>::cast(promise);
7545 : return js_promise->has_handler();
7546 : }
7547 : return false;
7548 : }
7549 :
7550 12 : Local<Value> Promise::Result() {
7551 : i::Handle<i::JSReceiver> promise = Utils::OpenHandle(this);
7552 12 : i::Isolate* isolate = promise->GetIsolate();
7553 24 : LOG_API(isolate, Promise, Result);
7554 : i::Handle<i::JSPromise> js_promise = i::Handle<i::JSPromise>::cast(promise);
7555 : Utils::ApiCheck(js_promise->status() != kPending, "v8_Promise_Result",
7556 : "Promise is still pending");
7557 : i::Handle<i::Object> result(js_promise->result(), isolate);
7558 12 : return Utils::ToLocal(result);
7559 : }
7560 :
7561 24 : Promise::PromiseState Promise::State() {
7562 : i::Handle<i::JSReceiver> promise = Utils::OpenHandle(this);
7563 24 : i::Isolate* isolate = promise->GetIsolate();
7564 48 : LOG_API(isolate, Promise, Status);
7565 : i::Handle<i::JSPromise> js_promise = i::Handle<i::JSPromise>::cast(promise);
7566 48 : return static_cast<PromiseState>(js_promise->status());
7567 : }
7568 :
7569 12 : Local<Object> Proxy::GetTarget() {
7570 : i::Handle<i::JSProxy> self = Utils::OpenHandle(this);
7571 : i::Handle<i::JSReceiver> target(self->target());
7572 12 : return Utils::ToLocal(target);
7573 : }
7574 :
7575 :
7576 12 : Local<Value> Proxy::GetHandler() {
7577 : i::Handle<i::JSProxy> self = Utils::OpenHandle(this);
7578 : i::Handle<i::Object> handler(self->handler(), self->GetIsolate());
7579 12 : return Utils::ToLocal(handler);
7580 : }
7581 :
7582 :
7583 12 : bool Proxy::IsRevoked() {
7584 : i::Handle<i::JSProxy> self = Utils::OpenHandle(this);
7585 12 : return self->IsRevoked();
7586 : }
7587 :
7588 :
7589 6 : void Proxy::Revoke() {
7590 6 : i::Handle<i::JSProxy> self = Utils::OpenHandle(this);
7591 6 : i::JSProxy::Revoke(self);
7592 6 : }
7593 :
7594 :
7595 20 : MaybeLocal<Proxy> Proxy::New(Local<Context> context, Local<Object> local_target,
7596 : Local<Object> local_handler) {
7597 80 : PREPARE_FOR_EXECUTION(context, Proxy, New, Proxy);
7598 : i::Handle<i::JSReceiver> target = Utils::OpenHandle(*local_target);
7599 : i::Handle<i::JSReceiver> handler = Utils::OpenHandle(*local_handler);
7600 : Local<Proxy> result;
7601 : has_pending_exception =
7602 40 : !ToLocal<Proxy>(i::JSProxy::New(isolate, target, handler), &result);
7603 20 : RETURN_ON_FAILED_EXECUTION(Proxy);
7604 20 : RETURN_ESCAPED(result);
7605 : }
7606 :
7607 93 : Local<String> WasmCompiledModule::GetWasmWireBytes() {
7608 : i::Handle<i::JSObject> obj =
7609 : i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
7610 : i::Handle<i::WasmCompiledModule> compiled_part =
7611 : i::handle(i::WasmCompiledModule::cast(obj->GetEmbedderField(0)));
7612 93 : i::Handle<i::String> wire_bytes(compiled_part->module_bytes());
7613 93 : return Local<String>::Cast(Utils::ToLocal(wire_bytes));
7614 : }
7615 :
7616 : // Currently, wasm modules are bound, both to Isolate and to
7617 : // the Context they were created in. The currently-supported means to
7618 : // decontextualize and then re-contextualize a module is via
7619 : // serialization/deserialization.
7620 : WasmCompiledModule::TransferrableModule
7621 13 : WasmCompiledModule::GetTransferrableModule() {
7622 : i::DisallowHeapAllocation no_gc;
7623 13 : WasmCompiledModule::SerializedModule compiled_part = Serialize();
7624 :
7625 13 : Local<String> wire_bytes = GetWasmWireBytes();
7626 13 : size_t wire_size = static_cast<size_t>(wire_bytes->Length());
7627 13 : uint8_t* bytes = new uint8_t[wire_size];
7628 : wire_bytes->WriteOneByte(bytes, 0, wire_bytes->Length());
7629 :
7630 : return TransferrableModule(
7631 : std::move(compiled_part),
7632 : std::make_pair(
7633 : std::unique_ptr<const uint8_t[]>(const_cast<const uint8_t*>(bytes)),
7634 13 : wire_size));
7635 : }
7636 :
7637 11 : MaybeLocal<WasmCompiledModule> WasmCompiledModule::FromTransferrableModule(
7638 : Isolate* isolate,
7639 : const WasmCompiledModule::TransferrableModule& transferrable_module) {
7640 : MaybeLocal<WasmCompiledModule> ret =
7641 : Deserialize(isolate, AsCallerOwned(transferrable_module.compiled_code),
7642 22 : AsCallerOwned(transferrable_module.wire_bytes));
7643 11 : return ret;
7644 : }
7645 :
7646 55 : WasmCompiledModule::SerializedModule WasmCompiledModule::Serialize() {
7647 : i::Handle<i::JSObject> obj =
7648 : i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
7649 : i::Handle<i::WasmCompiledModule> compiled_part =
7650 : i::handle(i::WasmCompiledModule::cast(obj->GetEmbedderField(0)));
7651 :
7652 : std::unique_ptr<i::ScriptData> script_data =
7653 : i::WasmCompiledModuleSerializer::SerializeWasmModule(obj->GetIsolate(),
7654 55 : compiled_part);
7655 : script_data->ReleaseDataOwnership();
7656 :
7657 55 : size_t size = static_cast<size_t>(script_data->length());
7658 110 : return {std::unique_ptr<const uint8_t[]>(script_data->data()), size};
7659 : }
7660 :
7661 65 : MaybeLocal<WasmCompiledModule> WasmCompiledModule::Deserialize(
7662 : Isolate* isolate,
7663 : const WasmCompiledModule::CallerOwnedBuffer& serialized_module,
7664 : const WasmCompiledModule::CallerOwnedBuffer& wire_bytes) {
7665 65 : int size = static_cast<int>(serialized_module.second);
7666 65 : i::ScriptData sc(serialized_module.first, size);
7667 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7668 : i::MaybeHandle<i::FixedArray> maybe_compiled_part =
7669 : i::WasmCompiledModuleSerializer::DeserializeWasmModule(
7670 : i_isolate, &sc,
7671 130 : {wire_bytes.first, static_cast<int>(wire_bytes.second)});
7672 : i::Handle<i::FixedArray> compiled_part;
7673 65 : if (!maybe_compiled_part.ToHandle(&compiled_part)) {
7674 47 : return MaybeLocal<WasmCompiledModule>();
7675 : }
7676 : i::Handle<i::WasmCompiledModule> compiled_module =
7677 18 : handle(i::WasmCompiledModule::cast(*compiled_part));
7678 : return Local<WasmCompiledModule>::Cast(
7679 : Utils::ToLocal(i::Handle<i::JSObject>::cast(
7680 18 : i::WasmModuleObject::New(i_isolate, compiled_module))));
7681 : }
7682 :
7683 54 : MaybeLocal<WasmCompiledModule> WasmCompiledModule::DeserializeOrCompile(
7684 : Isolate* isolate,
7685 : const WasmCompiledModule::CallerOwnedBuffer& serialized_module,
7686 : const WasmCompiledModule::CallerOwnedBuffer& wire_bytes) {
7687 : MaybeLocal<WasmCompiledModule> ret =
7688 54 : Deserialize(isolate, serialized_module, wire_bytes);
7689 54 : if (!ret.IsEmpty()) {
7690 7 : return ret;
7691 : }
7692 47 : return Compile(isolate, wire_bytes.first, wire_bytes.second);
7693 : }
7694 :
7695 61 : MaybeLocal<WasmCompiledModule> WasmCompiledModule::Compile(Isolate* isolate,
7696 : const uint8_t* start,
7697 : size_t length) {
7698 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7699 : i::wasm::ErrorThrower thrower(i_isolate, "WasmCompiledModule::Deserialize()");
7700 : i::MaybeHandle<i::JSObject> maybe_compiled = i::wasm::SyncCompile(
7701 183 : i_isolate, &thrower, i::wasm::ModuleWireBytes(start, start + length));
7702 61 : if (maybe_compiled.is_null()) return MaybeLocal<WasmCompiledModule>();
7703 : return Local<WasmCompiledModule>::Cast(
7704 40 : Utils::ToLocal(maybe_compiled.ToHandleChecked()));
7705 : }
7706 :
7707 28 : void WasmModuleObjectBuilder::OnBytesReceived(const uint8_t* bytes,
7708 : size_t size) {
7709 28 : std::unique_ptr<uint8_t[]> cloned_bytes(new uint8_t[size]);
7710 : memcpy(cloned_bytes.get(), bytes, size);
7711 : received_buffers_.push_back(
7712 : Buffer(std::unique_ptr<const uint8_t[]>(
7713 : const_cast<const uint8_t*>(cloned_bytes.release())),
7714 56 : size));
7715 28 : total_size_ += size;
7716 28 : }
7717 :
7718 14 : MaybeLocal<WasmCompiledModule> WasmModuleObjectBuilder::Finish() {
7719 14 : std::unique_ptr<uint8_t[]> wire_bytes(new uint8_t[total_size_]);
7720 : uint8_t* insert_at = wire_bytes.get();
7721 :
7722 84 : for (size_t i = 0; i < received_buffers_.size(); ++i) {
7723 42 : const Buffer& buff = received_buffers_[i];
7724 28 : memcpy(insert_at, buff.first.get(), buff.second);
7725 28 : insert_at += buff.second;
7726 : }
7727 28 : return WasmCompiledModule::Compile(isolate_, wire_bytes.get(), total_size_);
7728 : }
7729 :
7730 : // static
7731 3829 : v8::ArrayBuffer::Allocator* v8::ArrayBuffer::Allocator::NewDefaultAllocator() {
7732 7658 : return new ArrayBufferAllocator();
7733 : }
7734 :
7735 90 : bool v8::ArrayBuffer::IsExternal() const {
7736 90 : return Utils::OpenHandle(this)->is_external();
7737 : }
7738 :
7739 :
7740 56 : bool v8::ArrayBuffer::IsNeuterable() const {
7741 56 : return Utils::OpenHandle(this)->is_neuterable();
7742 : }
7743 :
7744 :
7745 90 : v8::ArrayBuffer::Contents v8::ArrayBuffer::Externalize() {
7746 : i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
7747 : i::Isolate* isolate = self->GetIsolate();
7748 : Utils::ApiCheck(!self->is_external(), "v8_ArrayBuffer_Externalize",
7749 : "ArrayBuffer already externalized");
7750 : self->set_is_external(true);
7751 90 : isolate->heap()->UnregisterArrayBuffer(*self);
7752 :
7753 90 : return GetContents();
7754 : }
7755 :
7756 :
7757 13188 : v8::ArrayBuffer::Contents v8::ArrayBuffer::GetContents() {
7758 : i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
7759 13278 : size_t byte_length = static_cast<size_t>(self->byte_length()->Number());
7760 : Contents contents;
7761 : contents.data_ = self->backing_store();
7762 : contents.byte_length_ = byte_length;
7763 13188 : return contents;
7764 : }
7765 :
7766 :
7767 53 : void v8::ArrayBuffer::Neuter() {
7768 : i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
7769 53 : i::Isolate* isolate = obj->GetIsolate();
7770 : Utils::ApiCheck(obj->is_external(),
7771 : "v8::ArrayBuffer::Neuter",
7772 : "Only externalized ArrayBuffers can be neutered");
7773 : Utils::ApiCheck(obj->is_neuterable(), "v8::ArrayBuffer::Neuter",
7774 : "Only neuterable ArrayBuffers can be neutered");
7775 106 : LOG_API(isolate, ArrayBuffer, Neuter);
7776 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
7777 53 : obj->Neuter();
7778 53 : }
7779 :
7780 :
7781 152 : size_t v8::ArrayBuffer::ByteLength() const {
7782 : i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
7783 152 : return static_cast<size_t>(obj->byte_length()->Number());
7784 : }
7785 :
7786 :
7787 110 : Local<ArrayBuffer> v8::ArrayBuffer::New(Isolate* isolate, size_t byte_length) {
7788 110 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7789 220 : LOG_API(i_isolate, ArrayBuffer, New);
7790 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
7791 : i::Handle<i::JSArrayBuffer> obj =
7792 110 : i_isolate->factory()->NewJSArrayBuffer(i::SharedFlag::kNotShared);
7793 : // TODO(jbroman): It may be useful in the future to provide a MaybeLocal
7794 : // version that throws an exception or otherwise does not crash.
7795 110 : if (!i::JSArrayBuffer::SetupAllocatingData(obj, i_isolate, byte_length)) {
7796 0 : i::FatalProcessOutOfMemory("v8::ArrayBuffer::New");
7797 : }
7798 110 : return Utils::ToLocal(obj);
7799 : }
7800 :
7801 :
7802 173 : Local<ArrayBuffer> v8::ArrayBuffer::New(Isolate* isolate, void* data,
7803 : size_t byte_length,
7804 : ArrayBufferCreationMode mode) {
7805 : // Embedders must guarantee that the external backing store is valid.
7806 173 : CHECK(byte_length == 0 || data != NULL);
7807 173 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7808 346 : LOG_API(i_isolate, ArrayBuffer, New);
7809 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
7810 : i::Handle<i::JSArrayBuffer> obj =
7811 173 : i_isolate->factory()->NewJSArrayBuffer(i::SharedFlag::kNotShared);
7812 : i::JSArrayBuffer::Setup(obj, i_isolate,
7813 : mode == ArrayBufferCreationMode::kExternalized, data,
7814 173 : byte_length);
7815 173 : return Utils::ToLocal(obj);
7816 : }
7817 :
7818 :
7819 1192 : Local<ArrayBuffer> v8::ArrayBufferView::Buffer() {
7820 : i::Handle<i::JSArrayBufferView> obj = Utils::OpenHandle(this);
7821 : i::Handle<i::JSArrayBuffer> buffer;
7822 1192 : if (obj->IsJSDataView()) {
7823 : i::Handle<i::JSDataView> data_view(i::JSDataView::cast(*obj));
7824 : DCHECK(data_view->buffer()->IsJSArrayBuffer());
7825 : buffer = i::handle(i::JSArrayBuffer::cast(data_view->buffer()));
7826 : } else {
7827 : DCHECK(obj->IsJSTypedArray());
7828 1176 : buffer = i::JSTypedArray::cast(*obj)->GetBuffer();
7829 : }
7830 1192 : return Utils::ToLocal(buffer);
7831 : }
7832 :
7833 :
7834 21 : size_t v8::ArrayBufferView::CopyContents(void* dest, size_t byte_length) {
7835 : i::Handle<i::JSArrayBufferView> self = Utils::OpenHandle(this);
7836 21 : size_t byte_offset = i::NumberToSize(self->byte_offset());
7837 : size_t bytes_to_copy =
7838 21 : i::Min(byte_length, i::NumberToSize(self->byte_length()));
7839 21 : if (bytes_to_copy) {
7840 : i::DisallowHeapAllocation no_gc;
7841 : i::Handle<i::JSArrayBuffer> buffer(i::JSArrayBuffer::cast(self->buffer()));
7842 : const char* source = reinterpret_cast<char*>(buffer->backing_store());
7843 21 : if (source == nullptr) {
7844 : DCHECK(self->IsJSTypedArray());
7845 : i::Handle<i::JSTypedArray> typed_array(i::JSTypedArray::cast(*self));
7846 : i::Handle<i::FixedTypedArrayBase> fixed_array(
7847 : i::FixedTypedArrayBase::cast(typed_array->elements()));
7848 : source = reinterpret_cast<char*>(fixed_array->DataPtr());
7849 : }
7850 21 : memcpy(dest, source + byte_offset, bytes_to_copy);
7851 : }
7852 21 : return bytes_to_copy;
7853 : }
7854 :
7855 :
7856 42 : bool v8::ArrayBufferView::HasBuffer() const {
7857 : i::Handle<i::JSArrayBufferView> self = Utils::OpenHandle(this);
7858 : i::Handle<i::JSArrayBuffer> buffer(i::JSArrayBuffer::cast(self->buffer()));
7859 42 : return buffer->backing_store() != nullptr;
7860 : }
7861 :
7862 :
7863 1402 : size_t v8::ArrayBufferView::ByteOffset() {
7864 : i::Handle<i::JSArrayBufferView> obj = Utils::OpenHandle(this);
7865 1402 : return static_cast<size_t>(obj->byte_offset()->Number());
7866 : }
7867 :
7868 :
7869 1419 : size_t v8::ArrayBufferView::ByteLength() {
7870 : i::Handle<i::JSArrayBufferView> obj = Utils::OpenHandle(this);
7871 1419 : return static_cast<size_t>(obj->byte_length()->Number());
7872 : }
7873 :
7874 :
7875 332 : size_t v8::TypedArray::Length() {
7876 : i::Handle<i::JSTypedArray> obj = Utils::OpenHandle(this);
7877 332 : return static_cast<size_t>(obj->length_value());
7878 : }
7879 :
7880 : #define TYPED_ARRAY_NEW(Type, type, TYPE, ctype, size) \
7881 : Local<Type##Array> Type##Array::New(Local<ArrayBuffer> array_buffer, \
7882 : size_t byte_offset, size_t length) { \
7883 : i::Isolate* isolate = Utils::OpenHandle(*array_buffer)->GetIsolate(); \
7884 : LOG_API(isolate, Type##Array, New); \
7885 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate); \
7886 : if (!Utils::ApiCheck(length <= static_cast<size_t>(i::Smi::kMaxValue), \
7887 : "v8::" #Type \
7888 : "Array::New(Local<ArrayBuffer>, size_t, size_t)", \
7889 : "length exceeds max allowed value")) { \
7890 : return Local<Type##Array>(); \
7891 : } \
7892 : i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*array_buffer); \
7893 : i::Handle<i::JSTypedArray> obj = isolate->factory()->NewJSTypedArray( \
7894 : i::kExternal##Type##Array, buffer, byte_offset, length); \
7895 : return Utils::ToLocal##Type##Array(obj); \
7896 : } \
7897 : Local<Type##Array> Type##Array::New( \
7898 : Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, \
7899 : size_t length) { \
7900 : CHECK(i::FLAG_harmony_sharedarraybuffer); \
7901 : i::Isolate* isolate = \
7902 : Utils::OpenHandle(*shared_array_buffer)->GetIsolate(); \
7903 : LOG_API(isolate, Type##Array, New); \
7904 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate); \
7905 : if (!Utils::ApiCheck( \
7906 : length <= static_cast<size_t>(i::Smi::kMaxValue), \
7907 : "v8::" #Type \
7908 : "Array::New(Local<SharedArrayBuffer>, size_t, size_t)", \
7909 : "length exceeds max allowed value")) { \
7910 : return Local<Type##Array>(); \
7911 : } \
7912 : i::Handle<i::JSArrayBuffer> buffer = \
7913 : Utils::OpenHandle(*shared_array_buffer); \
7914 : i::Handle<i::JSTypedArray> obj = isolate->factory()->NewJSTypedArray( \
7915 : i::kExternal##Type##Array, buffer, byte_offset, length); \
7916 : return Utils::ToLocal##Type##Array(obj); \
7917 : }
7918 :
7919 784 : TYPED_ARRAYS(TYPED_ARRAY_NEW)
7920 : #undef TYPED_ARRAY_NEW
7921 :
7922 20 : Local<DataView> DataView::New(Local<ArrayBuffer> array_buffer,
7923 : size_t byte_offset, size_t byte_length) {
7924 : i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*array_buffer);
7925 20 : i::Isolate* isolate = buffer->GetIsolate();
7926 40 : LOG_API(isolate, DataView, New);
7927 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
7928 : i::Handle<i::JSDataView> obj =
7929 20 : isolate->factory()->NewJSDataView(buffer, byte_offset, byte_length);
7930 20 : return Utils::ToLocal(obj);
7931 : }
7932 :
7933 :
7934 7 : Local<DataView> DataView::New(Local<SharedArrayBuffer> shared_array_buffer,
7935 : size_t byte_offset, size_t byte_length) {
7936 7 : CHECK(i::FLAG_harmony_sharedarraybuffer);
7937 : i::Handle<i::JSArrayBuffer> buffer = Utils::OpenHandle(*shared_array_buffer);
7938 7 : i::Isolate* isolate = buffer->GetIsolate();
7939 14 : LOG_API(isolate, DataView, New);
7940 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
7941 : i::Handle<i::JSDataView> obj =
7942 7 : isolate->factory()->NewJSDataView(buffer, byte_offset, byte_length);
7943 7 : return Utils::ToLocal(obj);
7944 : }
7945 :
7946 :
7947 292 : bool v8::SharedArrayBuffer::IsExternal() const {
7948 292 : return Utils::OpenHandle(this)->is_external();
7949 : }
7950 :
7951 :
7952 100 : v8::SharedArrayBuffer::Contents v8::SharedArrayBuffer::Externalize() {
7953 : i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
7954 : i::Isolate* isolate = self->GetIsolate();
7955 : Utils::ApiCheck(!self->is_external(), "v8_SharedArrayBuffer_Externalize",
7956 : "SharedArrayBuffer already externalized");
7957 : self->set_is_external(true);
7958 100 : isolate->heap()->UnregisterArrayBuffer(*self);
7959 100 : return GetContents();
7960 : }
7961 :
7962 :
7963 171 : v8::SharedArrayBuffer::Contents v8::SharedArrayBuffer::GetContents() {
7964 : i::Handle<i::JSArrayBuffer> self = Utils::OpenHandle(this);
7965 271 : size_t byte_length = static_cast<size_t>(self->byte_length()->Number());
7966 : Contents contents;
7967 : contents.data_ = self->backing_store();
7968 : contents.byte_length_ = byte_length;
7969 171 : return contents;
7970 : }
7971 :
7972 :
7973 21 : size_t v8::SharedArrayBuffer::ByteLength() const {
7974 : i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this);
7975 21 : return static_cast<size_t>(obj->byte_length()->Number());
7976 : }
7977 :
7978 :
7979 7 : Local<SharedArrayBuffer> v8::SharedArrayBuffer::New(Isolate* isolate,
7980 : size_t byte_length) {
7981 7 : CHECK(i::FLAG_harmony_sharedarraybuffer);
7982 7 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
7983 14 : LOG_API(i_isolate, SharedArrayBuffer, New);
7984 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
7985 : i::Handle<i::JSArrayBuffer> obj =
7986 7 : i_isolate->factory()->NewJSArrayBuffer(i::SharedFlag::kShared);
7987 : // TODO(jbroman): It may be useful in the future to provide a MaybeLocal
7988 : // version that throws an exception or otherwise does not crash.
7989 7 : if (!i::JSArrayBuffer::SetupAllocatingData(obj, i_isolate, byte_length, true,
7990 7 : i::SharedFlag::kShared)) {
7991 0 : i::FatalProcessOutOfMemory("v8::SharedArrayBuffer::New");
7992 : }
7993 7 : return Utils::ToLocalShared(obj);
7994 : }
7995 :
7996 :
7997 336 : Local<SharedArrayBuffer> v8::SharedArrayBuffer::New(
7998 : Isolate* isolate, void* data, size_t byte_length,
7999 : ArrayBufferCreationMode mode) {
8000 336 : CHECK(i::FLAG_harmony_sharedarraybuffer);
8001 : // Embedders must guarantee that the external backing store is valid.
8002 336 : CHECK(byte_length == 0 || data != NULL);
8003 336 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
8004 672 : LOG_API(i_isolate, SharedArrayBuffer, New);
8005 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
8006 : i::Handle<i::JSArrayBuffer> obj =
8007 336 : i_isolate->factory()->NewJSArrayBuffer(i::SharedFlag::kShared);
8008 : i::JSArrayBuffer::Setup(obj, i_isolate,
8009 : mode == ArrayBufferCreationMode::kExternalized, data,
8010 336 : byte_length, i::SharedFlag::kShared);
8011 336 : return Utils::ToLocalShared(obj);
8012 : }
8013 :
8014 :
8015 148 : Local<Symbol> v8::Symbol::New(Isolate* isolate, Local<String> name) {
8016 148 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
8017 296 : LOG_API(i_isolate, Symbol, New);
8018 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
8019 148 : i::Handle<i::Symbol> result = i_isolate->factory()->NewSymbol();
8020 203 : if (!name.IsEmpty()) result->set_name(*Utils::OpenHandle(*name));
8021 148 : return Utils::ToLocal(result);
8022 : }
8023 :
8024 :
8025 28 : Local<Symbol> v8::Symbol::For(Isolate* isolate, Local<String> name) {
8026 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
8027 28 : i::Handle<i::String> i_name = Utils::OpenHandle(*name);
8028 : return Utils::ToLocal(i_isolate->SymbolFor(
8029 28 : i::Heap::kPublicSymbolTableRootIndex, i_name, false));
8030 : }
8031 :
8032 :
8033 28 : Local<Symbol> v8::Symbol::ForApi(Isolate* isolate, Local<String> name) {
8034 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
8035 28 : i::Handle<i::String> i_name = Utils::OpenHandle(*name);
8036 : return Utils::ToLocal(
8037 28 : i_isolate->SymbolFor(i::Heap::kApiSymbolTableRootIndex, i_name, false));
8038 : }
8039 :
8040 : #define WELL_KNOWN_SYMBOLS(V) \
8041 : V(HasInstance, has_instance) \
8042 : V(IsConcatSpreadable, is_concat_spreadable) \
8043 : V(Iterator, iterator) \
8044 : V(Match, match) \
8045 : V(Replace, replace) \
8046 : V(Search, search) \
8047 : V(Split, split) \
8048 : V(ToPrimitive, to_primitive) \
8049 : V(ToStringTag, to_string_tag) \
8050 : V(Unscopables, unscopables)
8051 :
8052 : #define SYMBOL_GETTER(Name, name) \
8053 : Local<Symbol> v8::Symbol::Get##Name(Isolate* isolate) { \
8054 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); \
8055 : return Utils::ToLocal(i_isolate->factory()->name##_symbol()); \
8056 : }
8057 :
8058 125214 : WELL_KNOWN_SYMBOLS(SYMBOL_GETTER)
8059 :
8060 : #undef SYMBOL_GETTER
8061 : #undef WELL_KNOWN_SYMBOLS
8062 :
8063 87 : Local<Private> v8::Private::New(Isolate* isolate, Local<String> name) {
8064 87 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
8065 174 : LOG_API(i_isolate, Private, New);
8066 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(i_isolate);
8067 87 : i::Handle<i::Symbol> symbol = i_isolate->factory()->NewPrivateSymbol();
8068 160 : if (!name.IsEmpty()) symbol->set_name(*Utils::OpenHandle(*name));
8069 : Local<Symbol> result = Utils::ToLocal(symbol);
8070 174 : return v8::Local<Private>(reinterpret_cast<Private*>(*result));
8071 : }
8072 :
8073 :
8074 14253508 : Local<Private> v8::Private::ForApi(Isolate* isolate, Local<String> name) {
8075 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
8076 14253508 : i::Handle<i::String> i_name = Utils::OpenHandle(*name);
8077 : Local<Symbol> result = Utils::ToLocal(i_isolate->SymbolFor(
8078 14253508 : i::Heap::kApiPrivateSymbolTableRootIndex, i_name, true));
8079 14253508 : return v8::Local<Private>(reinterpret_cast<Private*>(*result));
8080 : }
8081 :
8082 :
8083 36399 : Local<Number> v8::Number::New(Isolate* isolate, double value) {
8084 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
8085 36399 : if (std::isnan(value)) {
8086 : // Introduce only canonical NaN value into the VM, to avoid signaling NaNs.
8087 : value = std::numeric_limits<double>::quiet_NaN();
8088 : }
8089 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(internal_isolate);
8090 36399 : i::Handle<i::Object> result = internal_isolate->factory()->NewNumber(value);
8091 36399 : return Utils::NumberToLocal(result);
8092 : }
8093 :
8094 :
8095 1099197 : Local<Integer> v8::Integer::New(Isolate* isolate, int32_t value) {
8096 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
8097 : if (i::Smi::IsValid(value)) {
8098 : return Utils::IntegerToLocal(i::Handle<i::Object>(i::Smi::FromInt(value),
8099 : internal_isolate));
8100 : }
8101 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(internal_isolate);
8102 : i::Handle<i::Object> result = internal_isolate->factory()->NewNumber(value);
8103 : return Utils::IntegerToLocal(result);
8104 : }
8105 :
8106 :
8107 160 : Local<Integer> v8::Integer::NewFromUnsigned(Isolate* isolate, uint32_t value) {
8108 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
8109 160 : bool fits_into_int32_t = (value & (1 << 31)) == 0;
8110 160 : if (fits_into_int32_t) {
8111 35 : return Integer::New(isolate, static_cast<int32_t>(value));
8112 : }
8113 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(internal_isolate);
8114 125 : i::Handle<i::Object> result = internal_isolate->factory()->NewNumber(value);
8115 : return Utils::IntegerToLocal(result);
8116 : }
8117 :
8118 :
8119 619 : void Isolate::ReportExternalAllocationLimitReached() {
8120 619 : i::Heap* heap = reinterpret_cast<i::Isolate*>(this)->heap();
8121 1238 : if (heap->gc_state() != i::Heap::NOT_IN_GC) return;
8122 619 : heap->ReportExternalMemoryPressure();
8123 : }
8124 :
8125 :
8126 9769 : HeapProfiler* Isolate::GetHeapProfiler() {
8127 : i::HeapProfiler* heap_profiler =
8128 : reinterpret_cast<i::Isolate*>(this)->heap_profiler();
8129 9769 : return reinterpret_cast<HeapProfiler*>(heap_profiler);
8130 : }
8131 :
8132 :
8133 0 : CpuProfiler* Isolate::GetCpuProfiler() {
8134 : i::CpuProfiler* cpu_profiler =
8135 : reinterpret_cast<i::Isolate*>(this)->cpu_profiler();
8136 0 : return reinterpret_cast<CpuProfiler*>(cpu_profiler);
8137 : }
8138 :
8139 :
8140 83125 : bool Isolate::InContext() {
8141 83125 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8142 83125 : return isolate->context() != NULL;
8143 : }
8144 :
8145 :
8146 68545269 : v8::Local<v8::Context> Isolate::GetCurrentContext() {
8147 68545269 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8148 : i::Context* context = isolate->context();
8149 68545269 : if (context == NULL) return Local<Context>();
8150 : i::Context* native_context = context->native_context();
8151 68545241 : if (native_context == NULL) return Local<Context>();
8152 : return Utils::ToLocal(i::Handle<i::Context>(native_context));
8153 : }
8154 :
8155 :
8156 0 : v8::Local<v8::Context> Isolate::GetCallingContext() {
8157 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8158 0 : i::Handle<i::Object> calling = isolate->GetCallingNativeContext();
8159 0 : if (calling.is_null()) return Local<Context>();
8160 : return Utils::ToLocal(i::Handle<i::Context>::cast(calling));
8161 : }
8162 :
8163 :
8164 62035 : v8::Local<v8::Context> Isolate::GetEnteredContext() {
8165 62035 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8166 : i::Handle<i::Object> last =
8167 62035 : isolate->handle_scope_implementer()->LastEnteredContext();
8168 62035 : if (last.is_null()) return Local<Context>();
8169 : return Utils::ToLocal(i::Handle<i::Context>::cast(last));
8170 : }
8171 :
8172 0 : v8::Local<v8::Context> Isolate::GetEnteredOrMicrotaskContext() {
8173 0 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8174 : i::Handle<i::Object> last;
8175 0 : if (isolate->handle_scope_implementer()
8176 : ->MicrotaskContextIsLastEnteredContext()) {
8177 0 : last = isolate->handle_scope_implementer()->MicrotaskContext();
8178 : } else {
8179 0 : last = isolate->handle_scope_implementer()->LastEnteredContext();
8180 : }
8181 0 : if (last.is_null()) return Local<Context>();
8182 : return Utils::ToLocal(i::Handle<i::Context>::cast(last));
8183 : }
8184 :
8185 11882 : v8::Local<Value> Isolate::ThrowException(v8::Local<v8::Value> value) {
8186 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8187 : ENTER_V8(isolate);
8188 : // If we're passed an empty handle, we throw an undefined exception
8189 : // to deal more gracefully with out of memory situations.
8190 11882 : if (value.IsEmpty()) {
8191 28 : isolate->ScheduleThrow(isolate->heap()->undefined_value());
8192 : } else {
8193 11854 : isolate->ScheduleThrow(*Utils::OpenHandle(*value));
8194 : }
8195 23764 : return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
8196 : }
8197 :
8198 36 : void Isolate::AddGCPrologueCallback(GCCallback callback, GCType gc_type) {
8199 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8200 36 : isolate->heap()->AddGCPrologueCallback(callback, gc_type);
8201 36 : }
8202 :
8203 :
8204 30 : void Isolate::RemoveGCPrologueCallback(GCCallback callback) {
8205 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8206 30 : isolate->heap()->RemoveGCPrologueCallback(callback);
8207 30 : }
8208 :
8209 :
8210 30 : void Isolate::AddGCEpilogueCallback(GCCallback callback, GCType gc_type) {
8211 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8212 30 : isolate->heap()->AddGCEpilogueCallback(callback, gc_type);
8213 30 : }
8214 :
8215 :
8216 30 : void Isolate::RemoveGCEpilogueCallback(GCCallback callback) {
8217 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8218 30 : isolate->heap()->RemoveGCEpilogueCallback(callback);
8219 30 : }
8220 :
8221 :
8222 0 : void V8::AddGCPrologueCallback(GCCallback callback, GCType gc_type) {
8223 : i::Isolate* isolate = i::Isolate::Current();
8224 : isolate->heap()->AddGCPrologueCallback(
8225 0 : reinterpret_cast<v8::Isolate::GCCallback>(callback), gc_type, false);
8226 0 : }
8227 :
8228 :
8229 0 : void V8::AddGCEpilogueCallback(GCCallback callback, GCType gc_type) {
8230 : i::Isolate* isolate = i::Isolate::Current();
8231 : isolate->heap()->AddGCEpilogueCallback(
8232 0 : reinterpret_cast<v8::Isolate::GCCallback>(callback), gc_type, false);
8233 0 : }
8234 :
8235 0 : void Isolate::SetEmbedderHeapTracer(EmbedderHeapTracer* tracer) {
8236 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8237 0 : isolate->heap()->SetEmbedderHeapTracer(tracer);
8238 0 : }
8239 :
8240 1331 : void Isolate::TerminateExecution() {
8241 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8242 1331 : isolate->stack_guard()->RequestTerminateExecution();
8243 1331 : }
8244 :
8245 :
8246 1685 : bool Isolate::IsExecutionTerminating() {
8247 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8248 1685 : return IsExecutionTerminatingCheck(isolate);
8249 : }
8250 :
8251 :
8252 14 : void Isolate::CancelTerminateExecution() {
8253 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8254 14 : isolate->stack_guard()->ClearTerminateExecution();
8255 14 : isolate->CancelTerminateExecution();
8256 14 : }
8257 :
8258 :
8259 128 : void Isolate::RequestInterrupt(InterruptCallback callback, void* data) {
8260 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8261 128 : isolate->RequestInterrupt(callback, data);
8262 128 : }
8263 :
8264 :
8265 10647 : void Isolate::RequestGarbageCollectionForTesting(GarbageCollectionType type) {
8266 10647 : CHECK(i::FLAG_expose_gc);
8267 10647 : if (type == kMinorGarbageCollection) {
8268 : reinterpret_cast<i::Isolate*>(this)->heap()->CollectGarbage(
8269 : i::NEW_SPACE, i::GarbageCollectionReason::kTesting,
8270 150 : kGCCallbackFlagForced);
8271 : } else {
8272 : DCHECK_EQ(kFullGarbageCollection, type);
8273 : reinterpret_cast<i::Isolate*>(this)->heap()->CollectAllGarbage(
8274 : i::Heap::kAbortIncrementalMarkingMask,
8275 10497 : i::GarbageCollectionReason::kTesting, kGCCallbackFlagForced);
8276 : }
8277 10647 : }
8278 :
8279 :
8280 765500 : Isolate* Isolate::GetCurrent() {
8281 : i::Isolate* isolate = i::Isolate::Current();
8282 765500 : return reinterpret_cast<Isolate*>(isolate);
8283 : }
8284 :
8285 :
8286 60523 : Isolate* Isolate::New(const Isolate::CreateParams& params) {
8287 60523 : i::Isolate* isolate = new i::Isolate(false);
8288 60523 : return IsolateNewImpl(isolate, params);
8289 : }
8290 :
8291 : // This is separate so that tests can provide a different |isolate|.
8292 60601 : Isolate* IsolateNewImpl(internal::Isolate* isolate,
8293 : const v8::Isolate::CreateParams& params) {
8294 : Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
8295 60601 : CHECK(params.array_buffer_allocator != NULL);
8296 : isolate->set_array_buffer_allocator(params.array_buffer_allocator);
8297 60601 : if (params.snapshot_blob != NULL) {
8298 : isolate->set_snapshot_blob(params.snapshot_blob);
8299 : } else {
8300 60517 : isolate->set_snapshot_blob(i::Snapshot::DefaultSnapshotBlob());
8301 : }
8302 60601 : if (params.entry_hook) {
8303 : #ifdef V8_USE_SNAPSHOT
8304 : // Setting a FunctionEntryHook is only supported in no-snapshot builds.
8305 : Utils::ApiCheck(
8306 : false, "v8::Isolate::New",
8307 : "Setting a FunctionEntryHook is only supported in no-snapshot builds.");
8308 : #endif
8309 : isolate->set_function_entry_hook(params.entry_hook);
8310 : }
8311 60601 : auto code_event_handler = params.code_event_handler;
8312 : #ifdef ENABLE_GDB_JIT_INTERFACE
8313 60601 : if (code_event_handler == nullptr && i::FLAG_gdbjit) {
8314 : code_event_handler = i::GDBJITInterface::EventHandler;
8315 : }
8316 : #endif // ENABLE_GDB_JIT_INTERFACE
8317 60601 : if (code_event_handler) {
8318 0 : isolate->InitializeLoggingAndCounters();
8319 : isolate->logger()->SetCodeEventHandler(kJitCodeEventDefault,
8320 0 : code_event_handler);
8321 : }
8322 60601 : if (params.counter_lookup_callback) {
8323 0 : v8_isolate->SetCounterFunction(params.counter_lookup_callback);
8324 : }
8325 :
8326 60601 : if (params.create_histogram_callback) {
8327 0 : v8_isolate->SetCreateHistogramFunction(params.create_histogram_callback);
8328 : }
8329 :
8330 60601 : if (params.add_histogram_sample_callback) {
8331 : v8_isolate->SetAddHistogramSampleFunction(
8332 : params.add_histogram_sample_callback);
8333 : }
8334 :
8335 60601 : isolate->set_api_external_references(params.external_references);
8336 60601 : isolate->set_allow_atomics_wait(params.allow_atomics_wait);
8337 :
8338 60601 : if (params.host_import_module_dynamically_callback_ != nullptr) {
8339 : isolate->SetHostImportModuleDynamicallyCallback(
8340 29457 : params.host_import_module_dynamically_callback_);
8341 : }
8342 :
8343 60601 : SetResourceConstraints(isolate, params.constraints);
8344 : // TODO(jochen): Once we got rid of Isolate::Current(), we can remove this.
8345 : Isolate::Scope isolate_scope(v8_isolate);
8346 60601 : if (params.entry_hook || !i::Snapshot::Initialize(isolate)) {
8347 0 : isolate->Init(NULL);
8348 : }
8349 60601 : return v8_isolate;
8350 : }
8351 :
8352 :
8353 59290 : void Isolate::Dispose() {
8354 59290 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8355 118581 : if (!Utils::ApiCheck(!isolate->IsInUse(),
8356 : "v8::Isolate::Dispose()",
8357 : "Disposing the isolate that is entered by a thread.")) {
8358 59290 : return;
8359 : }
8360 59285 : isolate->TearDown();
8361 : }
8362 :
8363 0 : void Isolate::DumpAndResetStats() {
8364 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8365 0 : isolate->DumpAndResetStats();
8366 0 : }
8367 :
8368 1800 : void Isolate::DiscardThreadSpecificMetadata() {
8369 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8370 1800 : isolate->DiscardPerThreadDataForThisThread();
8371 1800 : }
8372 :
8373 :
8374 132589 : void Isolate::Enter() {
8375 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8376 193287 : isolate->Enter();
8377 132584 : }
8378 :
8379 :
8380 132587 : void Isolate::Exit() {
8381 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8382 193285 : isolate->Exit();
8383 132588 : }
8384 :
8385 :
8386 6 : void Isolate::SetAbortOnUncaughtExceptionCallback(
8387 : AbortOnUncaughtExceptionCallback callback) {
8388 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8389 6 : isolate->SetAbortOnUncaughtExceptionCallback(callback);
8390 6 : }
8391 :
8392 :
8393 2562502 : Isolate::DisallowJavascriptExecutionScope::DisallowJavascriptExecutionScope(
8394 : Isolate* isolate,
8395 : Isolate::DisallowJavascriptExecutionScope::OnFailure on_failure)
8396 2562502 : : on_failure_(on_failure) {
8397 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
8398 2562502 : if (on_failure_ == CRASH_ON_FAILURE) {
8399 : internal_ = reinterpret_cast<void*>(
8400 6 : new i::DisallowJavascriptExecution(i_isolate));
8401 : } else {
8402 : DCHECK_EQ(THROW_ON_FAILURE, on_failure);
8403 : internal_ = reinterpret_cast<void*>(
8404 2562496 : new i::ThrowOnJavascriptExecution(i_isolate));
8405 : }
8406 2562502 : }
8407 :
8408 :
8409 2562502 : Isolate::DisallowJavascriptExecutionScope::~DisallowJavascriptExecutionScope() {
8410 2562502 : if (on_failure_ == CRASH_ON_FAILURE) {
8411 6 : delete reinterpret_cast<i::DisallowJavascriptExecution*>(internal_);
8412 : } else {
8413 2562496 : delete reinterpret_cast<i::ThrowOnJavascriptExecution*>(internal_);
8414 : }
8415 2562502 : }
8416 :
8417 :
8418 6 : Isolate::AllowJavascriptExecutionScope::AllowJavascriptExecutionScope(
8419 : Isolate* isolate) {
8420 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
8421 : internal_assert_ = reinterpret_cast<void*>(
8422 6 : new i::AllowJavascriptExecution(i_isolate));
8423 : internal_throws_ = reinterpret_cast<void*>(
8424 6 : new i::NoThrowOnJavascriptExecution(i_isolate));
8425 6 : }
8426 :
8427 :
8428 6 : Isolate::AllowJavascriptExecutionScope::~AllowJavascriptExecutionScope() {
8429 6 : delete reinterpret_cast<i::AllowJavascriptExecution*>(internal_assert_);
8430 6 : delete reinterpret_cast<i::NoThrowOnJavascriptExecution*>(internal_throws_);
8431 6 : }
8432 :
8433 :
8434 69057 : Isolate::SuppressMicrotaskExecutionScope::SuppressMicrotaskExecutionScope(
8435 : Isolate* isolate)
8436 69057 : : isolate_(reinterpret_cast<i::Isolate*>(isolate)) {
8437 138114 : isolate_->handle_scope_implementer()->IncrementCallDepth();
8438 : isolate_->handle_scope_implementer()->IncrementMicrotasksSuppressions();
8439 69057 : }
8440 :
8441 :
8442 69057 : Isolate::SuppressMicrotaskExecutionScope::~SuppressMicrotaskExecutionScope() {
8443 138114 : isolate_->handle_scope_implementer()->DecrementMicrotasksSuppressions();
8444 : isolate_->handle_scope_implementer()->DecrementCallDepth();
8445 69057 : }
8446 :
8447 :
8448 7 : void Isolate::GetHeapStatistics(HeapStatistics* heap_statistics) {
8449 14 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8450 14 : i::Heap* heap = isolate->heap();
8451 7 : heap_statistics->total_heap_size_ = heap->CommittedMemory();
8452 : heap_statistics->total_heap_size_executable_ =
8453 7 : heap->CommittedMemoryExecutable();
8454 7 : heap_statistics->total_physical_size_ = heap->CommittedPhysicalMemory();
8455 7 : heap_statistics->total_available_size_ = heap->Available();
8456 7 : heap_statistics->used_heap_size_ = heap->SizeOfObjects();
8457 7 : heap_statistics->heap_size_limit_ = heap->MaxReserved();
8458 : heap_statistics->malloced_memory_ =
8459 7 : isolate->allocator()->GetCurrentMemoryUsage();
8460 : heap_statistics->peak_malloced_memory_ =
8461 7 : isolate->allocator()->GetMaxMemoryUsage();
8462 7 : heap_statistics->does_zap_garbage_ = heap->ShouldZapGarbage();
8463 7 : }
8464 :
8465 :
8466 0 : size_t Isolate::NumberOfHeapSpaces() {
8467 0 : return i::LAST_SPACE - i::FIRST_SPACE + 1;
8468 : }
8469 :
8470 :
8471 0 : bool Isolate::GetHeapSpaceStatistics(HeapSpaceStatistics* space_statistics,
8472 : size_t index) {
8473 0 : if (!space_statistics) return false;
8474 0 : if (!i::Heap::IsValidAllocationSpace(static_cast<i::AllocationSpace>(index)))
8475 : return false;
8476 :
8477 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8478 0 : i::Heap* heap = isolate->heap();
8479 0 : i::Space* space = heap->space(static_cast<int>(index));
8480 :
8481 0 : space_statistics->space_name_ = heap->GetSpaceName(static_cast<int>(index));
8482 0 : space_statistics->space_size_ = space->CommittedMemory();
8483 0 : space_statistics->space_used_size_ = space->SizeOfObjects();
8484 0 : space_statistics->space_available_size_ = space->Available();
8485 0 : space_statistics->physical_space_size_ = space->CommittedPhysicalMemory();
8486 0 : return true;
8487 : }
8488 :
8489 :
8490 0 : size_t Isolate::NumberOfTrackedHeapObjectTypes() {
8491 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8492 0 : i::Heap* heap = isolate->heap();
8493 0 : return heap->NumberOfTrackedHeapObjectTypes();
8494 : }
8495 :
8496 :
8497 0 : bool Isolate::GetHeapObjectStatisticsAtLastGC(
8498 : HeapObjectStatistics* object_statistics, size_t type_index) {
8499 0 : if (!object_statistics) return false;
8500 0 : if (V8_LIKELY(!i::FLAG_gc_stats)) return false;
8501 :
8502 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8503 0 : i::Heap* heap = isolate->heap();
8504 0 : if (type_index >= heap->NumberOfTrackedHeapObjectTypes()) return false;
8505 :
8506 : const char* object_type;
8507 : const char* object_sub_type;
8508 0 : size_t object_count = heap->ObjectCountAtLastGC(type_index);
8509 0 : size_t object_size = heap->ObjectSizeAtLastGC(type_index);
8510 0 : if (!heap->GetObjectTypeName(type_index, &object_type, &object_sub_type)) {
8511 : // There should be no objects counted when the type is unknown.
8512 : DCHECK_EQ(object_count, 0U);
8513 : DCHECK_EQ(object_size, 0U);
8514 : return false;
8515 : }
8516 :
8517 0 : object_statistics->object_type_ = object_type;
8518 0 : object_statistics->object_sub_type_ = object_sub_type;
8519 0 : object_statistics->object_count_ = object_count;
8520 0 : object_statistics->object_size_ = object_size;
8521 0 : return true;
8522 : }
8523 :
8524 0 : bool Isolate::GetHeapCodeAndMetadataStatistics(
8525 : HeapCodeStatistics* code_statistics) {
8526 0 : if (!code_statistics) return false;
8527 :
8528 0 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8529 0 : isolate->heap()->CollectCodeStatistics();
8530 :
8531 0 : code_statistics->code_and_metadata_size_ = isolate->code_and_metadata_size();
8532 : code_statistics->bytecode_and_metadata_size_ =
8533 0 : isolate->bytecode_and_metadata_size();
8534 0 : return true;
8535 : }
8536 :
8537 6937 : void Isolate::GetStackSample(const RegisterState& state, void** frames,
8538 : size_t frames_limit, SampleInfo* sample_info) {
8539 6937 : RegisterState regs = state;
8540 6937 : if (TickSample::GetStackSample(this, ®s, TickSample::kSkipCEntryFrame,
8541 : frames, frames_limit, sample_info)) {
8542 6817 : return;
8543 : }
8544 120 : sample_info->frames_count = 0;
8545 120 : sample_info->vm_state = OTHER;
8546 120 : sample_info->external_callback_entry = nullptr;
8547 : }
8548 :
8549 18 : size_t Isolate::NumberOfPhantomHandleResetsSinceLastCall() {
8550 18 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8551 18 : size_t result = isolate->global_handles()->NumberOfPhantomHandleResets();
8552 : isolate->global_handles()->ResetNumberOfPhantomHandleResets();
8553 18 : return result;
8554 : }
8555 :
8556 6 : void Isolate::SetEventLogger(LogEventCallback that) {
8557 : // Do not overwrite the event logger if we want to log explicitly.
8558 12 : if (i::FLAG_log_internal_timer_events) return;
8559 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8560 : isolate->set_event_logger(that);
8561 : }
8562 :
8563 :
8564 18 : void Isolate::AddBeforeCallEnteredCallback(BeforeCallEnteredCallback callback) {
8565 36 : if (callback == NULL) return;
8566 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8567 18 : isolate->AddBeforeCallEnteredCallback(callback);
8568 : }
8569 :
8570 :
8571 6 : void Isolate::RemoveBeforeCallEnteredCallback(
8572 : BeforeCallEnteredCallback callback) {
8573 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8574 6 : isolate->RemoveBeforeCallEnteredCallback(callback);
8575 6 : }
8576 :
8577 :
8578 30 : void Isolate::AddCallCompletedCallback(CallCompletedCallback callback) {
8579 60 : if (callback == NULL) return;
8580 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8581 30 : isolate->AddCallCompletedCallback(callback);
8582 : }
8583 :
8584 :
8585 6 : void Isolate::RemoveCallCompletedCallback(CallCompletedCallback callback) {
8586 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8587 6 : isolate->RemoveCallCompletedCallback(callback);
8588 6 : }
8589 :
8590 :
8591 0 : void Isolate::AddCallCompletedCallback(
8592 : DeprecatedCallCompletedCallback callback) {
8593 : AddCallCompletedCallback(reinterpret_cast<CallCompletedCallback>(callback));
8594 0 : }
8595 :
8596 :
8597 0 : void Isolate::RemoveCallCompletedCallback(
8598 : DeprecatedCallCompletedCallback callback) {
8599 : RemoveCallCompletedCallback(
8600 : reinterpret_cast<CallCompletedCallback>(callback));
8601 0 : }
8602 :
8603 12 : void Isolate::SetPromiseHook(PromiseHook hook) {
8604 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8605 12 : isolate->SetPromiseHook(hook);
8606 12 : }
8607 :
8608 6 : void Isolate::SetPromiseRejectCallback(PromiseRejectCallback callback) {
8609 12 : if (callback == NULL) return;
8610 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8611 6 : isolate->SetPromiseRejectCallback(callback);
8612 : }
8613 :
8614 :
8615 8953 : void Isolate::RunMicrotasks() {
8616 : DCHECK(MicrotasksPolicy::kScoped != GetMicrotasksPolicy());
8617 8953 : reinterpret_cast<i::Isolate*>(this)->RunMicrotasks();
8618 8953 : }
8619 :
8620 :
8621 147 : void Isolate::EnqueueMicrotask(Local<Function> microtask) {
8622 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8623 147 : isolate->EnqueueMicrotask(Utils::OpenHandle(*microtask));
8624 147 : }
8625 :
8626 :
8627 334 : void Isolate::EnqueueMicrotask(MicrotaskCallback microtask, void* data) {
8628 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8629 : i::HandleScope scope(isolate);
8630 : i::Handle<i::CallHandlerInfo> callback_info =
8631 : i::Handle<i::CallHandlerInfo>::cast(
8632 334 : isolate->factory()->NewStruct(i::TUPLE2_TYPE));
8633 668 : SET_FIELD_WRAPPED(callback_info, set_callback, microtask);
8634 668 : SET_FIELD_WRAPPED(callback_info, set_data, data);
8635 334 : isolate->EnqueueMicrotask(callback_info);
8636 334 : }
8637 :
8638 :
8639 0 : void Isolate::SetAutorunMicrotasks(bool autorun) {
8640 : SetMicrotasksPolicy(
8641 0 : autorun ? MicrotasksPolicy::kAuto : MicrotasksPolicy::kExplicit);
8642 0 : }
8643 :
8644 :
8645 0 : bool Isolate::WillAutorunMicrotasks() const {
8646 0 : return GetMicrotasksPolicy() == MicrotasksPolicy::kAuto;
8647 : }
8648 :
8649 :
8650 1477 : void Isolate::SetMicrotasksPolicy(MicrotasksPolicy policy) {
8651 1477 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8652 : isolate->handle_scope_implementer()->set_microtasks_policy(policy);
8653 1477 : }
8654 :
8655 :
8656 0 : MicrotasksPolicy Isolate::GetMicrotasksPolicy() const {
8657 0 : i::Isolate* isolate =
8658 : reinterpret_cast<i::Isolate*>(const_cast<Isolate*>(this));
8659 0 : return isolate->handle_scope_implementer()->microtasks_policy();
8660 : }
8661 :
8662 :
8663 6 : void Isolate::AddMicrotasksCompletedCallback(
8664 : MicrotasksCompletedCallback callback) {
8665 : DCHECK(callback);
8666 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8667 6 : isolate->AddMicrotasksCompletedCallback(callback);
8668 6 : }
8669 :
8670 :
8671 6 : void Isolate::RemoveMicrotasksCompletedCallback(
8672 : MicrotasksCompletedCallback callback) {
8673 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8674 6 : isolate->RemoveMicrotasksCompletedCallback(callback);
8675 6 : }
8676 :
8677 :
8678 58 : void Isolate::SetUseCounterCallback(UseCounterCallback callback) {
8679 58 : reinterpret_cast<i::Isolate*>(this)->SetUseCounterCallback(callback);
8680 58 : }
8681 :
8682 :
8683 6 : void Isolate::SetCounterFunction(CounterLookupCallback callback) {
8684 6 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8685 6 : isolate->stats_table()->SetCounterFunction(callback);
8686 6 : isolate->InitializeLoggingAndCounters();
8687 6 : isolate->counters()->ResetCounters();
8688 6 : }
8689 :
8690 :
8691 6 : void Isolate::SetCreateHistogramFunction(CreateHistogramCallback callback) {
8692 12 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8693 6 : isolate->stats_table()->SetCreateHistogramFunction(callback);
8694 6 : isolate->InitializeLoggingAndCounters();
8695 6 : isolate->counters()->ResetHistograms();
8696 6 : isolate->counters()->InitializeHistograms();
8697 6 : }
8698 :
8699 :
8700 6 : void Isolate::SetAddHistogramSampleFunction(
8701 : AddHistogramSampleCallback callback) {
8702 : reinterpret_cast<i::Isolate*>(this)
8703 : ->stats_table()
8704 6 : ->SetAddHistogramSampleFunction(callback);
8705 6 : }
8706 :
8707 :
8708 0 : bool Isolate::IdleNotification(int idle_time_in_ms) {
8709 : // Returning true tells the caller that it need not
8710 : // continue to call IdleNotification.
8711 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8712 0 : if (!i::FLAG_use_idle_notification) return true;
8713 0 : return isolate->heap()->IdleNotification(idle_time_in_ms);
8714 : }
8715 :
8716 :
8717 5450 : bool Isolate::IdleNotificationDeadline(double deadline_in_seconds) {
8718 : // Returning true tells the caller that it need not
8719 : // continue to call IdleNotification.
8720 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8721 5450 : if (!i::FLAG_use_idle_notification) return true;
8722 5450 : return isolate->heap()->IdleNotification(deadline_in_seconds);
8723 : }
8724 :
8725 6536 : void Isolate::LowMemoryNotification() {
8726 6536 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8727 : {
8728 : i::HistogramTimerScope idle_notification_scope(
8729 6536 : isolate->counters()->gc_low_memory_notification());
8730 19608 : TRACE_EVENT0("v8", "V8.GCLowMemoryNotification");
8731 : isolate->heap()->CollectAllAvailableGarbage(
8732 6536 : i::GarbageCollectionReason::kLowMemoryNotification);
8733 : }
8734 : {
8735 6536 : i::HeapIterator iterator(isolate->heap());
8736 : i::HeapObject* obj;
8737 44140226 : while ((obj = iterator.next()) != nullptr) {
8738 44127154 : if (obj->IsAbstractCode()) {
8739 8951201 : i::AbstractCode::cast(obj)->DropStackFrameCache();
8740 : }
8741 6536 : }
8742 : }
8743 6536 : }
8744 :
8745 :
8746 5614 : int Isolate::ContextDisposedNotification(bool dependant_context) {
8747 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8748 5626 : return isolate->heap()->NotifyContextDisposed(dependant_context);
8749 : }
8750 :
8751 :
8752 0 : void Isolate::IsolateInForegroundNotification() {
8753 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8754 0 : return isolate->IsolateInForegroundNotification();
8755 : }
8756 :
8757 :
8758 0 : void Isolate::IsolateInBackgroundNotification() {
8759 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8760 0 : return isolate->IsolateInBackgroundNotification();
8761 : }
8762 :
8763 26 : void Isolate::MemoryPressureNotification(MemoryPressureLevel level) {
8764 76 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8765 : bool on_isolate_thread =
8766 26 : v8::Locker::IsActive()
8767 : ? isolate->thread_manager()->IsLockedByCurrentThread()
8768 76 : : i::ThreadId::Current().Equals(isolate->thread_id());
8769 26 : isolate->heap()->MemoryPressureNotification(level, on_isolate_thread);
8770 26 : isolate->allocator()->MemoryPressureNotification(level);
8771 : isolate->compiler_dispatcher()->MemoryPressureNotification(level,
8772 26 : on_isolate_thread);
8773 26 : }
8774 :
8775 0 : void Isolate::SetRAILMode(RAILMode rail_mode) {
8776 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8777 0 : return isolate->SetRAILMode(rail_mode);
8778 : }
8779 :
8780 18 : void Isolate::IncreaseHeapLimitForDebugging() {
8781 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8782 : isolate->heap()->IncreaseHeapLimitForDebugging();
8783 18 : }
8784 :
8785 4321 : void Isolate::RestoreOriginalHeapLimit() {
8786 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8787 4321 : isolate->heap()->RestoreOriginalHeapLimit();
8788 4321 : }
8789 :
8790 18 : bool Isolate::IsHeapLimitIncreasedForDebugging() {
8791 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8792 18 : return isolate->heap()->IsHeapLimitIncreasedForDebugging();
8793 : }
8794 :
8795 72 : void Isolate::SetJitCodeEventHandler(JitCodeEventOptions options,
8796 : JitCodeEventHandler event_handler) {
8797 72 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8798 : // Ensure that logging is initialized for our isolate.
8799 72 : isolate->InitializeLoggingAndCounters();
8800 72 : isolate->logger()->SetCodeEventHandler(options, event_handler);
8801 72 : }
8802 :
8803 :
8804 12 : void Isolate::SetStackLimit(uintptr_t stack_limit) {
8805 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8806 12 : CHECK(stack_limit);
8807 12 : isolate->stack_guard()->SetStackLimit(stack_limit);
8808 12 : }
8809 :
8810 0 : void Isolate::GetCodeRange(void** start, size_t* length_in_bytes) {
8811 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8812 0 : if (isolate->heap()->memory_allocator()->code_range()->valid()) {
8813 0 : *start = isolate->heap()->memory_allocator()->code_range()->start();
8814 : *length_in_bytes =
8815 0 : isolate->heap()->memory_allocator()->code_range()->size();
8816 : } else {
8817 0 : *start = NULL;
8818 0 : *length_in_bytes = 0;
8819 : }
8820 0 : }
8821 :
8822 :
8823 30 : void Isolate::SetFatalErrorHandler(FatalErrorCallback that) {
8824 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8825 : isolate->set_exception_behavior(that);
8826 30 : }
8827 :
8828 0 : void Isolate::SetOOMErrorHandler(OOMErrorCallback that) {
8829 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8830 : isolate->set_oom_behavior(that);
8831 0 : }
8832 :
8833 56 : void Isolate::SetAllowCodeGenerationFromStringsCallback(
8834 : AllowCodeGenerationFromStringsCallback callback) {
8835 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8836 : isolate->set_allow_code_gen_callback(callback);
8837 56 : }
8838 :
8839 : #define CALLBACK_SETTER(ExternalName, Type, InternalName) \
8840 : void Isolate::Set##ExternalName(Type callback) { \
8841 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this); \
8842 : isolate->set_##InternalName(callback); \
8843 : }
8844 :
8845 240 : CALLBACK_SETTER(WasmModuleCallback, ExtensionCallback, wasm_module_callback)
8846 240 : CALLBACK_SETTER(WasmCompileCallback, ExtensionCallback, wasm_compile_callback)
8847 30 : CALLBACK_SETTER(WasmInstanceCallback, ExtensionCallback, wasm_instance_callback)
8848 30 : CALLBACK_SETTER(WasmInstantiateCallback, ExtensionCallback,
8849 : wasm_instantiate_callback)
8850 :
8851 0 : bool Isolate::IsDead() {
8852 0 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8853 0 : return isolate->IsDead();
8854 : }
8855 :
8856 927 : bool Isolate::AddMessageListener(MessageCallback that, Local<Value> data) {
8857 927 : return AddMessageListenerWithErrorLevel(that, kMessageError, data);
8858 : }
8859 :
8860 29556 : bool Isolate::AddMessageListenerWithErrorLevel(MessageCallback that,
8861 : int message_levels,
8862 : Local<Value> data) {
8863 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8864 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
8865 : i::HandleScope scope(isolate);
8866 : i::Handle<i::TemplateList> list = isolate->factory()->message_listeners();
8867 29556 : i::Handle<i::FixedArray> listener = isolate->factory()->NewFixedArray(3);
8868 : i::Handle<i::Foreign> foreign =
8869 29556 : isolate->factory()->NewForeign(FUNCTION_ADDR(that));
8870 29556 : listener->set(0, *foreign);
8871 29549 : listener->set(1, data.IsEmpty() ? isolate->heap()->undefined_value()
8872 59112 : : *Utils::OpenHandle(*data));
8873 : listener->set(2, i::Smi::FromInt(message_levels));
8874 29556 : list = i::TemplateList::Add(isolate, list, listener);
8875 : isolate->heap()->SetMessageListeners(*list);
8876 29556 : return true;
8877 : }
8878 :
8879 :
8880 185 : void Isolate::RemoveMessageListeners(MessageCallback that) {
8881 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8882 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate);
8883 : i::HandleScope scope(isolate);
8884 : i::DisallowHeapAllocation no_gc;
8885 185 : i::TemplateList* listeners = isolate->heap()->message_listeners();
8886 603 : for (int i = 0; i < listeners->length(); i++) {
8887 233 : if (listeners->get(i)->IsUndefined(isolate)) continue; // skip deleted ones
8888 : i::FixedArray* listener = i::FixedArray::cast(listeners->get(i));
8889 : i::Foreign* callback_obj = i::Foreign::cast(listener->get(0));
8890 185 : if (callback_obj->foreign_address() == FUNCTION_ADDR(that)) {
8891 185 : listeners->set(i, isolate->heap()->undefined_value());
8892 : }
8893 : }
8894 185 : }
8895 :
8896 :
8897 32 : void Isolate::SetFailedAccessCheckCallbackFunction(
8898 : FailedAccessCheckCallback callback) {
8899 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8900 32 : isolate->SetFailedAccessCheckCallback(callback);
8901 32 : }
8902 :
8903 :
8904 885 : void Isolate::SetCaptureStackTraceForUncaughtExceptions(
8905 : bool capture, int frame_limit, StackTrace::StackTraceOptions options) {
8906 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8907 : isolate->SetCaptureStackTraceForUncaughtExceptions(capture, frame_limit,
8908 885 : options);
8909 885 : }
8910 :
8911 :
8912 6 : void Isolate::VisitExternalResources(ExternalResourceVisitor* visitor) {
8913 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8914 6 : isolate->heap()->VisitExternalResources(visitor);
8915 6 : }
8916 :
8917 :
8918 238959 : bool Isolate::IsInUse() {
8919 238959 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8920 238959 : return isolate->IsInUse();
8921 : }
8922 :
8923 :
8924 6 : void Isolate::VisitHandlesWithClassIds(PersistentHandleVisitor* visitor) {
8925 6 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8926 : i::DisallowHeapAllocation no_allocation;
8927 6 : isolate->global_handles()->IterateAllRootsWithClassIds(visitor);
8928 6 : }
8929 :
8930 :
8931 6 : void Isolate::VisitHandlesForPartialDependence(
8932 : PersistentHandleVisitor* visitor) {
8933 6 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8934 : i::DisallowHeapAllocation no_allocation;
8935 6 : isolate->global_handles()->IterateAllRootsInNewSpaceWithClassIds(visitor);
8936 6 : }
8937 :
8938 :
8939 0 : void Isolate::VisitWeakHandles(PersistentHandleVisitor* visitor) {
8940 0 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8941 : i::DisallowHeapAllocation no_allocation;
8942 0 : isolate->global_handles()->IterateWeakRootsInNewSpaceWithClassIds(visitor);
8943 0 : }
8944 :
8945 6 : void Isolate::SetAllowAtomicsWait(bool allow) {
8946 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8947 : isolate->set_allow_atomics_wait(allow);
8948 6 : }
8949 :
8950 1194192 : MicrotasksScope::MicrotasksScope(Isolate* isolate, MicrotasksScope::Type type)
8951 : : isolate_(reinterpret_cast<i::Isolate*>(isolate)),
8952 1194192 : run_(type == MicrotasksScope::kRunMicrotasks) {
8953 1194192 : auto handle_scope_implementer = isolate_->handle_scope_implementer();
8954 1194192 : if (run_) handle_scope_implementer->IncrementMicrotasksScopeDepth();
8955 : #ifdef DEBUG
8956 : if (!run_) handle_scope_implementer->IncrementDebugMicrotasksScopeDepth();
8957 : #endif
8958 1194192 : }
8959 :
8960 :
8961 1194191 : MicrotasksScope::~MicrotasksScope() {
8962 1269282 : auto handle_scope_implementer = isolate_->handle_scope_implementer();
8963 1194191 : if (run_) {
8964 : handle_scope_implementer->DecrementMicrotasksScopeDepth();
8965 75091 : if (MicrotasksPolicy::kScoped ==
8966 : handle_scope_implementer->microtasks_policy()) {
8967 48431 : PerformCheckpoint(reinterpret_cast<Isolate*>(isolate_));
8968 : }
8969 : }
8970 : #ifdef DEBUG
8971 : if (!run_) handle_scope_implementer->DecrementDebugMicrotasksScopeDepth();
8972 : #endif
8973 1194191 : }
8974 :
8975 :
8976 48461 : void MicrotasksScope::PerformCheckpoint(Isolate* v8Isolate) {
8977 48461 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8Isolate);
8978 96922 : if (IsExecutionTerminatingCheck(isolate)) return;
8979 96194 : auto handle_scope_implementer = isolate->handle_scope_implementer();
8980 96194 : if (!handle_scope_implementer->GetMicrotasksScopeDepth() &&
8981 : !handle_scope_implementer->HasMicrotasksSuppressions()) {
8982 47721 : isolate->RunMicrotasks();
8983 : }
8984 : }
8985 :
8986 :
8987 0 : int MicrotasksScope::GetCurrentDepth(Isolate* v8Isolate) {
8988 0 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8Isolate);
8989 0 : return isolate->handle_scope_implementer()->GetMicrotasksScopeDepth();
8990 : }
8991 :
8992 120 : bool MicrotasksScope::IsRunningMicrotasks(Isolate* v8Isolate) {
8993 120 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8Isolate);
8994 120 : return isolate->IsRunningMicrotasks();
8995 : }
8996 :
8997 11616539 : String::Utf8Value::Utf8Value(v8::Local<v8::Value> obj)
8998 11616539 : : str_(NULL), length_(0) {
8999 11616574 : if (obj.IsEmpty()) return;
9000 : i::Isolate* isolate = i::Isolate::Current();
9001 : Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
9002 : ENTER_V8(isolate);
9003 : i::HandleScope scope(isolate);
9004 11616527 : Local<Context> context = v8_isolate->GetCurrentContext();
9005 23233031 : TryCatch try_catch(v8_isolate);
9006 : Local<String> str;
9007 23233077 : if (!obj->ToString(context).ToLocal(&str)) return;
9008 : i::Handle<i::String> i_str = Utils::OpenHandle(*str);
9009 11616504 : length_ = v8::Utf8Length(*i_str, isolate);
9010 11616504 : str_ = i::NewArray<char>(length_ + 1);
9011 11616504 : str->WriteUtf8(str_);
9012 : }
9013 :
9014 :
9015 11616539 : String::Utf8Value::~Utf8Value() {
9016 11616539 : i::DeleteArray(str_);
9017 11616539 : }
9018 :
9019 :
9020 7 : String::Value::Value(v8::Local<v8::Value> obj) : str_(NULL), length_(0) {
9021 7 : if (obj.IsEmpty()) return;
9022 : i::Isolate* isolate = i::Isolate::Current();
9023 : Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
9024 : ENTER_V8(isolate);
9025 : i::HandleScope scope(isolate);
9026 7 : Local<Context> context = v8_isolate->GetCurrentContext();
9027 14 : TryCatch try_catch(v8_isolate);
9028 : Local<String> str;
9029 14 : if (!obj->ToString(context).ToLocal(&str)) return;
9030 7 : length_ = str->Length();
9031 7 : str_ = i::NewArray<uint16_t>(length_ + 1);
9032 : str->Write(str_);
9033 : }
9034 :
9035 :
9036 7 : String::Value::~Value() {
9037 7 : i::DeleteArray(str_);
9038 7 : }
9039 :
9040 : #define DEFINE_ERROR(NAME, name) \
9041 : Local<Value> Exception::NAME(v8::Local<v8::String> raw_message) { \
9042 : i::Isolate* isolate = i::Isolate::Current(); \
9043 : LOG_API(isolate, NAME, New); \
9044 : ENTER_V8_NO_SCRIPT_NO_EXCEPTION(isolate); \
9045 : i::Object* error; \
9046 : { \
9047 : i::HandleScope scope(isolate); \
9048 : i::Handle<i::String> message = Utils::OpenHandle(*raw_message); \
9049 : i::Handle<i::JSFunction> constructor = isolate->name##_function(); \
9050 : error = *isolate->factory()->NewError(constructor, message); \
9051 : } \
9052 : i::Handle<i::Object> result(error, isolate); \
9053 : return Utils::ToLocal(result); \
9054 : }
9055 :
9056 485 : DEFINE_ERROR(RangeError, range_error)
9057 35 : DEFINE_ERROR(ReferenceError, reference_error)
9058 35 : DEFINE_ERROR(SyntaxError, syntax_error)
9059 35 : DEFINE_ERROR(TypeError, type_error)
9060 1240 : DEFINE_ERROR(Error, error)
9061 :
9062 : #undef DEFINE_ERROR
9063 :
9064 :
9065 110 : Local<Message> Exception::CreateMessage(Isolate* isolate,
9066 : Local<Value> exception) {
9067 110 : i::Handle<i::Object> obj = Utils::OpenHandle(*exception);
9068 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
9069 : ENTER_V8(i_isolate);
9070 : i::HandleScope scope(i_isolate);
9071 : return Utils::MessageToLocal(
9072 220 : scope.CloseAndEscape(i_isolate->CreateMessage(obj, NULL)));
9073 : }
9074 :
9075 :
9076 0 : Local<Message> Exception::CreateMessage(Local<Value> exception) {
9077 : i::Handle<i::Object> obj = Utils::OpenHandle(*exception);
9078 0 : if (!obj->IsHeapObject()) return Local<Message>();
9079 : i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
9080 0 : return CreateMessage(reinterpret_cast<Isolate*>(isolate), exception);
9081 : }
9082 :
9083 :
9084 49 : Local<StackTrace> Exception::GetStackTrace(Local<Value> exception) {
9085 : i::Handle<i::Object> obj = Utils::OpenHandle(*exception);
9086 49 : if (!obj->IsJSObject()) return Local<StackTrace>();
9087 : i::Handle<i::JSObject> js_obj = i::Handle<i::JSObject>::cast(obj);
9088 : i::Isolate* isolate = js_obj->GetIsolate();
9089 : ENTER_V8(isolate);
9090 49 : return Utils::StackTraceToLocal(isolate->GetDetailedStackTrace(js_obj));
9091 : }
9092 :
9093 :
9094 : // --- D e b u g S u p p o r t ---
9095 :
9096 0 : bool Debug::SetDebugEventListener(Isolate* isolate, EventCallback that,
9097 : Local<Value> data) {
9098 0 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
9099 : ENTER_V8(i_isolate);
9100 : i::HandleScope scope(i_isolate);
9101 0 : if (that == nullptr) {
9102 0 : i_isolate->debug()->SetDebugDelegate(nullptr, false);
9103 : } else {
9104 : i::Handle<i::Object> i_data = i_isolate->factory()->undefined_value();
9105 0 : if (!data.IsEmpty()) i_data = Utils::OpenHandle(*data);
9106 : i::NativeDebugDelegate* delegate =
9107 0 : new i::NativeDebugDelegate(i_isolate, that, i_data);
9108 0 : i_isolate->debug()->SetDebugDelegate(delegate, true);
9109 : }
9110 0 : return true;
9111 : }
9112 :
9113 0 : void Debug::DebugBreak(Isolate* isolate) { debug::DebugBreak(isolate); }
9114 :
9115 0 : void Debug::CancelDebugBreak(Isolate* isolate) {
9116 : debug::CancelDebugBreak(isolate);
9117 0 : }
9118 :
9119 0 : bool Debug::CheckDebugBreak(Isolate* isolate) {
9120 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
9121 0 : return internal_isolate->stack_guard()->CheckDebugBreak();
9122 : }
9123 :
9124 0 : void Debug::SetMessageHandler(Isolate* isolate,
9125 0 : v8::Debug::MessageHandler handler) {}
9126 :
9127 0 : void Debug::SendCommand(Isolate* isolate, const uint16_t* command, int length,
9128 0 : ClientData* client_data) {}
9129 :
9130 0 : MaybeLocal<Value> Debug::Call(Local<Context> context,
9131 : v8::Local<v8::Function> fun,
9132 : v8::Local<v8::Value> data) {
9133 0 : return debug::Call(context, fun, data);
9134 : }
9135 :
9136 0 : void Debug::ProcessDebugMessages(Isolate* isolate) {}
9137 :
9138 0 : Local<Context> Debug::GetDebugContext(Isolate* isolate) {
9139 0 : return debug::GetDebugContext(isolate);
9140 : }
9141 :
9142 0 : MaybeLocal<Context> Debug::GetDebuggedContext(Isolate* isolate) {
9143 0 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
9144 : ENTER_V8(i_isolate);
9145 0 : if (!i_isolate->debug()->in_debug_scope()) return MaybeLocal<Context>();
9146 0 : i::Handle<i::Object> calling = i_isolate->GetCallingNativeContext();
9147 0 : if (calling.is_null()) return MaybeLocal<Context>();
9148 0 : return Utils::ToLocal(i::Handle<i::Context>::cast(calling));
9149 : }
9150 :
9151 0 : void Debug::SetLiveEditEnabled(Isolate* isolate, bool enable) {
9152 : debug::SetLiveEditEnabled(isolate, enable);
9153 0 : }
9154 :
9155 0 : bool Debug::IsTailCallEliminationEnabled(Isolate* isolate) {
9156 0 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
9157 0 : return internal_isolate->is_tail_call_elimination_enabled();
9158 : }
9159 :
9160 0 : void Debug::SetTailCallEliminationEnabled(Isolate* isolate, bool enabled) {
9161 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
9162 0 : internal_isolate->SetTailCallEliminationEnabled(enabled);
9163 0 : }
9164 :
9165 0 : MaybeLocal<Array> Debug::GetInternalProperties(Isolate* v8_isolate,
9166 : Local<Value> value) {
9167 0 : return debug::GetInternalProperties(v8_isolate, value);
9168 : }
9169 :
9170 4579 : void debug::SetContextId(Local<Context> context, int id) {
9171 : Utils::OpenHandle(*context)->set_debug_context_id(i::Smi::FromInt(id));
9172 4579 : }
9173 :
9174 878040 : int debug::GetContextId(Local<Context> context) {
9175 : i::Object* value = Utils::OpenHandle(*context)->debug_context_id();
9176 1756080 : return (value->IsSmi()) ? i::Smi::cast(value)->value() : 0;
9177 : }
9178 :
9179 158583 : Local<Context> debug::GetDebugContext(Isolate* isolate) {
9180 158583 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
9181 : ENTER_V8(i_isolate);
9182 317166 : return Utils::ToLocal(i_isolate->debug()->GetDebugContext());
9183 : }
9184 :
9185 7751 : MaybeLocal<Value> debug::Call(Local<Context> context,
9186 : v8::Local<v8::Function> fun,
9187 : v8::Local<v8::Value> data) {
9188 38755 : PREPARE_FOR_EXECUTION(context, Debug, Call, Value);
9189 : i::Handle<i::Object> data_obj;
9190 7751 : if (data.IsEmpty()) {
9191 4465 : data_obj = isolate->factory()->undefined_value();
9192 : } else {
9193 3286 : data_obj = Utils::OpenHandle(*data);
9194 : }
9195 : Local<Value> result;
9196 : has_pending_exception = !ToLocal<Value>(
9197 15502 : isolate->debug()->Call(Utils::OpenHandle(*fun), data_obj), &result);
9198 7769 : RETURN_ON_FAILED_EXECUTION(Value);
9199 7733 : RETURN_ESCAPED(result);
9200 : }
9201 :
9202 4146 : void debug::SetLiveEditEnabled(Isolate* isolate, bool enable) {
9203 4146 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
9204 : internal_isolate->debug()->set_live_edit_enabled(enable);
9205 4146 : }
9206 :
9207 19611 : void debug::DebugBreak(Isolate* isolate) {
9208 19611 : reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->RequestDebugBreak();
9209 19611 : }
9210 :
9211 93 : void debug::CancelDebugBreak(Isolate* isolate) {
9212 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
9213 93 : internal_isolate->stack_guard()->ClearDebugBreak();
9214 93 : }
9215 :
9216 106344 : MaybeLocal<Array> debug::GetInternalProperties(Isolate* v8_isolate,
9217 : Local<Value> value) {
9218 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9219 : ENTER_V8(isolate);
9220 106344 : i::Handle<i::Object> val = Utils::OpenHandle(*value);
9221 : i::Handle<i::JSArray> result;
9222 212688 : if (!i::Runtime::GetInternalProperties(isolate, val).ToHandle(&result))
9223 0 : return MaybeLocal<Array>();
9224 106344 : return Utils::ToLocal(result);
9225 : }
9226 :
9227 10287 : void debug::ChangeBreakOnException(Isolate* isolate, ExceptionBreakState type) {
9228 20574 : i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
9229 : internal_isolate->debug()->ChangeBreakOnException(
9230 20574 : i::BreakException, type == BreakOnAnyException);
9231 : internal_isolate->debug()->ChangeBreakOnException(i::BreakUncaughtException,
9232 20574 : type != NoBreakOnException);
9233 10287 : }
9234 :
9235 4519 : void debug::SetBreakPointsActive(Isolate* v8_isolate, bool is_active) {
9236 4519 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9237 : ENTER_V8(isolate);
9238 : isolate->debug()->set_break_points_active(is_active);
9239 4519 : }
9240 :
9241 8624 : void debug::SetOutOfMemoryCallback(Isolate* isolate,
9242 : OutOfMemoryCallback callback, void* data) {
9243 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
9244 : ENTER_V8(i_isolate);
9245 8624 : i_isolate->heap()->SetOutOfMemoryCallback(callback, data);
9246 8624 : }
9247 :
9248 62890 : void debug::PrepareStep(Isolate* v8_isolate, StepAction action) {
9249 125780 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9250 : ENTER_V8(isolate);
9251 62890 : CHECK(isolate->debug()->CheckExecutionState());
9252 : // Clear all current stepping setup.
9253 62890 : isolate->debug()->ClearStepping();
9254 : // Prepare step.
9255 125780 : isolate->debug()->PrepareStep(static_cast<i::StepAction>(action));
9256 62890 : }
9257 :
9258 72 : void debug::ClearStepping(Isolate* v8_isolate) {
9259 72 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9260 : ENTER_V8(isolate);
9261 : // Clear all current stepping setup.
9262 72 : isolate->debug()->ClearStepping();
9263 72 : }
9264 :
9265 66 : void debug::BreakRightNow(Isolate* v8_isolate) {
9266 66 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9267 : ENTER_V8(isolate);
9268 66 : isolate->debug()->HandleDebugBreak(i::kIgnoreIfAllFramesBlackboxed);
9269 66 : }
9270 :
9271 144 : bool debug::AllFramesOnStackAreBlackboxed(Isolate* v8_isolate) {
9272 144 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9273 : ENTER_V8(isolate);
9274 288 : return isolate->debug()->AllFramesOnStackAreBlackboxed();
9275 : }
9276 :
9277 0 : v8::Isolate* debug::Script::GetIsolate() const {
9278 0 : return reinterpret_cast<v8::Isolate*>(Utils::OpenHandle(this)->GetIsolate());
9279 : }
9280 :
9281 0 : ScriptOriginOptions debug::Script::OriginOptions() const {
9282 0 : return Utils::OpenHandle(this)->origin_options();
9283 : }
9284 :
9285 12100 : bool debug::Script::WasCompiled() const {
9286 : return Utils::OpenHandle(this)->compilation_state() ==
9287 12100 : i::Script::COMPILATION_STATE_COMPILED;
9288 : }
9289 :
9290 12076 : bool debug::Script::IsEmbedded() const {
9291 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9292 12076 : return script->context_data() == script->GetHeap()->uninitialized_symbol();
9293 : }
9294 :
9295 107772 : int debug::Script::Id() const { return Utils::OpenHandle(this)->id(); }
9296 :
9297 36576 : int debug::Script::LineOffset() const {
9298 36576 : return Utils::OpenHandle(this)->line_offset();
9299 : }
9300 :
9301 36576 : int debug::Script::ColumnOffset() const {
9302 36576 : return Utils::OpenHandle(this)->column_offset();
9303 : }
9304 :
9305 36576 : std::vector<int> debug::Script::LineEnds() const {
9306 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9307 36576 : if (script->type() == i::Script::TYPE_WASM) return std::vector<int>();
9308 : i::Isolate* isolate = script->GetIsolate();
9309 : i::HandleScope scope(isolate);
9310 36576 : i::Script::InitLineEnds(script);
9311 36576 : CHECK(script->line_ends()->IsFixedArray());
9312 : i::Handle<i::FixedArray> line_ends(i::FixedArray::cast(script->line_ends()));
9313 36576 : std::vector<int> result(line_ends->length());
9314 12505440 : for (int i = 0; i < line_ends->length(); ++i) {
9315 : i::Smi* line_end = i::Smi::cast(line_ends->get(i));
9316 12432288 : result[i] = line_end->value();
9317 : }
9318 : return result;
9319 : }
9320 :
9321 36796 : MaybeLocal<String> debug::Script::Name() const {
9322 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
9323 : i::HandleScope handle_scope(isolate);
9324 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9325 : i::Handle<i::Object> value(script->name(), isolate);
9326 36796 : if (!value->IsString()) return MaybeLocal<String>();
9327 : return Utils::ToLocal(
9328 15983 : handle_scope.CloseAndEscape(i::Handle<i::String>::cast(value)));
9329 : }
9330 :
9331 57389 : MaybeLocal<String> debug::Script::SourceURL() const {
9332 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
9333 : i::HandleScope handle_scope(isolate);
9334 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9335 : i::Handle<i::Object> value(script->source_url(), isolate);
9336 57389 : if (!value->IsString()) return MaybeLocal<String>();
9337 : return Utils::ToLocal(
9338 1301 : handle_scope.CloseAndEscape(i::Handle<i::String>::cast(value)));
9339 : }
9340 :
9341 36576 : MaybeLocal<String> debug::Script::SourceMappingURL() const {
9342 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
9343 : i::HandleScope handle_scope(isolate);
9344 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9345 : i::Handle<i::Object> value(script->source_mapping_url(), isolate);
9346 36576 : if (!value->IsString()) return MaybeLocal<String>();
9347 : return Utils::ToLocal(
9348 3367 : handle_scope.CloseAndEscape(i::Handle<i::String>::cast(value)));
9349 : }
9350 :
9351 90224 : Maybe<int> debug::Script::ContextId() const {
9352 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
9353 : i::HandleScope handle_scope(isolate);
9354 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9355 : i::Object* value = script->context_data();
9356 90224 : if (value->IsSmi()) return Just(i::Smi::cast(value)->value());
9357 : return Nothing<int>();
9358 : }
9359 :
9360 36582 : MaybeLocal<String> debug::Script::Source() const {
9361 : i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
9362 : i::HandleScope handle_scope(isolate);
9363 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9364 : i::Handle<i::Object> value(script->source(), isolate);
9365 36582 : if (!value->IsString()) return MaybeLocal<String>();
9366 : return Utils::ToLocal(
9367 36582 : handle_scope.CloseAndEscape(i::Handle<i::String>::cast(value)));
9368 : }
9369 :
9370 24646 : bool debug::Script::IsWasm() const {
9371 24646 : return Utils::OpenHandle(this)->type() == i::Script::TYPE_WASM;
9372 : }
9373 :
9374 36576 : bool debug::Script::IsModule() const {
9375 36576 : return Utils::OpenHandle(this)->origin_options().IsModule();
9376 : }
9377 :
9378 : namespace {
9379 : int GetSmiValue(i::Handle<i::FixedArray> array, int index) {
9380 : return i::Smi::cast(array->get(index))->value();
9381 : }
9382 :
9383 21752 : bool CompareBreakLocation(const i::BreakLocation& loc1,
9384 21752 : const i::BreakLocation& loc2) {
9385 21752 : return loc1.position() < loc2.position();
9386 : }
9387 : } // namespace
9388 :
9389 258 : bool debug::Script::GetPossibleBreakpoints(
9390 : const debug::Location& start, const debug::Location& end,
9391 : bool restrict_to_function,
9392 : std::vector<debug::BreakLocation>* locations) const {
9393 258 : CHECK(!start.IsEmpty());
9394 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9395 258 : if (script->type() == i::Script::TYPE_WASM) {
9396 : i::Handle<i::WasmCompiledModule> compiled_module(
9397 : i::WasmCompiledModule::cast(script->wasm_compiled_module()));
9398 36 : return compiled_module->GetPossibleBreakpoints(start, end, locations);
9399 : }
9400 :
9401 222 : i::Script::InitLineEnds(script);
9402 222 : CHECK(script->line_ends()->IsFixedArray());
9403 192 : i::Isolate* isolate = script->GetIsolate();
9404 : i::Handle<i::FixedArray> line_ends =
9405 : i::Handle<i::FixedArray>::cast(i::handle(script->line_ends(), isolate));
9406 222 : CHECK(line_ends->length());
9407 :
9408 222 : int start_offset = GetSourceOffset(start);
9409 : int end_offset = end.IsEmpty()
9410 120 : ? GetSmiValue(line_ends, line_ends->length() - 1) + 1
9411 342 : : GetSourceOffset(end);
9412 222 : if (start_offset >= end_offset) return true;
9413 :
9414 : std::vector<i::BreakLocation> v8_locations;
9415 192 : if (!isolate->debug()->GetPossibleBreakpoints(
9416 : script, start_offset, end_offset, restrict_to_function,
9417 384 : &v8_locations)) {
9418 : return false;
9419 : }
9420 :
9421 192 : std::sort(v8_locations.begin(), v8_locations.end(), CompareBreakLocation);
9422 : int current_line_end_index = 0;
9423 3822 : for (const auto& v8_location : v8_locations) {
9424 : int offset = v8_location.position();
9425 8868 : while (offset > GetSmiValue(line_ends, current_line_end_index)) {
9426 1992 : ++current_line_end_index;
9427 1992 : CHECK(current_line_end_index < line_ends->length());
9428 : }
9429 : int line_offset = 0;
9430 :
9431 3438 : if (current_line_end_index > 0) {
9432 5820 : line_offset = GetSmiValue(line_ends, current_line_end_index - 1) + 1;
9433 : }
9434 : locations->emplace_back(
9435 3438 : current_line_end_index + script->line_offset(),
9436 6876 : offset - line_offset +
9437 : (current_line_end_index == 0 ? script->column_offset() : 0),
9438 10314 : v8_location.type());
9439 : }
9440 : return true;
9441 : }
9442 :
9443 486 : int debug::Script::GetSourceOffset(const debug::Location& location) const {
9444 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9445 486 : if (script->type() == i::Script::TYPE_WASM) {
9446 : // TODO(clemensh): Return the proper thing for wasm.
9447 : return 0;
9448 : }
9449 :
9450 1458 : int line = std::max(location.GetLineNumber() - script->line_offset(), 0);
9451 486 : int column = location.GetColumnNumber();
9452 486 : if (line == 0) {
9453 420 : column = std::max(0, column - script->column_offset());
9454 : }
9455 :
9456 486 : i::Script::InitLineEnds(script);
9457 486 : CHECK(script->line_ends()->IsFixedArray());
9458 : i::Handle<i::FixedArray> line_ends = i::Handle<i::FixedArray>::cast(
9459 : i::handle(script->line_ends(), script->GetIsolate()));
9460 486 : CHECK(line_ends->length());
9461 486 : if (line >= line_ends->length())
9462 180 : return GetSmiValue(line_ends, line_ends->length() - 1);
9463 396 : int line_offset = GetSmiValue(line_ends, line);
9464 606 : if (line == 0) return std::min(column, line_offset);
9465 186 : int prev_line_offset = GetSmiValue(line_ends, line - 1);
9466 372 : return std::min(prev_line_offset + column + 1, line_offset);
9467 : }
9468 :
9469 54 : v8::debug::Location debug::Script::GetSourceLocation(int offset) const {
9470 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9471 54 : if (script->type() == i::Script::TYPE_WASM) {
9472 : // TODO(clemensh): Return the proper thing for wasm.
9473 0 : return v8::debug::Location();
9474 : }
9475 : i::Script::PositionInfo info;
9476 54 : i::Script::GetPositionInfo(script, offset, &info, i::Script::WITH_OFFSET);
9477 54 : return debug::Location(info.line, info.column);
9478 : }
9479 :
9480 56 : debug::WasmScript* debug::WasmScript::Cast(debug::Script* script) {
9481 56 : CHECK(script->IsWasm());
9482 56 : return static_cast<WasmScript*>(script);
9483 : }
9484 :
9485 156 : int debug::WasmScript::NumFunctions() const {
9486 : i::DisallowHeapAllocation no_gc;
9487 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9488 : DCHECK_EQ(i::Script::TYPE_WASM, script->type());
9489 : i::WasmCompiledModule* compiled_module =
9490 : i::WasmCompiledModule::cast(script->wasm_compiled_module());
9491 : DCHECK_GE(i::kMaxInt, compiled_module->module()->functions.size());
9492 312 : return static_cast<int>(compiled_module->module()->functions.size());
9493 : }
9494 :
9495 156 : int debug::WasmScript::NumImportedFunctions() const {
9496 : i::DisallowHeapAllocation no_gc;
9497 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9498 : DCHECK_EQ(i::Script::TYPE_WASM, script->type());
9499 : i::WasmCompiledModule* compiled_module =
9500 : i::WasmCompiledModule::cast(script->wasm_compiled_module());
9501 : DCHECK_GE(i::kMaxInt, compiled_module->module()->num_imported_functions);
9502 156 : return static_cast<int>(compiled_module->module()->num_imported_functions);
9503 : }
9504 :
9505 6 : std::pair<int, int> debug::WasmScript::GetFunctionRange(
9506 : int function_index) const {
9507 : i::DisallowHeapAllocation no_gc;
9508 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9509 : DCHECK_EQ(i::Script::TYPE_WASM, script->type());
9510 : i::WasmCompiledModule* compiled_module =
9511 : i::WasmCompiledModule::cast(script->wasm_compiled_module());
9512 : DCHECK_LE(0, function_index);
9513 : DCHECK_GT(compiled_module->module()->functions.size(), function_index);
9514 : i::wasm::WasmFunction& func =
9515 6 : compiled_module->module()->functions[function_index];
9516 : DCHECK_GE(i::kMaxInt, func.code_start_offset);
9517 : DCHECK_GE(i::kMaxInt, func.code_end_offset);
9518 : return std::make_pair(static_cast<int>(func.code_start_offset),
9519 6 : static_cast<int>(func.code_end_offset));
9520 : }
9521 :
9522 100 : debug::WasmDisassembly debug::WasmScript::DisassembleFunction(
9523 : int function_index) const {
9524 : i::DisallowHeapAllocation no_gc;
9525 : i::Handle<i::Script> script = Utils::OpenHandle(this);
9526 : DCHECK_EQ(i::Script::TYPE_WASM, script->type());
9527 : i::WasmCompiledModule* compiled_module =
9528 : i::WasmCompiledModule::cast(script->wasm_compiled_module());
9529 100 : return compiled_module->DisassembleFunction(function_index);
9530 : }
9531 :
9532 44500 : debug::Location::Location(int line_number, int column_number)
9533 44500 : : line_number_(line_number), column_number_(column_number) {
9534 44500 : CHECK(line_number >= 0);
9535 44500 : CHECK(column_number >= 0);
9536 44500 : }
9537 :
9538 270 : debug::Location::Location()
9539 : : line_number_(v8::Function::kLineOffsetNotFound),
9540 270 : column_number_(v8::Function::kLineOffsetNotFound) {}
9541 :
9542 10731 : int debug::Location::GetLineNumber() const {
9543 10731 : CHECK(line_number_ >= 0);
9544 10731 : return line_number_;
9545 : }
9546 :
9547 8586 : int debug::Location::GetColumnNumber() const {
9548 8586 : CHECK(column_number_ >= 0);
9549 8586 : return column_number_;
9550 : }
9551 :
9552 289 : bool debug::Location::IsEmpty() const {
9553 769 : return line_number_ == -1 && column_number_ == -1;
9554 : }
9555 :
9556 4345 : void debug::GetLoadedScripts(v8::Isolate* v8_isolate,
9557 : PersistentValueVector<debug::Script>& scripts) {
9558 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9559 : ENTER_V8(isolate);
9560 : // TODO(kozyatinskiy): remove this GC once tests are dealt with.
9561 : isolate->heap()->CollectAllGarbage(i::Heap::kFinalizeIncrementalMarkingMask,
9562 4345 : i::GarbageCollectionReason::kDebugger);
9563 : {
9564 : i::DisallowHeapAllocation no_gc;
9565 4345 : i::Script::Iterator iterator(isolate);
9566 : i::Script* script;
9567 116496 : while ((script = iterator.Next()) != nullptr) {
9568 107806 : if (!script->IsUserJavaScript()) continue;
9569 12106 : if (script->HasValidSource()) {
9570 : i::HandleScope handle_scope(isolate);
9571 : i::Handle<i::Script> script_handle(script, isolate);
9572 12106 : scripts.Append(ToApiHandle<Script>(script_handle));
9573 : }
9574 : }
9575 : }
9576 4345 : }
9577 :
9578 8594 : MaybeLocal<UnboundScript> debug::CompileInspectorScript(Isolate* v8_isolate,
9579 : Local<String> source) {
9580 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9581 25782 : PREPARE_FOR_DEBUG_INTERFACE_EXECUTION_WITH_ISOLATE(isolate, UnboundScript);
9582 8594 : i::ScriptData* script_data = NULL;
9583 8594 : i::Handle<i::String> str = Utils::OpenHandle(*source);
9584 : i::Handle<i::SharedFunctionInfo> result;
9585 : {
9586 : ScriptOriginOptions origin_options;
9587 : result = i::Compiler::GetSharedFunctionInfoForScript(
9588 : str, i::Handle<i::Object>(), 0, 0, origin_options,
9589 : i::Handle<i::Object>(), isolate->native_context(), NULL, &script_data,
9590 : ScriptCompiler::kNoCompileOptions,
9591 : i::FLAG_expose_inspector_scripts ? i::NOT_NATIVES_CODE
9592 17188 : : i::INSPECTOR_CODE);
9593 : has_pending_exception = result.is_null();
9594 8594 : RETURN_ON_FAILED_EXECUTION(UnboundScript);
9595 : }
9596 8594 : RETURN_ESCAPED(ToApiHandle<UnboundScript>(result));
9597 : }
9598 :
9599 8742 : void debug::SetDebugDelegate(Isolate* v8_isolate,
9600 : debug::DebugDelegate* delegate) {
9601 8742 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9602 : ENTER_V8(isolate);
9603 8742 : isolate->debug()->SetDebugDelegate(delegate, false);
9604 8742 : }
9605 :
9606 73324 : void debug::ResetBlackboxedStateCache(Isolate* v8_isolate,
9607 : v8::Local<debug::Script> script) {
9608 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9609 : ENTER_V8(isolate);
9610 : i::DisallowHeapAllocation no_gc;
9611 73324 : i::SharedFunctionInfo::ScriptIterator iter(Utils::OpenHandle(*script));
9612 1128257 : while (i::SharedFunctionInfo* info = iter.Next()) {
9613 1054933 : info->set_computed_debug_is_blackboxed(false);
9614 : }
9615 73324 : }
9616 :
9617 7344 : int debug::EstimatedValueSize(Isolate* v8_isolate, v8::Local<v8::Value> value) {
9618 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9619 : ENTER_V8(isolate);
9620 : i::Handle<i::Object> object = Utils::OpenHandle(*value);
9621 7344 : if (object->IsSmi()) return i::kPointerSize;
9622 6792 : CHECK(object->IsHeapObject());
9623 6792 : return i::Handle<i::HeapObject>::cast(object)->Size();
9624 : }
9625 :
9626 106344 : v8::MaybeLocal<v8::Array> debug::EntriesPreview(Isolate* v8_isolate,
9627 : v8::Local<v8::Value> value,
9628 : bool* is_key_value) {
9629 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9630 : ENTER_V8(isolate);
9631 106344 : if (value->IsMap()) {
9632 44 : *is_key_value = true;
9633 44 : return value.As<Map>()->AsArray();
9634 : }
9635 106300 : if (value->IsSet()) {
9636 48 : *is_key_value = false;
9637 48 : return value.As<Set>()->AsArray();
9638 : }
9639 :
9640 : i::Handle<i::Object> object = Utils::OpenHandle(*value);
9641 106252 : if (object->IsJSWeakCollection()) {
9642 36 : *is_key_value = object->IsJSWeakMap();
9643 : return Utils::ToLocal(i::JSWeakCollection::GetEntries(
9644 36 : i::Handle<i::JSWeakCollection>::cast(object), 0));
9645 : }
9646 106216 : if (object->IsJSMapIterator()) {
9647 : i::Handle<i::JSMapIterator> iterator =
9648 : i::Handle<i::JSMapIterator>::cast(object);
9649 : int iterator_kind = i::Smi::cast(iterator->kind())->value();
9650 84 : *is_key_value = iterator_kind == i::JSMapIterator::kKindEntries;
9651 84 : if (!iterator->HasMore()) return v8::Array::New(v8_isolate);
9652 : return Utils::ToLocal(MapAsArray(isolate, iterator->table(),
9653 : i::Smi::cast(iterator->index())->value(),
9654 78 : iterator_kind));
9655 : }
9656 106132 : if (object->IsJSSetIterator()) {
9657 : i::Handle<i::JSSetIterator> it = i::Handle<i::JSSetIterator>::cast(object);
9658 42 : *is_key_value = false;
9659 42 : if (!it->HasMore()) return v8::Array::New(v8_isolate);
9660 : return Utils::ToLocal(
9661 36 : SetAsArray(isolate, it->table(), i::Smi::cast(it->index())->value()));
9662 : }
9663 106090 : return v8::MaybeLocal<v8::Array>();
9664 : }
9665 :
9666 20545 : Local<Function> debug::GetBuiltin(Isolate* v8_isolate, Builtin builtin) {
9667 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9668 : ENTER_V8(isolate);
9669 : i::HandleScope handle_scope(isolate);
9670 : i::Builtins::Name name;
9671 20545 : switch (builtin) {
9672 : case kObjectKeys:
9673 : name = i::Builtins::kObjectKeys;
9674 4109 : break;
9675 : case kObjectGetPrototypeOf:
9676 : name = i::Builtins::kObjectGetPrototypeOf;
9677 4109 : break;
9678 : case kObjectGetOwnPropertyDescriptor:
9679 : name = i::Builtins::kObjectGetOwnPropertyDescriptor;
9680 4109 : break;
9681 : case kObjectGetOwnPropertyNames:
9682 : name = i::Builtins::kObjectGetOwnPropertyNames;
9683 4109 : break;
9684 : case kObjectGetOwnPropertySymbols:
9685 : name = i::Builtins::kObjectGetOwnPropertySymbols;
9686 4109 : break;
9687 : }
9688 : i::Handle<i::Code> call_code(isolate->builtins()->builtin(name));
9689 : i::Handle<i::JSFunction> fun =
9690 : isolate->factory()->NewFunctionWithoutPrototype(
9691 20545 : isolate->factory()->empty_string(), call_code, false);
9692 : fun->shared()->DontAdaptArguments();
9693 41090 : return Utils::ToLocal(handle_scope.CloseAndEscape(fun));
9694 : }
9695 :
9696 38231 : void debug::SetConsoleDelegate(Isolate* v8_isolate, ConsoleDelegate* delegate) {
9697 : i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
9698 : ENTER_V8(isolate);
9699 : isolate->set_console_delegate(delegate);
9700 38231 : }
9701 :
9702 318 : debug::ConsoleCallArguments::ConsoleCallArguments(
9703 : const v8::FunctionCallbackInfo<v8::Value>& info)
9704 318 : : v8::FunctionCallbackInfo<v8::Value>(nullptr, info.values_, info.length_) {
9705 318 : }
9706 :
9707 8105 : debug::ConsoleCallArguments::ConsoleCallArguments(
9708 : internal::BuiltinArguments& args)
9709 : : v8::FunctionCallbackInfo<v8::Value>(nullptr, &args[0] - 1,
9710 24315 : args.length() - 1) {}
9711 :
9712 6378 : int debug::GetStackFrameId(v8::Local<v8::StackFrame> frame) {
9713 6378 : return Utils::OpenHandle(*frame)->id();
9714 : }
9715 :
9716 42 : MaybeLocal<debug::Script> debug::GeneratorObject::Script() {
9717 : i::Handle<i::JSGeneratorObject> obj = Utils::OpenHandle(this);
9718 : i::Object* maybe_script = obj->function()->shared()->script();
9719 42 : if (!maybe_script->IsScript()) return MaybeLocal<debug::Script>();
9720 : i::Handle<i::Script> script(i::Script::cast(maybe_script), obj->GetIsolate());
9721 42 : return ToApiHandle<debug::Script>(script);
9722 : }
9723 :
9724 12 : Local<Function> debug::GeneratorObject::Function() {
9725 : i::Handle<i::JSGeneratorObject> obj = Utils::OpenHandle(this);
9726 12 : return Utils::ToLocal(handle(obj->function()));
9727 : }
9728 :
9729 42 : debug::Location debug::GeneratorObject::SuspendedLocation() {
9730 : i::Handle<i::JSGeneratorObject> obj = Utils::OpenHandle(this);
9731 42 : CHECK(obj->is_suspended());
9732 : i::Object* maybe_script = obj->function()->shared()->script();
9733 42 : if (!maybe_script->IsScript()) return debug::Location();
9734 : i::Handle<i::Script> script(i::Script::cast(maybe_script), obj->GetIsolate());
9735 : i::Script::PositionInfo info;
9736 : i::Script::GetPositionInfo(script, obj->source_position(), &info,
9737 42 : i::Script::WITH_OFFSET);
9738 42 : return debug::Location(info.line, info.column);
9739 : }
9740 :
9741 54 : bool debug::GeneratorObject::IsSuspended() {
9742 54 : return Utils::OpenHandle(this)->is_suspended();
9743 : }
9744 :
9745 54 : v8::Local<debug::GeneratorObject> debug::GeneratorObject::Cast(
9746 : v8::Local<v8::Value> value) {
9747 54 : CHECK(value->IsGeneratorObject());
9748 54 : return ToApiHandle<debug::GeneratorObject>(Utils::OpenHandle(*value));
9749 : }
9750 :
9751 535 : Local<String> CpuProfileNode::GetFunctionName() const {
9752 1070 : const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
9753 : i::Isolate* isolate = node->isolate();
9754 1070 : const i::CodeEntry* entry = node->entry();
9755 : i::Handle<i::String> name =
9756 535 : isolate->factory()->InternalizeUtf8String(entry->name());
9757 535 : if (!entry->has_name_prefix()) {
9758 : return ToApiHandle<String>(name);
9759 : } else {
9760 : // We do not expect this to fail. Change this if it does.
9761 : i::Handle<i::String> cons = isolate->factory()->NewConsString(
9762 : isolate->factory()->InternalizeUtf8String(entry->name_prefix()),
9763 72 : name).ToHandleChecked();
9764 : return ToApiHandle<String>(cons);
9765 : }
9766 : }
9767 :
9768 300 : int debug::Coverage::FunctionData::StartOffset() const {
9769 300 : return function_->start;
9770 : }
9771 300 : int debug::Coverage::FunctionData::EndOffset() const { return function_->end; }
9772 300 : uint32_t debug::Coverage::FunctionData::Count() const {
9773 300 : return function_->count;
9774 : }
9775 :
9776 288 : MaybeLocal<String> debug::Coverage::FunctionData::Name() const {
9777 288 : return ToApiHandle<String>(function_->name);
9778 : }
9779 :
9780 126 : Local<debug::Script> debug::Coverage::ScriptData::GetScript() const {
9781 126 : return ToApiHandle<debug::Script>(script_->script);
9782 : }
9783 :
9784 414 : size_t debug::Coverage::ScriptData::FunctionCount() const {
9785 828 : return script_->functions.size();
9786 : }
9787 :
9788 300 : debug::Coverage::FunctionData debug::Coverage::ScriptData::GetFunctionData(
9789 : size_t i) const {
9790 600 : return FunctionData(&script_->functions.at(i));
9791 : }
9792 :
9793 204 : debug::Coverage::~Coverage() { delete coverage_; }
9794 :
9795 444 : size_t debug::Coverage::ScriptCount() const { return coverage_->size(); }
9796 :
9797 126 : debug::Coverage::ScriptData debug::Coverage::GetScriptData(size_t i) const {
9798 252 : return ScriptData(&coverage_->at(i));
9799 : }
9800 :
9801 66 : debug::Coverage debug::Coverage::CollectPrecise(Isolate* isolate) {
9802 : return Coverage(
9803 132 : i::Coverage::CollectPrecise(reinterpret_cast<i::Isolate*>(isolate)));
9804 : }
9805 :
9806 36 : debug::Coverage debug::Coverage::CollectBestEffort(Isolate* isolate) {
9807 : return Coverage(
9808 72 : i::Coverage::CollectBestEffort(reinterpret_cast<i::Isolate*>(isolate)));
9809 : }
9810 :
9811 182 : void debug::Coverage::SelectMode(Isolate* isolate, debug::Coverage::Mode mode) {
9812 182 : i::Coverage::SelectMode(reinterpret_cast<i::Isolate*>(isolate), mode);
9813 182 : }
9814 :
9815 24 : const char* CpuProfileNode::GetFunctionNameStr() const {
9816 24 : const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
9817 24 : return node->entry()->name();
9818 : }
9819 :
9820 149 : int CpuProfileNode::GetScriptId() const {
9821 149 : const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
9822 149 : const i::CodeEntry* entry = node->entry();
9823 149 : return entry->script_id();
9824 : }
9825 :
9826 135 : Local<String> CpuProfileNode::GetScriptResourceName() const {
9827 270 : const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
9828 : i::Isolate* isolate = node->isolate();
9829 : return ToApiHandle<String>(isolate->factory()->InternalizeUtf8String(
9830 135 : node->entry()->resource_name()));
9831 : }
9832 :
9833 24 : const char* CpuProfileNode::GetScriptResourceNameStr() const {
9834 24 : const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
9835 24 : return node->entry()->resource_name();
9836 : }
9837 :
9838 135 : int CpuProfileNode::GetLineNumber() const {
9839 135 : return reinterpret_cast<const i::ProfileNode*>(this)->entry()->line_number();
9840 : }
9841 :
9842 :
9843 135 : int CpuProfileNode::GetColumnNumber() const {
9844 : return reinterpret_cast<const i::ProfileNode*>(this)->
9845 135 : entry()->column_number();
9846 : }
9847 :
9848 :
9849 111 : unsigned int CpuProfileNode::GetHitLineCount() const {
9850 : const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
9851 111 : return node->GetHitLineCount();
9852 : }
9853 :
9854 :
9855 24 : bool CpuProfileNode::GetLineTicks(LineTick* entries,
9856 : unsigned int length) const {
9857 : const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
9858 24 : return node->GetLineTicks(entries, length);
9859 : }
9860 :
9861 :
9862 118 : const char* CpuProfileNode::GetBailoutReason() const {
9863 118 : const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
9864 118 : return node->entry()->bailout_reason();
9865 : }
9866 :
9867 :
9868 123 : unsigned CpuProfileNode::GetHitCount() const {
9869 123 : return reinterpret_cast<const i::ProfileNode*>(this)->self_ticks();
9870 : }
9871 :
9872 :
9873 0 : unsigned CpuProfileNode::GetCallUid() const {
9874 0 : return reinterpret_cast<const i::ProfileNode*>(this)->function_id();
9875 : }
9876 :
9877 :
9878 290 : unsigned CpuProfileNode::GetNodeId() const {
9879 290 : return reinterpret_cast<const i::ProfileNode*>(this)->id();
9880 : }
9881 :
9882 :
9883 520 : int CpuProfileNode::GetChildrenCount() const {
9884 520 : return reinterpret_cast<const i::ProfileNode*>(this)->children()->length();
9885 : }
9886 :
9887 :
9888 554 : const CpuProfileNode* CpuProfileNode::GetChild(int index) const {
9889 : const i::ProfileNode* child =
9890 554 : reinterpret_cast<const i::ProfileNode*>(this)->children()->at(index);
9891 554 : return reinterpret_cast<const CpuProfileNode*>(child);
9892 : }
9893 :
9894 :
9895 0 : const std::vector<CpuProfileDeoptInfo>& CpuProfileNode::GetDeoptInfos() const {
9896 : const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
9897 0 : return node->deopt_infos();
9898 : }
9899 :
9900 :
9901 142 : void CpuProfile::Delete() {
9902 142 : i::CpuProfile* profile = reinterpret_cast<i::CpuProfile*>(this);
9903 : i::CpuProfiler* profiler = profile->cpu_profiler();
9904 : DCHECK(profiler != nullptr);
9905 142 : profiler->DeleteProfile(profile);
9906 142 : }
9907 :
9908 :
9909 0 : Local<String> CpuProfile::GetTitle() const {
9910 0 : const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
9911 0 : i::Isolate* isolate = profile->top_down()->isolate();
9912 : return ToApiHandle<String>(isolate->factory()->InternalizeUtf8String(
9913 0 : profile->title()));
9914 : }
9915 :
9916 :
9917 138 : const CpuProfileNode* CpuProfile::GetTopDownRoot() const {
9918 : const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
9919 138 : return reinterpret_cast<const CpuProfileNode*>(profile->top_down()->root());
9920 : }
9921 :
9922 :
9923 9162 : const CpuProfileNode* CpuProfile::GetSample(int index) const {
9924 : const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
9925 9162 : return reinterpret_cast<const CpuProfileNode*>(profile->sample(index));
9926 : }
9927 :
9928 :
9929 9162 : int64_t CpuProfile::GetSampleTimestamp(int index) const {
9930 : const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
9931 : return (profile->sample_timestamp(index) - base::TimeTicks())
9932 9162 : .InMicroseconds();
9933 : }
9934 :
9935 :
9936 80 : int64_t CpuProfile::GetStartTime() const {
9937 : const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
9938 80 : return (profile->start_time() - base::TimeTicks()).InMicroseconds();
9939 : }
9940 :
9941 :
9942 46 : int64_t CpuProfile::GetEndTime() const {
9943 : const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this);
9944 46 : return (profile->end_time() - base::TimeTicks()).InMicroseconds();
9945 : }
9946 :
9947 :
9948 9140 : int CpuProfile::GetSamplesCount() const {
9949 9140 : return reinterpret_cast<const i::CpuProfile*>(this)->samples_count();
9950 : }
9951 :
9952 224 : CpuProfiler* CpuProfiler::New(Isolate* isolate) {
9953 : return reinterpret_cast<CpuProfiler*>(
9954 224 : new i::CpuProfiler(reinterpret_cast<i::Isolate*>(isolate)));
9955 : }
9956 :
9957 224 : void CpuProfiler::Dispose() { delete reinterpret_cast<i::CpuProfiler*>(this); }
9958 :
9959 54 : void CpuProfiler::SetSamplingInterval(int us) {
9960 : DCHECK_GE(us, 0);
9961 : return reinterpret_cast<i::CpuProfiler*>(this)->set_sampling_interval(
9962 54 : base::TimeDelta::FromMicroseconds(us));
9963 : }
9964 :
9965 6 : void CpuProfiler::CollectSample() {
9966 6 : reinterpret_cast<i::CpuProfiler*>(this)->CollectSample();
9967 6 : }
9968 :
9969 464 : void CpuProfiler::StartProfiling(Local<String> title, bool record_samples) {
9970 : reinterpret_cast<i::CpuProfiler*>(this)->StartProfiling(
9971 928 : *Utils::OpenHandle(*title), record_samples);
9972 464 : }
9973 :
9974 :
9975 187 : CpuProfile* CpuProfiler::StopProfiling(Local<String> title) {
9976 : return reinterpret_cast<CpuProfile*>(
9977 : reinterpret_cast<i::CpuProfiler*>(this)->StopProfiling(
9978 187 : *Utils::OpenHandle(*title)));
9979 : }
9980 :
9981 :
9982 44 : void CpuProfiler::SetIdle(bool is_idle) {
9983 44 : i::CpuProfiler* profiler = reinterpret_cast<i::CpuProfiler*>(this);
9984 56 : i::Isolate* isolate = profiler->isolate();
9985 44 : if (!isolate->is_profiling()) return;
9986 : v8::StateTag state = isolate->current_vm_state();
9987 : DCHECK(state == v8::EXTERNAL || state == v8::IDLE);
9988 12 : if (isolate->js_entry_sp() != NULL) return;
9989 12 : if (is_idle) {
9990 : isolate->set_current_vm_state(v8::IDLE);
9991 6 : } else if (state == v8::IDLE) {
9992 : isolate->set_current_vm_state(v8::EXTERNAL);
9993 : }
9994 : }
9995 :
9996 :
9997 : static i::HeapGraphEdge* ToInternal(const HeapGraphEdge* edge) {
9998 : return const_cast<i::HeapGraphEdge*>(
9999 : reinterpret_cast<const i::HeapGraphEdge*>(edge));
10000 : }
10001 :
10002 :
10003 7260866 : HeapGraphEdge::Type HeapGraphEdge::GetType() const {
10004 14521732 : return static_cast<HeapGraphEdge::Type>(ToInternal(this)->type());
10005 : }
10006 :
10007 :
10008 7202939 : Local<Value> HeapGraphEdge::GetName() const {
10009 14405878 : i::HeapGraphEdge* edge = ToInternal(this);
10010 : i::Isolate* isolate = edge->isolate();
10011 7202939 : switch (edge->type()) {
10012 : case i::HeapGraphEdge::kContextVariable:
10013 : case i::HeapGraphEdge::kInternal:
10014 : case i::HeapGraphEdge::kProperty:
10015 : case i::HeapGraphEdge::kShortcut:
10016 : case i::HeapGraphEdge::kWeak:
10017 : return ToApiHandle<String>(
10018 7201799 : isolate->factory()->InternalizeUtf8String(edge->name()));
10019 : case i::HeapGraphEdge::kElement:
10020 : case i::HeapGraphEdge::kHidden:
10021 : return ToApiHandle<Number>(
10022 1140 : isolate->factory()->NewNumberFromInt(edge->index()));
10023 0 : default: UNREACHABLE();
10024 : }
10025 : return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
10026 : }
10027 :
10028 :
10029 372 : const HeapGraphNode* HeapGraphEdge::GetFromNode() const {
10030 : const i::HeapEntry* from = ToInternal(this)->from();
10031 372 : return reinterpret_cast<const HeapGraphNode*>(from);
10032 : }
10033 :
10034 :
10035 963347 : const HeapGraphNode* HeapGraphEdge::GetToNode() const {
10036 963347 : const i::HeapEntry* to = ToInternal(this)->to();
10037 963347 : return reinterpret_cast<const HeapGraphNode*>(to);
10038 : }
10039 :
10040 :
10041 : static i::HeapEntry* ToInternal(const HeapGraphNode* entry) {
10042 : return const_cast<i::HeapEntry*>(
10043 : reinterpret_cast<const i::HeapEntry*>(entry));
10044 : }
10045 :
10046 :
10047 468 : HeapGraphNode::Type HeapGraphNode::GetType() const {
10048 468 : return static_cast<HeapGraphNode::Type>(ToInternal(this)->type());
10049 : }
10050 :
10051 :
10052 2316 : Local<String> HeapGraphNode::GetName() const {
10053 2316 : i::Isolate* isolate = ToInternal(this)->isolate();
10054 : return ToApiHandle<String>(
10055 2316 : isolate->factory()->InternalizeUtf8String(ToInternal(this)->name()));
10056 : }
10057 :
10058 :
10059 749562 : SnapshotObjectId HeapGraphNode::GetId() const {
10060 749562 : return ToInternal(this)->id();
10061 : }
10062 :
10063 :
10064 24 : size_t HeapGraphNode::GetShallowSize() const {
10065 24 : return ToInternal(this)->self_size();
10066 : }
10067 :
10068 :
10069 88485 : int HeapGraphNode::GetChildrenCount() const {
10070 88485 : return ToInternal(this)->children_count();
10071 : }
10072 :
10073 :
10074 7720380 : const HeapGraphEdge* HeapGraphNode::GetChild(int index) const {
10075 7720380 : return reinterpret_cast<const HeapGraphEdge*>(ToInternal(this)->child(index));
10076 : }
10077 :
10078 :
10079 : static i::HeapSnapshot* ToInternal(const HeapSnapshot* snapshot) {
10080 : return const_cast<i::HeapSnapshot*>(
10081 : reinterpret_cast<const i::HeapSnapshot*>(snapshot));
10082 : }
10083 :
10084 :
10085 30 : void HeapSnapshot::Delete() {
10086 84 : i::Isolate* isolate = ToInternal(this)->profiler()->isolate();
10087 30 : if (isolate->heap_profiler()->GetSnapshotsCount() > 1) {
10088 6 : ToInternal(this)->Delete();
10089 : } else {
10090 : // If this is the last snapshot, clean up all accessory data as well.
10091 24 : isolate->heap_profiler()->DeleteAllSnapshots();
10092 : }
10093 30 : }
10094 :
10095 :
10096 526 : const HeapGraphNode* HeapSnapshot::GetRoot() const {
10097 526 : return reinterpret_cast<const HeapGraphNode*>(ToInternal(this)->root());
10098 : }
10099 :
10100 :
10101 248130 : const HeapGraphNode* HeapSnapshot::GetNodeById(SnapshotObjectId id) const {
10102 : return reinterpret_cast<const HeapGraphNode*>(
10103 248130 : ToInternal(this)->GetEntryById(id));
10104 : }
10105 :
10106 :
10107 12 : int HeapSnapshot::GetNodesCount() const {
10108 12 : return ToInternal(this)->entries().length();
10109 : }
10110 :
10111 :
10112 109120 : const HeapGraphNode* HeapSnapshot::GetNode(int index) const {
10113 : return reinterpret_cast<const HeapGraphNode*>(
10114 109120 : &ToInternal(this)->entries().at(index));
10115 : }
10116 :
10117 :
10118 24 : SnapshotObjectId HeapSnapshot::GetMaxSnapshotJSObjectId() const {
10119 24 : return ToInternal(this)->max_snapshot_js_object_id();
10120 : }
10121 :
10122 :
10123 24 : void HeapSnapshot::Serialize(OutputStream* stream,
10124 : HeapSnapshot::SerializationFormat format) const {
10125 : Utils::ApiCheck(format == kJSON,
10126 : "v8::HeapSnapshot::Serialize",
10127 : "Unknown serialization format");
10128 24 : Utils::ApiCheck(stream->GetChunkSize() > 0,
10129 : "v8::HeapSnapshot::Serialize",
10130 : "Invalid stream chunk size");
10131 : i::HeapSnapshotJSONSerializer serializer(ToInternal(this));
10132 24 : serializer.Serialize(stream);
10133 24 : }
10134 :
10135 :
10136 : // static
10137 : STATIC_CONST_MEMBER_DEFINITION const SnapshotObjectId
10138 : HeapProfiler::kUnknownObjectId;
10139 :
10140 :
10141 138 : int HeapProfiler::GetSnapshotCount() {
10142 138 : return reinterpret_cast<i::HeapProfiler*>(this)->GetSnapshotsCount();
10143 : }
10144 :
10145 :
10146 36 : const HeapSnapshot* HeapProfiler::GetHeapSnapshot(int index) {
10147 : return reinterpret_cast<const HeapSnapshot*>(
10148 36 : reinterpret_cast<i::HeapProfiler*>(this)->GetSnapshot(index));
10149 : }
10150 :
10151 :
10152 186 : SnapshotObjectId HeapProfiler::GetObjectId(Local<Value> value) {
10153 186 : i::Handle<i::Object> obj = Utils::OpenHandle(*value);
10154 186 : return reinterpret_cast<i::HeapProfiler*>(this)->GetSnapshotObjectId(obj);
10155 : }
10156 :
10157 :
10158 168 : Local<Value> HeapProfiler::FindObjectById(SnapshotObjectId id) {
10159 : i::Handle<i::Object> obj =
10160 168 : reinterpret_cast<i::HeapProfiler*>(this)->FindHeapObjectById(id);
10161 168 : if (obj.is_null()) return Local<Value>();
10162 : return Utils::ToLocal(obj);
10163 : }
10164 :
10165 :
10166 4705 : void HeapProfiler::ClearObjectIds() {
10167 4705 : reinterpret_cast<i::HeapProfiler*>(this)->ClearHeapObjectMap();
10168 4705 : }
10169 :
10170 :
10171 365 : const HeapSnapshot* HeapProfiler::TakeHeapSnapshot(
10172 : ActivityControl* control, ObjectNameResolver* resolver) {
10173 : return reinterpret_cast<const HeapSnapshot*>(
10174 : reinterpret_cast<i::HeapProfiler*>(this)
10175 365 : ->TakeSnapshot(control, resolver));
10176 : }
10177 :
10178 :
10179 48 : void HeapProfiler::StartTrackingHeapObjects(bool track_allocations) {
10180 : reinterpret_cast<i::HeapProfiler*>(this)->StartHeapObjectsTracking(
10181 48 : track_allocations);
10182 48 : }
10183 :
10184 :
10185 4747 : void HeapProfiler::StopTrackingHeapObjects() {
10186 4747 : reinterpret_cast<i::HeapProfiler*>(this)->StopHeapObjectsTracking();
10187 4747 : }
10188 :
10189 :
10190 66 : SnapshotObjectId HeapProfiler::GetHeapStats(OutputStream* stream,
10191 : int64_t* timestamp_us) {
10192 : i::HeapProfiler* heap_profiler = reinterpret_cast<i::HeapProfiler*>(this);
10193 66 : return heap_profiler->PushHeapObjectsStats(stream, timestamp_us);
10194 : }
10195 :
10196 36 : bool HeapProfiler::StartSamplingHeapProfiler(uint64_t sample_interval,
10197 : int stack_depth,
10198 : SamplingFlags flags) {
10199 : return reinterpret_cast<i::HeapProfiler*>(this)->StartSamplingHeapProfiler(
10200 36 : sample_interval, stack_depth, flags);
10201 : }
10202 :
10203 :
10204 36 : void HeapProfiler::StopSamplingHeapProfiler() {
10205 36 : reinterpret_cast<i::HeapProfiler*>(this)->StopSamplingHeapProfiler();
10206 36 : }
10207 :
10208 :
10209 42 : AllocationProfile* HeapProfiler::GetAllocationProfile() {
10210 42 : return reinterpret_cast<i::HeapProfiler*>(this)->GetAllocationProfile();
10211 : }
10212 :
10213 :
10214 30 : void HeapProfiler::DeleteAllHeapSnapshots() {
10215 30 : reinterpret_cast<i::HeapProfiler*>(this)->DeleteAllSnapshots();
10216 30 : }
10217 :
10218 :
10219 12 : void HeapProfiler::SetWrapperClassInfoProvider(uint16_t class_id,
10220 : WrapperInfoCallback callback) {
10221 : reinterpret_cast<i::HeapProfiler*>(this)->DefineWrapperClass(class_id,
10222 12 : callback);
10223 12 : }
10224 :
10225 0 : void HeapProfiler::SetGetRetainerInfosCallback(
10226 : GetRetainerInfosCallback callback) {
10227 : reinterpret_cast<i::HeapProfiler*>(this)->SetGetRetainerInfosCallback(
10228 0 : callback);
10229 0 : }
10230 :
10231 0 : size_t HeapProfiler::GetProfilerMemorySize() {
10232 : return reinterpret_cast<i::HeapProfiler*>(this)->
10233 0 : GetMemorySizeUsedByProfiler();
10234 : }
10235 :
10236 : v8::Testing::StressType internal::Testing::stress_type_ =
10237 : v8::Testing::kStressTypeOpt;
10238 :
10239 :
10240 8061 : void Testing::SetStressRunType(Testing::StressType type) {
10241 : internal::Testing::set_stress_type(type);
10242 8061 : }
10243 :
10244 :
10245 8061 : int Testing::GetStressRuns() {
10246 80594 : if (internal::FLAG_stress_runs != 0) return internal::FLAG_stress_runs;
10247 : #ifdef DEBUG
10248 : // In debug mode the code runs much slower so stressing will only make two
10249 : // runs.
10250 : return 2;
10251 : #else
10252 : return 5;
10253 : #endif
10254 : }
10255 :
10256 :
10257 32238 : static void SetFlagsFromString(const char* flags) {
10258 : V8::SetFlagsFromString(flags, i::StrLength(flags));
10259 32238 : }
10260 :
10261 :
10262 40297 : void Testing::PrepareStressRun(int run) {
10263 : static const char* kLazyOptimizations =
10264 : "--prepare-always-opt "
10265 : "--max-inlined-source-size=999999 "
10266 : "--max-inlined-nodes=999999 "
10267 : "--max-inlined-nodes-cumulative=999999 "
10268 : "--noalways-opt";
10269 : static const char* kForcedOptimizations = "--always-opt";
10270 :
10271 : // If deoptimization stressed turn on frequent deoptimization. If no value
10272 : // is spefified through --deopt-every-n-times use a default default value.
10273 : static const char* kDeoptEvery13Times = "--deopt-every-n-times=13";
10274 40297 : if (internal::Testing::stress_type() == Testing::kStressTypeDeopt &&
10275 0 : internal::FLAG_deopt_every_n_times == 0) {
10276 0 : SetFlagsFromString(kDeoptEvery13Times);
10277 : }
10278 :
10279 : #ifdef DEBUG
10280 : // As stressing in debug mode only make two runs skip the deopt stressing
10281 : // here.
10282 : if (run == GetStressRuns() - 1) {
10283 : SetFlagsFromString(kForcedOptimizations);
10284 : } else {
10285 : SetFlagsFromString(kLazyOptimizations);
10286 : }
10287 : #else
10288 40297 : if (run == GetStressRuns() - 1) {
10289 8061 : SetFlagsFromString(kForcedOptimizations);
10290 32236 : } else if (run != GetStressRuns() - 2) {
10291 24177 : SetFlagsFromString(kLazyOptimizations);
10292 : }
10293 : #endif
10294 40297 : }
10295 :
10296 :
10297 8061 : void Testing::DeoptimizeAll(Isolate* isolate) {
10298 : i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
10299 : i::HandleScope scope(i_isolate);
10300 8061 : internal::Deoptimizer::DeoptimizeAll(i_isolate);
10301 8061 : }
10302 :
10303 :
10304 : namespace internal {
10305 :
10306 :
10307 6863 : void HandleScopeImplementer::FreeThreadResources() {
10308 6863 : Free();
10309 6863 : }
10310 :
10311 :
10312 22574 : char* HandleScopeImplementer::ArchiveThread(char* storage) {
10313 22574 : HandleScopeData* current = isolate_->handle_scope_data();
10314 22574 : handle_scope_data_ = *current;
10315 : MemCopy(storage, this, sizeof(*this));
10316 :
10317 : ResetAfterArchive();
10318 : current->Initialize();
10319 :
10320 22574 : return storage + ArchiveSpacePerThread();
10321 : }
10322 :
10323 :
10324 2314 : int HandleScopeImplementer::ArchiveSpacePerThread() {
10325 2314 : return sizeof(HandleScopeImplementer);
10326 : }
10327 :
10328 :
10329 22574 : char* HandleScopeImplementer::RestoreThread(char* storage) {
10330 : MemCopy(this, storage, sizeof(*this));
10331 22574 : *isolate_->handle_scope_data() = handle_scope_data_;
10332 22574 : return storage + ArchiveSpacePerThread();
10333 : }
10334 :
10335 540571 : void HandleScopeImplementer::IterateThis(RootVisitor* v) {
10336 : #ifdef DEBUG
10337 : bool found_block_before_deferred = false;
10338 : #endif
10339 : // Iterate over all handles in the blocks except for the last.
10340 667163 : for (int i = blocks()->length() - 2; i >= 0; --i) {
10341 126592 : Object** block = blocks()->at(i);
10342 126632 : if (last_handle_before_deferred_block_ != NULL &&
10343 80 : (last_handle_before_deferred_block_ <= &block[kHandleBlockSize]) &&
10344 : (last_handle_before_deferred_block_ >= block)) {
10345 : v->VisitRootPointers(Root::kHandleScope, block,
10346 40 : last_handle_before_deferred_block_);
10347 40 : DCHECK(!found_block_before_deferred);
10348 : #ifdef DEBUG
10349 : found_block_before_deferred = true;
10350 : #endif
10351 : } else {
10352 126552 : v->VisitRootPointers(Root::kHandleScope, block, &block[kHandleBlockSize]);
10353 : }
10354 : }
10355 :
10356 : DCHECK(last_handle_before_deferred_block_ == NULL ||
10357 : found_block_before_deferred);
10358 :
10359 : // Iterate over live handles in the last block (if any).
10360 540571 : if (!blocks()->is_empty()) {
10361 : v->VisitRootPointers(Root::kHandleScope, blocks()->last(),
10362 679694 : handle_scope_data_.next);
10363 : }
10364 :
10365 540571 : List<Context*>* context_lists[2] = { &saved_contexts_, &entered_contexts_};
10366 1621713 : for (unsigned i = 0; i < arraysize(context_lists); i++) {
10367 1081142 : if (context_lists[i]->is_empty()) continue;
10368 : Object** start = reinterpret_cast<Object**>(&context_lists[i]->first());
10369 : v->VisitRootPointers(Root::kHandleScope, start,
10370 668278 : start + context_lists[i]->length());
10371 : }
10372 540571 : if (microtask_context_) {
10373 : v->VisitRootPointer(Root::kHandleScope,
10374 1450 : reinterpret_cast<Object**>(µtask_context_));
10375 : }
10376 540571 : }
10377 :
10378 536522 : void HandleScopeImplementer::Iterate(RootVisitor* v) {
10379 536522 : HandleScopeData* current = isolate_->handle_scope_data();
10380 536522 : handle_scope_data_ = *current;
10381 536522 : IterateThis(v);
10382 536522 : }
10383 :
10384 4049 : char* HandleScopeImplementer::Iterate(RootVisitor* v, char* storage) {
10385 : HandleScopeImplementer* scope_implementer =
10386 : reinterpret_cast<HandleScopeImplementer*>(storage);
10387 4049 : scope_implementer->IterateThis(v);
10388 4049 : return storage + ArchiveSpacePerThread();
10389 : }
10390 :
10391 :
10392 150621 : DeferredHandles* HandleScopeImplementer::Detach(Object** prev_limit) {
10393 : DeferredHandles* deferred =
10394 150621 : new DeferredHandles(isolate()->handle_scope_data()->next, isolate());
10395 :
10396 452407 : while (!blocks_.is_empty()) {
10397 603572 : Object** block_start = blocks_.last();
10398 301786 : Object** block_limit = &block_start[kHandleBlockSize];
10399 : // We should not need to check for SealHandleScope here. Assert this.
10400 : DCHECK(prev_limit == block_limit ||
10401 : !(block_start <= prev_limit && prev_limit <= block_limit));
10402 301786 : if (prev_limit == block_limit) break;
10403 151165 : deferred->blocks_.Add(blocks_.last());
10404 151165 : blocks_.RemoveLast();
10405 : }
10406 :
10407 : // deferred->blocks_ now contains the blocks installed on the
10408 : // HandleScope stack since BeginDeferredScope was called, but in
10409 : // reverse order.
10410 :
10411 : DCHECK(prev_limit == NULL || !blocks_.is_empty());
10412 :
10413 : DCHECK(!blocks_.is_empty() && prev_limit != NULL);
10414 : DCHECK(last_handle_before_deferred_block_ != NULL);
10415 150621 : last_handle_before_deferred_block_ = NULL;
10416 150621 : return deferred;
10417 : }
10418 :
10419 :
10420 150621 : void HandleScopeImplementer::BeginDeferredScope() {
10421 : DCHECK(last_handle_before_deferred_block_ == NULL);
10422 150621 : last_handle_before_deferred_block_ = isolate()->handle_scope_data()->next;
10423 150621 : }
10424 :
10425 :
10426 150607 : DeferredHandles::~DeferredHandles() {
10427 301758 : isolate_->UnlinkDeferredHandles(this);
10428 :
10429 603516 : for (int i = 0; i < blocks_.length(); i++) {
10430 : #ifdef ENABLE_HANDLE_ZAPPING
10431 604060 : HandleScope::ZapRange(blocks_[i], &blocks_[i][kHandleBlockSize]);
10432 : #endif
10433 151151 : isolate_->handle_scope_implementer()->ReturnBlock(blocks_[i]);
10434 : }
10435 150607 : }
10436 :
10437 24065 : void DeferredHandles::Iterate(RootVisitor* v) {
10438 : DCHECK(!blocks_.is_empty());
10439 :
10440 : DCHECK((first_block_limit_ >= blocks_.first()) &&
10441 : (first_block_limit_ <= &(blocks_.first())[kHandleBlockSize]));
10442 :
10443 73221 : v->VisitRootPointers(Root::kHandleScope, blocks_.first(), first_block_limit_);
10444 :
10445 49156 : for (int i = 1; i < blocks_.length(); i++) {
10446 : v->VisitRootPointers(Root::kHandleScope, blocks_[i],
10447 1026 : &blocks_[i][kHandleBlockSize]);
10448 : }
10449 24065 : }
10450 :
10451 :
10452 936 : void InvokeAccessorGetterCallback(
10453 : v8::Local<v8::Name> property,
10454 : const v8::PropertyCallbackInfo<v8::Value>& info,
10455 : v8::AccessorNameGetterCallback getter) {
10456 : // Leaving JavaScript.
10457 : Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
10458 : RuntimeCallTimerScope timer(isolate,
10459 936 : &RuntimeCallStats::AccessorGetterCallback);
10460 : Address getter_address = reinterpret_cast<Address>(reinterpret_cast<intptr_t>(
10461 : getter));
10462 1872 : VMState<EXTERNAL> state(isolate);
10463 1872 : ExternalCallbackScope call_scope(isolate, getter_address);
10464 936 : getter(property, info);
10465 936 : }
10466 :
10467 :
10468 229 : void InvokeFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info,
10469 : v8::FunctionCallback callback) {
10470 : Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
10471 : RuntimeCallTimerScope timer(isolate,
10472 229 : &RuntimeCallStats::InvokeFunctionCallback);
10473 : Address callback_address =
10474 : reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
10475 458 : VMState<EXTERNAL> state(isolate);
10476 458 : ExternalCallbackScope call_scope(isolate, callback_address);
10477 229 : callback(info);
10478 229 : }
10479 :
10480 :
10481 : } // namespace internal
10482 : } // namespace v8
|
