// Copyright 2014 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "src/init/bootstrapper.h" #include "include/v8-function.h" #include "src/api/api-inl.h" #include "src/api/api-natives.h" #include "src/base/hashmap.h" #include "src/base/ieee754.h" #include "src/builtins/accessors.h" #include "src/codegen/compiler.h" #include "src/common/globals.h" #include "src/debug/debug.h" #include "src/execution/isolate-inl.h" #include "src/execution/microtask-queue.h" #include "src/execution/protectors.h" #include "src/extensions/cputracemark-extension.h" #include "src/extensions/externalize-string-extension.h" #include "src/extensions/gc-extension.h" #include "src/extensions/ignition-statistics-extension.h" #include "src/extensions/statistics-extension.h" #include "src/extensions/trigger-failure-extension.h" #include "src/logging/runtime-call-stats-scope.h" #include "src/objects/instance-type.h" #include "src/objects/js-array.h" #include "src/objects/objects.h" #include "src/sandbox/testing.h" #ifdef ENABLE_VTUNE_TRACEMARK #include "src/extensions/vtunedomain-support-extension.h" #endif // ENABLE_VTUNE_TRACEMARK #include "src/heap/heap-inl.h" #include "src/logging/counters.h" #include "src/logging/log.h" #include "src/numbers/math-random.h" #include "src/objects/api-callbacks.h" #include "src/objects/arguments.h" #include "src/objects/function-kind.h" #include "src/objects/hash-table-inl.h" #ifdef V8_INTL_SUPPORT #include "src/objects/intl-objects.h" #endif // V8_INTL_SUPPORT #include "src/objects/js-array-buffer-inl.h" #include "src/objects/js-array-inl.h" #include "src/objects/js-atomics-synchronization.h" #include "src/objects/js-disposable-stack.h" #include "src/objects/js-iterator-helpers.h" #ifdef V8_INTL_SUPPORT #include "src/objects/js-break-iterator.h" #include "src/objects/js-collator.h" #include "src/objects/js-date-time-format.h" #include "src/objects/js-display-names.h" #include "src/objects/js-duration-format.h" #include "src/objects/js-list-format.h" #include "src/objects/js-locale.h" #include "src/objects/js-number-format.h" #include "src/objects/js-plural-rules.h" #endif // V8_INTL_SUPPORT #include "src/objects/js-regexp-string-iterator.h" #include "src/objects/js-regexp.h" #include "src/objects/js-shadow-realm.h" #ifdef V8_INTL_SUPPORT #include "src/objects/js-relative-time-format.h" #include "src/objects/js-segment-iterator.h" #include "src/objects/js-segmenter.h" #include "src/objects/js-segments.h" #endif // V8_INTL_SUPPORT #include "src/codegen/script-details.h" #include "src/objects/js-raw-json.h" #include "src/objects/js-shared-array.h" #include "src/objects/js-struct.h" #include "src/objects/js-temporal-objects-inl.h" #include "src/objects/js-weak-refs.h" #include "src/objects/ordered-hash-table.h" #include "src/objects/property-cell.h" #include "src/objects/property-descriptor.h" #include "src/objects/slots-inl.h" #include "src/objects/swiss-name-dictionary-inl.h" #include "src/objects/templates.h" #include "src/snapshot/snapshot.h" #include "src/zone/zone-hashmap.h" #ifdef V8_FUZZILLI #include "src/fuzzilli/fuzzilli.h" #endif #if V8_ENABLE_WEBASSEMBLY #include "src/wasm/wasm-js.h" #endif // V8_ENABLE_WEBASSEMBLY namespace v8 { namespace internal { void SourceCodeCache::Initialize(Isolate* isolate, bool create_heap_objects) { … } void SourceCodeCache::Iterate(RootVisitor* v) { … } bool SourceCodeCache::Lookup(Isolate* isolate, base::Vector<const char> name, Handle<SharedFunctionInfo>* handle) { … } void SourceCodeCache::Add(Isolate* isolate, base::Vector<const char> name, DirectHandle<SharedFunctionInfo> shared) { … } Bootstrapper::Bootstrapper(Isolate* isolate) : … { … } void Bootstrapper::Initialize(bool create_heap_objects) { … } static const char* GCFunctionName() { … } static bool isValidCpuTraceMarkFunctionName() { … } void Bootstrapper::InitializeOncePerProcess() { … } void Bootstrapper::TearDown() { … } class Genesis { … }; void Bootstrapper::Iterate(RootVisitor* v) { … } Handle<NativeContext> Bootstrapper::CreateEnvironment( MaybeHandle<JSGlobalProxy> maybe_global_proxy, v8::Local<v8::ObjectTemplate> global_proxy_template, v8::ExtensionConfiguration* extensions, size_t context_snapshot_index, DeserializeEmbedderFieldsCallback embedder_fields_deserializer, v8::MicrotaskQueue* microtask_queue) { … } Handle<JSGlobalProxy> Bootstrapper::NewRemoteContext( MaybeHandle<JSGlobalProxy> maybe_global_proxy, v8::Local<v8::ObjectTemplate> global_proxy_template) { … } void Bootstrapper::LogAllMaps() { … } namespace { #ifdef DEBUG bool IsFunctionMapOrSpecialBuiltin(DirectHandle<Map> map, Builtin builtin, DirectHandle<Context> context) { … } #endif // DEBUG Handle<SharedFunctionInfo> CreateSharedFunctionInfoForBuiltin( Isolate* isolate, Handle<String> name, Builtin builtin, int len, bool adapt) { … } constexpr bool kAdapt = …; constexpr bool kDontAdapt = …; V8_NOINLINE Handle<JSFunction> CreateFunctionForBuiltin(Isolate* isolate, Handle<String> name, Handle<Map> map, Builtin builtin, int len, bool adapt) { … } V8_NOINLINE Handle<JSFunction> CreateFunctionForBuiltinWithPrototype( Isolate* isolate, Handle<String> name, Builtin builtin, Handle<HeapObject> prototype, InstanceType type, int instance_size, int inobject_properties, MutableMode prototype_mutability, int len, bool adapt) { … } V8_NOINLINE Handle<JSFunction> CreateFunctionForBuiltinWithoutPrototype( Isolate* isolate, Handle<String> name, Builtin builtin, int len, bool adapt) { … } V8_NOINLINE Handle<JSFunction> CreateFunction( Isolate* isolate, Handle<String> name, InstanceType type, int instance_size, int inobject_properties, Handle<HeapObject> prototype, Builtin builtin, int len, bool adapt) { … } V8_NOINLINE Handle<JSFunction> CreateFunction( Isolate* isolate, const char* name, InstanceType type, int instance_size, int inobject_properties, Handle<HeapObject> prototype, Builtin builtin, int len, bool adapt) { … } V8_NOINLINE Handle<JSFunction> InstallFunction( Isolate* isolate, Handle<JSObject> target, Handle<String> name, InstanceType type, int instance_size, int inobject_properties, Handle<HeapObject> prototype, Builtin call, int len, bool adapt) { … } V8_NOINLINE Handle<JSFunction> InstallFunction( Isolate* isolate, Handle<JSObject> target, const char* name, InstanceType type, int instance_size, int inobject_properties, Handle<HeapObject> prototype, Builtin call, int len, bool adapt) { … } // This sets a constructor instance type on the constructor map which will be // used in IsXxxConstructor() predicates. Having such predicates helps figuring // out if a protector cell should be invalidated. If there are no protector // cell checks required for constructor, this function must not be used. // Note, this function doesn't create a copy of the constructor's map. So it's // better to set constructor instance type after all the properties are added // to the constructor and thus the map is already guaranteed to be unique. V8_NOINLINE void SetConstructorInstanceType( Isolate* isolate, DirectHandle<JSFunction> constructor, InstanceType constructor_type) { … } V8_NOINLINE Handle<JSFunction> SimpleCreateFunction(Isolate* isolate, Handle<String> name, Builtin call, int len, bool adapt) { … } V8_NOINLINE Handle<JSFunction> InstallFunctionWithBuiltinId( Isolate* isolate, Handle<JSObject> base, const char* name, Builtin call, int len, bool adapt) { … } V8_NOINLINE Handle<JSFunction> InstallFunctionAtSymbol( Isolate* isolate, Handle<JSObject> base, Handle<Symbol> symbol, const char* symbol_string, Builtin call, int len, bool adapt, PropertyAttributes attrs = DONT_ENUM) { … } V8_NOINLINE Handle<JSFunction> CreateSharedObjectConstructor( Isolate* isolate, Handle<String> name, DirectHandle<Map> instance_map, Builtin builtin) { … } V8_NOINLINE void SimpleInstallGetterSetter(Isolate* isolate, Handle<JSObject> base, Handle<Name> name, Builtin call_getter, Builtin call_setter) { … } void SimpleInstallGetterSetter(Isolate* isolate, Handle<JSObject> base, const char* name, Builtin call_getter, Builtin call_setter) { … } V8_NOINLINE Handle<JSFunction> SimpleInstallGetter(Isolate* isolate, Handle<JSObject> base, Handle<Name> name, Handle<Name> property_name, Builtin call, bool adapt) { … } V8_NOINLINE Handle<JSFunction> SimpleInstallGetter(Isolate* isolate, Handle<JSObject> base, Handle<Name> name, Builtin call, bool adapt) { … } V8_NOINLINE void InstallConstant(Isolate* isolate, Handle<JSObject> holder, const char* name, DirectHandle<Object> value) { … } V8_NOINLINE void InstallTrueValuedProperty(Isolate* isolate, Handle<JSObject> holder, const char* name) { … } V8_NOINLINE void InstallSpeciesGetter(Isolate* isolate, Handle<JSFunction> constructor) { … } V8_NOINLINE void InstallToStringTag(Isolate* isolate, Handle<JSObject> holder, DirectHandle<String> value) { … } void InstallToStringTag(Isolate* isolate, Handle<JSObject> holder, const char* value) { … } // Create a map for result objects returned from builtins in such a way that // it's exactly the same map as the one produced by object literals. E.g., // iterator result objects have the same map as literals in the form `{value, // done}`. // // This way we have better sharing of maps (i.e. less polymorphism) and also // make it possible to hit the fast-paths in various builtins (i.e. promises and // collections) with user defined iterators. template <size_t N> Handle<Map> CreateLiteralObjectMapFromCache( Isolate* isolate, const std::array<Handle<Name>, N>& properties) { … } } // namespace Handle<JSFunction> Genesis::CreateEmptyFunction() { … } void Genesis::CreateSloppyModeFunctionMaps(Handle<JSFunction> empty) { … } Handle<JSFunction> Genesis::GetThrowTypeErrorIntrinsic() { … } void Genesis::CreateStrictModeFunctionMaps(Handle<JSFunction> empty) { … } void Genesis::CreateObjectFunction(DirectHandle<JSFunction> empty_function) { … } namespace { Handle<Map> CreateNonConstructorMap(Isolate* isolate, Handle<Map> source_map, Handle<JSObject> prototype, const char* reason) { … } } // namespace Handle<JSFunction> SimpleInstallFunction(Isolate* isolate, Handle<JSObject> base, const char* name, Builtin call, int len, bool adapt, PropertyAttributes attrs) { … } void Genesis::CreateIteratorMaps(Handle<JSFunction> empty) { … } void Genesis::CreateAsyncIteratorMaps(Handle<JSFunction> empty) { … } void Genesis::CreateAsyncFunctionMaps(Handle<JSFunction> empty) { … } void Genesis::CreateJSProxyMaps() { … } namespace { void ReplaceAccessors(Isolate* isolate, DirectHandle<Map> map, Handle<String> name, PropertyAttributes attributes, Handle<AccessorPair> accessor_pair) { … } void InitializeJSArrayMaps(Isolate* isolate, DirectHandle<Context> native_context, Handle<Map> initial_map) { … } } // namespace void Genesis::AddRestrictedFunctionProperties(DirectHandle<JSFunction> empty) { … } static void AddToWeakNativeContextList(Isolate* isolate, Tagged<Context> context) { … } void Genesis::CreateRoots() { … } void Genesis::InstallGlobalThisBinding() { … } Handle<JSGlobalObject> Genesis::CreateNewGlobals( v8::Local<v8::ObjectTemplate> global_proxy_template, DirectHandle<JSGlobalProxy> global_proxy) { … } void Genesis::HookUpGlobalProxy(DirectHandle<JSGlobalProxy> global_proxy) { … } void Genesis::HookUpGlobalObject(Handle<JSGlobalObject> global_object) { … } // See https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor for details // about intrinsicDefaultProto concept. In short it's about using proper // prototype object from constructor's realm when the constructor has // non-instance prototype. static void InstallWithIntrinsicDefaultProto(Isolate* isolate, Handle<JSFunction> function, int context_index) { … } static void InstallError(Isolate* isolate, Handle<JSObject> global, Handle<String> name, int context_index, Builtin error_constructor = Builtin::kErrorConstructor, int error_function_length = 1) { … } namespace { Handle<JSObject> InitializeTemporal(Isolate* isolate) { … } void LazyInitializeDateToTemporalInstant( v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … } void LazyInitializeGlobalThisTemporal( v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { … } } // namespace // This is only called if we are not using snapshots. The equivalent // work in the snapshot case is done in HookUpGlobalObject. void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object, Handle<JSFunction> empty_function) { … } Handle<JSFunction> Genesis::InstallTypedArray(const char* name, ElementsKind elements_kind, InstanceType constructor_type, int rab_gsab_initial_map_index) { … } void Genesis::InitializeExperimentalGlobal() { … } namespace { class TryCallScope { … }; } // namespace bool Genesis::CompileExtension(Isolate* isolate, v8::Extension* extension) { … } void Genesis::InitializeIteratorFunctions() { … } void Genesis::InitializeCallSiteBuiltins() { … } void Genesis::InitializeConsole(Handle<JSObject> extras_binding) { … } #define EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE … EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_import_assertions) EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_import_attributes) EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(js_regexp_modifiers) EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(js_regexp_duplicate_named_groups) EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(js_decorators) #ifdef V8_INTL_SUPPORT EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_best_fit_matcher) EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_remove_intl_locale_info_getters) #endif // V8_INTL_SUPPORT #undef EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE void Genesis::InitializeGlobal_harmony_iterator_helpers() { … } void Genesis::InitializeGlobal_js_atomics_pause() { … } void Genesis::InitializeGlobal_js_promise_try() { … } void Genesis::InitializeGlobal_js_promise_withresolvers() { … } void Genesis::InitializeGlobal_harmony_set_methods() { … } void Genesis::InitializeGlobal_harmony_shadow_realm() { … } void Genesis::InitializeGlobal_harmony_struct() { … } void Genesis::InitializeGlobal_sharedarraybuffer() { … } void Genesis::InitializeGlobal_harmony_weak_refs_with_cleanup_some() { … } void Genesis::InitializeGlobal_js_explicit_resource_management() { … } void Genesis::InitializeGlobal_js_float16array() { … } void Genesis::InitializeGlobal_js_source_phase_imports() { … } void Genesis::InitializeGlobal_regexp_linear_flag() { … } void Genesis::InitializeGlobal_harmony_temporal() { … } #ifdef V8_INTL_SUPPORT void Genesis::InitializeGlobal_harmony_intl_locale_info_func() { … } void Genesis::InitializeGlobal_harmony_intl_duration_format() { … } #endif // V8_INTL_SUPPORT Handle<JSFunction> Genesis::CreateArrayBuffer( Handle<String> name, ArrayBufferKind array_buffer_kind) { … } // TODO(jgruber): Refactor this into some kind of meaningful organization. There // is likely no reason remaining for these objects to be installed here. For // example, global object setup done in this function could likely move to // InitializeGlobal. bool Genesis::InstallABunchOfRandomThings() { … } bool Genesis::InstallExtrasBindings() { … } void Genesis::InitializeMapCaches() { … } bool Bootstrapper::InstallExtensions(Handle<NativeContext> native_context, v8::ExtensionConfiguration* extensions) { … } bool Genesis::InstallSpecialObjects( Isolate* isolate, DirectHandle<NativeContext> native_context) { … } static uint32_t Hash(RegisteredExtension* extension) { … } Genesis::ExtensionStates::ExtensionStates() : … { … } Genesis::ExtensionTraversalState Genesis::ExtensionStates::get_state( RegisteredExtension* extension) { … } void Genesis::ExtensionStates::set_state(RegisteredExtension* extension, ExtensionTraversalState state) { … } bool Genesis::InstallExtensions(Isolate* isolate, DirectHandle<Context> native_context, v8::ExtensionConfiguration* extensions) { … } bool Genesis::InstallAutoExtensions(Isolate* isolate, ExtensionStates* extension_states) { … } bool Genesis::InstallRequestedExtensions(Isolate* isolate, v8::ExtensionConfiguration* extensions, ExtensionStates* extension_states) { … } // Installs a named extension. This methods is unoptimized and does // not scale well if we want to support a large number of extensions. bool Genesis::InstallExtension(Isolate* isolate, const char* name, ExtensionStates* extension_states) { … } bool Genesis::InstallExtension(Isolate* isolate, v8::RegisteredExtension* current, ExtensionStates* extension_states) { … } bool Genesis::ConfigureGlobalObject( v8::Local<v8::ObjectTemplate> global_proxy_template) { … } bool Genesis::ConfigureApiObject(Handle<JSObject> object, Handle<ObjectTemplateInfo> object_template) { … } static bool PropertyAlreadyExists(Isolate* isolate, Handle<JSObject> to, Handle<Name> key) { … } void Genesis::TransferNamedProperties(DirectHandle<JSObject> from, Handle<JSObject> to) { … } void Genesis::TransferIndexedProperties(DirectHandle<JSObject> from, DirectHandle<JSObject> to) { … } void Genesis::TransferObject(DirectHandle<JSObject> from, Handle<JSObject> to) { … } Handle<Map> Genesis::CreateInitialMapForArraySubclass(int size, int inobject_properties) { … } Genesis::Genesis(Isolate* isolate, MaybeHandle<JSGlobalProxy> maybe_global_proxy, v8::Local<v8::ObjectTemplate> global_proxy_template, size_t context_snapshot_index, DeserializeEmbedderFieldsCallback embedder_fields_deserializer, v8::MicrotaskQueue* microtask_queue) : … { … } Genesis::Genesis(Isolate* isolate, MaybeHandle<JSGlobalProxy> maybe_global_proxy, v8::Local<v8::ObjectTemplate> global_proxy_template) : … { … } // Support for thread preemption. // Reserve space for statics needing saving and restoring. int Bootstrapper::ArchiveSpacePerThread() { … } // Archive statics that are thread-local. char* Bootstrapper::ArchiveState(char* to) { … } // Restore statics that are thread-local. char* Bootstrapper::RestoreState(char* from) { … } // Called when the top-level V8 mutex is destroyed. void Bootstrapper::FreeThreadResources() { … } } // namespace internal } // namespace v8
Codebase Browser
chromium