Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-10-13 08:01
📄 common.gypi { 'variables': { 'configuring_node%': 0, 'asan%': 0, 'ubsan%': 0, 'visibility%': 'hidden', # V8's visibility setting 'target_arch%': 'ia32', # set v8's target architecture 'host_arch%': 'ia32', # set v8's host architecture 'want_separate_host_toolset%': 0, # V8 should not build target and host 'library%': 'static_library', # allow override to 'shared_library' for DLL/.so builds 'component%': 'static_library', # NB. these names match with what V8 expects 'msvs_multi_core_compile': '0', # we do enable multicore compiles, but not using the V8 way 'enable_pgo_generate%': '0', 'enable_pgo_use%': '0', 'python%': 'python', 'node_shared%': 'false', 'force_dynamic_crt%': 0, 'node_use_v8_platform%': 'true', 'node_use_bundled_v8%': 'true', 'node_module_version%': '', 'node_with_ltcg%': '', 'node_shared_openssl%': 'false', 'node_tag%': '', 'uv_library%': 'static_library', 'clang%': 0, 'error_on_warn%': 'false', 'openssl_product': '<(STATIC_LIB_PREFIX)openssl<(STATIC_LIB_SUFFIX)', 'openssl_no_asm%': 0, # Don't use ICU data file (icudtl.dat) from V8, we use our own. 'icu_use_data_file_flag%': 0, # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. 'v8_embedder_string': '-node.22', ##### V8 defaults for Node.js ##### # Turn on SipHash for hash seed generation, addresses HashWick 'v8_use_siphash': 'true', # These are more relevant for V8 internal development. # Refs: https://github.com/nodejs/node/issues/23122 # Refs: https://github.com/nodejs/node/issues/23167 # Enable compiler warnings when using V8_DEPRECATED apis from V8 code. 'v8_deprecation_warnings': 0, # Enable compiler warnings when using V8_DEPRECATE_SOON apis from V8 code. 'v8_imminent_deprecation_warnings': 0, # Enable disassembler for `--print-code` v8 options 'v8_enable_disassembler': 1, # Sets -dOBJECT_PRINT. 'v8_enable_object_print%': 1, # https://github.com/nodejs/node/pull/22920/files#r222779926 'v8_enable_handle_zapping': 0, # Disable pointer compression. Can be enabled at build time via configure # options but default values are required here as this file is also used by # node-gyp to build addons. 'v8_enable_pointer_compression%': 0, 'v8_enable_31bit_smis_on_64bit_arch%': 0, # Disable v8 hugepage by default. 'v8_enable_hugepage%': 0, # This is more of a V8 dev setting # https://github.com/nodejs/node/pull/22920/files#r222779926 'v8_enable_fast_mksnapshot': 0, 'v8_win64_unwinding_info': 1, # Variables controlling external defines exposed in public headers. 'v8_enable_conservative_stack_scanning%': 0, 'v8_enable_direct_local%': 0, 'v8_enable_map_packing%': 0, 'v8_enable_pointer_compression_shared_cage%': 0, 'v8_enable_sandbox%': 0, 'v8_enable_v8_checks%': 0, 'v8_enable_zone_compression%': 0, 'v8_use_perfetto': 0, 'tsan%': 0, ##### end V8 defaults ##### 'conditions': [ ['OS == "win"', { 'os_posix': 0, 'v8_postmortem_support%': 0, 'obj_dir': '<(PRODUCT_DIR)/obj', 'v8_base': '<(PRODUCT_DIR)/lib/libv8_snapshot.a', }, { 'os_posix': 1, 'v8_postmortem_support%': 1, }], ['GENERATOR == "ninja"', { 'obj_dir': '<(PRODUCT_DIR)/obj', 'v8_base': '<(PRODUCT_DIR)/obj/tools/v8_gypfiles/libv8_snapshot.a', }, { 'obj_dir%': '<(PRODUCT_DIR)/obj.target', 'v8_base': '<(PRODUCT_DIR)/obj.target/tools/v8_gypfiles/libv8_snapshot.a', }], ['OS=="mac"', { 'obj_dir%': '<(PRODUCT_DIR)/obj.target', 'v8_base': '<(PRODUCT_DIR)/libv8_snapshot.a', }], # V8 pointer compression only supports 64bit architectures. ['target_arch in "arm ia32 mips mipsel ppc"', { 'v8_enable_pointer_compression': 0, 'v8_enable_31bit_smis_on_64bit_arch': 0, 'v8_enable_sandbox': 0 }], ['target_arch in "ppc64 s390x"', { 'v8_enable_backtrace': 1, }], ['OS=="linux"', { 'node_section_ordering_info%': '' }], ['OS == "zos"', { # use ICU data file on z/OS 'icu_use_data_file_flag%': 1 }] ], }, 'target_defaults': { 'default_configuration': 'Release', 'configurations': { 'Debug': { 'variables': { 'v8_enable_handle_zapping': 1, 'conditions': [ ['node_shared != "true"', { 'MSVC_runtimeType': 1, # MultiThreadedDebug (/MTd) }, { 'MSVC_runtimeType': 3, # MultiThreadedDebugDLL (/MDd) }], ], }, 'defines': [ 'DEBUG', '_DEBUG' ], 'cflags': [ '-g', '-O0' ], 'conditions': [ ['OS in "aix os400"', { 'cflags': [ '-gxcoff' ], 'ldflags': [ '-Wl,-bbigtoc' ], }], ['OS == "android"', { 'cflags': [ '-fPIC' ], 'ldflags': [ '-fPIC' ] }], ['clang==1', { 'msbuild_toolset': 'ClangCL', }], ], 'msvs_settings': { 'VCCLCompilerTool': { 'BasicRuntimeChecks': 3, # /RTC1 'MinimalRebuild': 'false', 'OmitFramePointers': 'false', 'Optimization': 0, # /Od, no optimization 'RuntimeLibrary': '<(MSVC_runtimeType)', }, 'VCLinkerTool': { 'LinkIncremental': 2, # enable incremental linking }, }, 'xcode_settings': { 'GCC_OPTIMIZATION_LEVEL': '0', # stop gyp from defaulting to -Os }, }, 'Release': { 'variables': { 'v8_enable_handle_zapping': 0, 'pgo_generate': ' -fprofile-generate ', 'pgo_use': ' -fprofile-use -fprofile-correction ', 'conditions': [ ['node_shared != "true"', { 'MSVC_runtimeType': 0 # MultiThreaded (/MT) }, { 'MSVC_runtimeType': 2 # MultiThreadedDLL (/MD) }], ['clang==1', { 'lto': ' -flto ', # Clang }, { 'lto': ' -flto=4 -fuse-linker-plugin -ffat-lto-objects ', # GCC }], ], }, 'cflags': [ '-O3' ], 'conditions': [ ['enable_lto=="true"', { 'cflags': ['<(lto)'], 'ldflags': ['<(lto)'], 'xcode_settings': { 'LLVM_LTO': 'YES', }, }], ['OS=="linux"', { 'conditions': [ ['node_section_ordering_info!=""', { 'cflags': [ '-fuse-ld=gold', '-ffunction-sections', ], 'ldflags': [ '-fuse-ld=gold', '-Wl,--section-ordering-file=<(node_section_ordering_info)', ], }], ], }], ['OS=="solaris"', { # pull in V8's postmortem metadata 'ldflags': [ '-Wl,-z,allextract' ] }], ['OS=="zos"', { # increase performance, number from experimentation 'cflags': [ '-qINLINE=::150:100000' ] }], ['OS!="mac" and OS!="win" and OS!="zos"', { # -fno-omit-frame-pointer is necessary for the --perf_basic_prof # flag to work correctly. perf(1) gets confused about JS stack # frames otherwise, even with --call-graph dwarf. 'cflags': [ '-fno-omit-frame-pointer' ], }], ['OS=="linux"', { 'conditions': [ ['enable_pgo_generate=="true"', { 'cflags': ['<(pgo_generate)'], 'ldflags': ['<(pgo_generate)'], },], ['enable_pgo_use=="true"', { 'cflags': ['<(pgo_use)'], 'ldflags': ['<(pgo_use)'], },], ], },], ['OS == "android"', { 'cflags': [ '-fPIC', '-I<(android_ndk_path)/sources/android/cpufeatures' ], 'ldflags': [ '-fPIC' ] }], ['clang==1', { 'msbuild_toolset': 'ClangCL', }], ], 'msvs_settings': { 'VCCLCompilerTool': { 'conditions': [ ['target_arch=="arm64"', { 'FloatingPointModel': 1 # /fp:strict }] ], 'EnableFunctionLevelLinking': 'true', 'EnableIntrinsicFunctions': 'true', 'FavorSizeOrSpeed': 1, # /Ot, favor speed over size 'InlineFunctionExpansion': 2, # /Ob2, inline anything eligible 'OmitFramePointers': 'true', 'Optimization': 3, # /Ox, full optimization 'RuntimeLibrary': '<(MSVC_runtimeType)', 'RuntimeTypeInfo': 'false', } }, 'xcode_settings': { 'GCC_OPTIMIZATION_LEVEL': '3', # stop gyp from defaulting to -Os }, } }, # Defines these mostly for node-gyp to pickup. 'defines': [ '_GLIBCXX_USE_CXX11_ABI=1', ], # Forcibly disable -Werror. We support a wide range of compilers, it's # simply not feasible to squelch all warnings, never mind that the # libraries in deps/ are not under our control. 'conditions': [ [ 'error_on_warn=="false"', { 'cflags!': ['-Werror'], }, '(_target_name!="<(node_lib_target_name)" or ' '_target_name!="<(node_core_target_name)")', { 'cflags!': ['-Werror'], }], ], 'msvs_settings': { 'VCCLCompilerTool': { # TODO(targos): Remove condition and always use LanguageStandard options # once node-gyp supports them. 'conditions': [ ['clang==1', { 'LanguageStandard': 'stdcpp20', 'LanguageStandard_C': 'stdc11', 'AdditionalOptions': [ '/Zc:__cplusplus', # The following option reduces the "error C1060: compiler is out of heap space" '/Zm2000', ], }, { 'AdditionalOptions': [ '/Zc:__cplusplus', # The following option enables c++20 on Windows. This is needed for V8 v12.4+ '-std:c++20', # The following option reduces the "error C1060: compiler is out of heap space" '/Zm2000', ], }], ], 'BufferSecurityCheck': 'true', 'DebugInformationFormat': 1, # /Z7 embed info in .obj files 'ExceptionHandling': 0, # /EHsc 'MultiProcessorCompilation': 'true', 'StringPooling': 'true', # pool string literals 'SuppressStartupBanner': 'true', 'WarnAsError': 'false', 'WarningLevel': 3, # /W3 }, 'VCLinkerTool': { 'target_conditions': [ ['_type=="executable"', { 'SubSystem': 1, # /SUBSYSTEM:CONSOLE }], ], 'conditions': [ ['target_arch=="ia32"', { 'TargetMachine' : 1, # /MACHINE:X86 }], ['target_arch=="x64"', { 'TargetMachine' : 17, # /MACHINE:X64 }], ['target_arch=="arm64"', { 'TargetMachine' : 0, # NotSet. MACHINE:ARM64 is inferred from the input files. }], ], 'GenerateDebugInformation': 'true', 'SuppressStartupBanner': 'true', }, }, # Disable warnings: # - "C4251: class needs to have dll-interface" # - "C4275: non-DLL-interface used as base for DLL-interface" # Over 10k of these warnings are generated when compiling node, # originating from v8.h. Most of them are false positives. # See also: https://github.com/nodejs/node/pull/15570 # TODO: re-enable when Visual Studio fixes these upstream. # # - "C4267: conversion from 'size_t' to 'int'" # Many any originate from our dependencies, and their sheer number # drowns out other, more legitimate warnings. # - "C4244: conversion from 'type1' to 'type2', possible loss of data" # Ususaly safe. Disable for `dep`, enable for `src` 'msvs_disabled_warnings': [4351, 4355, 4800, 4251, 4275, 4244, 4267], 'msvs_cygwin_shell': 0, # prevent actions from trying to use cygwin 'conditions': [ [ 'configuring_node', { 'msvs_configuration_attributes': { 'OutputDirectory': '<(DEPTH)/out/$(Configuration)/', 'IntermediateDirectory': '$(OutDir)obj/$(ProjectName)/' }, }], [ 'target_arch=="x64"', { 'msvs_configuration_platform': 'x64', }], [ 'target_arch=="arm64"', { 'msvs_configuration_platform': 'arm64', }], ['asan == 1 and OS != "mac" and OS != "zos"', { 'cflags+': [ '-fno-omit-frame-pointer', '-fsanitize=address', '-fsanitize-address-use-after-scope', ], 'defines': [ 'LEAK_SANITIZER', 'V8_USE_ADDRESS_SANITIZER' ], 'cflags!': [ '-fomit-frame-pointer' ], 'ldflags': [ '-fsanitize=address' ], }], ['asan == 1 and OS == "mac"', { 'xcode_settings': { 'OTHER_CFLAGS+': [ '-fno-omit-frame-pointer', '-gline-tables-only', '-fsanitize=address', '-DLEAK_SANITIZER' ], 'OTHER_CFLAGS!': [ '-fomit-frame-pointer', ], }, 'target_conditions': [ ['_type!="static_library"', { 'xcode_settings': {'OTHER_LDFLAGS': ['-fsanitize=address']}, }], ], }], ['ubsan == 1 and OS != "mac" and OS != "zos"', { 'cflags+': [ '-fno-omit-frame-pointer', '-fsanitize=undefined', ], 'defines': [ 'UNDEFINED_SANITIZER'], 'cflags!': [ '-fno-omit-frame-pointer' ], 'ldflags': [ '-fsanitize=undefined' ], }], ['ubsan == 1 and OS == "mac"', { 'xcode_settings': { 'OTHER_CFLAGS+': [ '-fno-omit-frame-pointer', '-fsanitize=undefined', '-DUNDEFINED_SANITIZER' ], }, 'target_conditions': [ ['_type!="static_library"', { 'xcode_settings': {'OTHER_LDFLAGS': ['-fsanitize=undefined']}, }], ], }], # The defines bellow must include all things from the external_v8_defines # list in v8/BUILD.gn. ['v8_enable_v8_checks == 1', { 'defines': ['V8_ENABLE_CHECKS'], }], ['v8_enable_pointer_compression == 1', { 'defines': ['V8_COMPRESS_POINTERS'], }], ['v8_enable_pointer_compression_shared_cage == 1', { 'defines': ['V8_COMPRESS_POINTERS_IN_SHARED_CAGE'], }], ['v8_enable_pointer_compression == 1 and v8_enable_pointer_compression_shared_cage != 1', { 'defines': ['V8_COMPRESS_POINTERS_IN_ISOLATE_CAGE'], }], ['v8_enable_pointer_compression == 1 or v8_enable_31bit_smis_on_64bit_arch == 1', { 'defines': ['V8_31BIT_SMIS_ON_64BIT_ARCH'], }], ['v8_enable_zone_compression == 1', { 'defines': ['V8_COMPRESS_ZONES',], }], ['v8_enable_sandbox == 1', { 'defines': ['V8_ENABLE_SANDBOX',], }], ['v8_deprecation_warnings == 1', { 'defines': ['V8_DEPRECATION_WARNINGS',], }], ['v8_imminent_deprecation_warnings == 1', { 'defines': ['V8_IMMINENT_DEPRECATION_WARNINGS',], }], ['v8_use_perfetto == 1', { 'defines': ['V8_USE_PERFETTO',], }], ['v8_enable_map_packing == 1', { 'defines': ['V8_MAP_PACKING',], }], ['tsan == 1', { 'defines': ['V8_IS_TSAN',], }], ['v8_enable_conservative_stack_scanning == 1', { 'defines': ['V8_ENABLE_CONSERVATIVE_STACK_SCANNING',], }], ['v8_enable_direct_local == 1', { 'defines': ['V8_ENABLE_DIRECT_LOCAL',], }], ['OS == "win"', { 'defines': [ 'WIN32', # we don't really want VC++ warning us about # how dangerous C functions are... '_CRT_SECURE_NO_DEPRECATE', # ... or that C implementations shouldn't use # POSIX names '_CRT_NONSTDC_NO_DEPRECATE', # Make sure the STL doesn't try to use exceptions '_HAS_EXCEPTIONS=0', 'BUILDING_V8_SHARED=1', 'BUILDING_UV_SHARED=1', # Stop <windows.h> from defining macros that conflict with # std::min() and std::max(). We don't use <windows.h> (much) # but we still inherit it from uv.h. 'NOMINMAX', ], }], [ 'OS in "linux freebsd openbsd solaris aix os400"', { 'cflags': [ '-pthread' ], 'ldflags': [ '-pthread' ], }], [ 'OS in "linux freebsd openbsd solaris android aix os400 cloudabi"', { 'cflags': [ '-Wall', '-Wextra', '-Wno-unused-parameter', ], 'cflags_cc': [ '-fno-rtti', '-fno-exceptions', '-fno-strict-aliasing', '-std=gnu++17', ], 'defines': [ '__STDC_FORMAT_MACROS' ], 'ldflags': [ '-rdynamic' ], 'target_conditions': [ # The 1990s toolchain on SmartOS can't handle thin archives. ['_type=="static_library" and OS=="solaris"', { 'standalone_static_library': 1, }], ['OS=="openbsd"', { 'cflags': [ '-I/usr/local/include' ], 'ldflags': [ '-Wl,-z,wxneeded' ], }], ['_toolset=="host"', { 'conditions': [ [ 'host_arch=="ia32"', { 'cflags': [ '-m32' ], 'ldflags': [ '-m32' ], }], [ 'host_arch=="x64"', { 'cflags': [ '-m64' ], 'ldflags': [ '-m64' ], }], [ 'host_arch=="ppc" and OS not in "aix os400"', { 'cflags': [ '-m32' ], 'ldflags': [ '-m32' ], }], [ 'host_arch=="ppc64" and OS not in "aix os400"', { 'cflags': [ '-m64', '-mminimal-toc' ], 'ldflags': [ '-m64' ], }], [ 'host_arch=="s390x" and OS=="linux"', { 'cflags': [ '-m64', '-march=z196' ], 'ldflags': [ '-m64', '-march=z196' ], }], ], }], ['_toolset=="target"', { 'conditions': [ [ 'target_arch=="ia32"', { 'cflags': [ '-m32' ], 'ldflags': [ '-m32' ], }], [ 'target_arch=="x64"', { 'cflags': [ '-m64' ], 'ldflags': [ '-m64' ], }], [ 'target_arch=="ppc" and OS not in "aix os400"', { 'cflags': [ '-m32' ], 'ldflags': [ '-m32' ], }], [ 'target_arch=="ppc64" and OS not in "aix os400"', { 'cflags': [ '-m64', '-mminimal-toc' ], 'ldflags': [ '-m64' ], }], [ 'target_arch=="s390x" and OS=="linux"', { 'cflags': [ '-m64', '-march=z196' ], 'ldflags': [ '-m64', '-march=z196' ], }], ], }], ], 'conditions': [ [ 'OS=="solaris"', { 'cflags': [ '-pthreads' ], 'ldflags': [ '-pthreads' ], 'cflags!': [ '-pthread' ], 'ldflags!': [ '-pthread' ], }], [ 'node_shared=="true"', { 'cflags': [ '-fPIC' ], }], ], }], [ 'OS in "aix os400"', { 'variables': { # Used to differentiate `AIX` and `OS400`(IBM i). 'aix_variant_name': '<!(uname -s)', }, 'cflags': [ '-maix64', ], 'ldflags!': [ '-rdynamic', ], 'ldflags': [ '-Wl,-bbigtoc', '-maix64', ], 'conditions': [ [ '"<(aix_variant_name)"=="OS400"', { # a.k.a. `IBM i` 'ldflags': [ '-Wl,-blibpath:/QOpenSys/pkgs/lib:/QOpenSys/usr/lib', '-Wl,-brtl', ], }, { # else it's `AIX` 'variables': { 'gcc_major': '<!(<(python) -c "import os; import subprocess; CXX=os.environ.get(\'CXX\', \'g++\'); subprocess.run([CXX, \'-dumpversion\'])")' }, # Disable the following compiler warning: # # warning: visibility attribute not supported in this # configuration; ignored [-Wattributes] # # This is gcc complaining about __attribute((visibility("default")) # in static library builds. Legitimate but harmless and it drowns # out more relevant warnings. 'cflags': [ '-Wno-attributes' ], 'ldflags': [ '-Wl,-blibpath:/usr/lib:/lib:/opt/freeware/lib/gcc/powerpc-ibm-aix7.3.0.0/>(gcc_major)/pthread/ppc64:/opt/freeware/lib/gcc/powerpc-ibm-aix7.2.0.0/>(gcc_major)/pthread/ppc64:/opt/freeware/lib/pthread/ppc64', ], }], ], }], ['OS=="android"', { 'target_conditions': [ ['_toolset=="target"', { 'defines': [ '_GLIBCXX_USE_C99_MATH' ], 'libraries': [ '-llog' ], }], ['_toolset=="host"', { 'cflags': [ '-pthread' ], 'ldflags': [ '-pthread' ], }], ], }], ['OS=="mac"', { 'defines': ['_DARWIN_USE_64_BIT_INODE=1'], 'xcode_settings': { 'ALWAYS_SEARCH_USER_PATHS': 'NO', 'GCC_CW_ASM_SYNTAX': 'NO', # No -fasm-blocks 'GCC_DYNAMIC_NO_PIC': 'NO', # No -mdynamic-no-pic # (Equivalent to -fPIC) 'GCC_ENABLE_CPP_EXCEPTIONS': 'NO', # -fno-exceptions 'GCC_ENABLE_CPP_RTTI': 'NO', # -fno-rtti 'GCC_ENABLE_PASCAL_STRINGS': 'NO', # No -mpascal-strings 'GCC_STRICT_ALIASING': 'NO', # -fno-strict-aliasing 'PREBINDING': 'NO', # No -Wl,-prebind 'MACOSX_DEPLOYMENT_TARGET': '11.0', # -mmacosx-version-min=11.0 'USE_HEADERMAP': 'NO', 'WARNING_CFLAGS': [ '-Wall', '-Wendif-labels', '-W', '-Wno-unused-parameter', ], }, 'target_conditions': [ ['_type!="static_library"', { 'xcode_settings': { 'OTHER_LDFLAGS': [ '-Wl,-search_paths_first' ], }, }], ], 'conditions': [ ['target_arch=="ia32"', { 'xcode_settings': {'ARCHS': ['i386']}, }], ['target_arch=="x64"', { 'xcode_settings': {'ARCHS': ['x86_64']}, }], ['target_arch=="arm64"', { 'xcode_settings': { 'ARCHS': ['arm64'], 'OTHER_LDFLAGS!': [ '-Wl,-no_pie', ], }, }], ['clang==1', { 'xcode_settings': { 'GCC_VERSION': 'com.apple.compilers.llvm.clang.1_0', 'CLANG_CXX_LANGUAGE_STANDARD': 'gnu++17', # -std=gnu++17 'CLANG_CXX_LIBRARY': 'libc++', }, }], ], }], ['OS=="freebsd"', { 'ldflags': [ '-Wl,--export-dynamic', ], }], # if node is built as an executable, # the openssl mechanism for keeping itself "dload"-ed to ensure proper # atexit cleanup does not apply ['node_shared_openssl!="true" and node_shared!="true"', { 'defines': [ # `OPENSSL_NO_PINSHARED` prevents openssl from dload # current node executable, # see https://github.com/nodejs/node/pull/21848 # or https://github.com/nodejs/node/issues/27925 'OPENSSL_NO_PINSHARED' ], }], ['node_shared_openssl!="true"', { # `OPENSSL_THREADS` is defined via GYP for openSSL for all architectures. 'defines': [ 'OPENSSL_THREADS', ], }], ['node_shared_openssl!="true" and openssl_no_asm==1', { 'defines': [ 'OPENSSL_NO_ASM', ], }], ['OS == "zos"', { 'defines': [ '_XOPEN_SOURCE_EXTENDED', '_XOPEN_SOURCE=600', '_UNIX03_THREADS', '_UNIX03_WITHDRAWN', '_UNIX03_SOURCE', '_OPEN_SYS_SOCK_IPV6', '_OPEN_SYS_FILE_EXT=1', '_POSIX_SOURCE', '_OPEN_SYS', '_OPEN_SYS_IF_EXT', '_OPEN_SYS_SOCK_IPV6', '_OPEN_MSGQ_EXT', '_LARGE_TIME_API', '_ALL_SOURCE', '_AE_BIMODAL=1', '__IBMCPP_TR1__', 'NODE_PLATFORM="os390"', 'PATH_MAX=1024', '_ENHANCED_ASCII_EXT=0xFFFFFFFF', '_Export=extern', '__static_assert=static_assert', ], 'cflags': [ '-q64', '-Wc,DLL', '-Wa,GOFF', '-qARCH=10', '-qASCII', '-qTUNE=12', '-qENUM=INT', '-qEXPORTALL', '-qASM', ], 'cflags_cc': [ '-qxclang=-std=c++14', ], 'ldflags': [ '-q64', ], # for addons due to v8config.h include of "zos-base.h": 'include_dirs': ['<(zoslib_include_dir)'], }], ], } }	25.42 KB	2025-03-03 12:37
📄 config.gypi # Do not edit. Generated by the configure script. { 'target_defaults': { 'cflags': [], 'configurations': { 'Debug': {'v8_enable_v8_checks': 0, 'variables': {}}, 'Release': {'v8_enable_v8_checks': 1, 'variables': {}}}, 'default_configuration': 'Release', 'defines': [ 'NODE_OPENSSL_CONF_NAME=nodejs_conf', 'NODE_OPENSSL_CERT_STORE', 'ICU_NO_USER_DATA_OVERRIDE'], 'include_dirs': [], 'libraries': ['-lz', '-lcrypto', '-lssl']}, 'variables': { 'asan': 0, 'clang': 1, 'coverage': 'false', 'dcheck_always_on': 0, 'debug_nghttp2': 'false', 'debug_node': 'false', 'enable_lto': 'false', 'enable_pgo_generate': 'false', 'enable_pgo_use': 'false', 'error_on_warn': 'false', 'force_dynamic_crt': 1, 'host_arch': 'x64', 'icu_data_in': '../../deps/icu-tmp/icudt76l.dat', 'icu_endianness': 'l', 'icu_gyp_path': 'tools/icu/icu-generic.gyp', 'icu_path': 'deps/icu-small', 'icu_small': 'false', 'icu_ver_major': '76', 'libdir': 'lib', 'llvm_version': '18.1', 'napi_build_version': '10', 'node_builtin_shareable_builtins': [ 'deps/cjs-module-lexer/lexer.js', 'deps/cjs-module-lexer/dist/lexer.js', 'deps/undici/undici.js', 'deps/amaro/dist/index.js'], 'node_byteorder': 'little', 'node_debug_lib': 'false', 'node_enable_d8': 'false', 'node_enable_v8_vtunejit': 'false', 'node_fipsinstall': 'false', 'node_install_corepack': 'true', 'node_install_npm': 'true', 'node_library_files': [ 'lib/_http_agent.js', 'lib/_http_client.js', 'lib/_http_common.js', 'lib/_http_incoming.js', 'lib/_http_outgoing.js', 'lib/_http_server.js', 'lib/_stream_duplex.js', 'lib/_stream_passthrough.js', 'lib/_stream_readable.js', 'lib/_stream_transform.js', 'lib/_stream_wrap.js', 'lib/_stream_writable.js', 'lib/_tls_common.js', 'lib/_tls_wrap.js', 'lib/assert.js', 'lib/assert/strict.js', 'lib/async_hooks.js', 'lib/buffer.js', 'lib/child_process.js', 'lib/cluster.js', 'lib/console.js', 'lib/constants.js', 'lib/crypto.js', 'lib/dgram.js', 'lib/diagnostics_channel.js', 'lib/dns.js', 'lib/dns/promises.js', 'lib/domain.js', 'lib/events.js', 'lib/fs.js', 'lib/fs/promises.js', 'lib/http.js', 'lib/http2.js', 'lib/https.js', 'lib/inspector.js', 'lib/inspector/promises.js', 'lib/internal/abort_controller.js', 'lib/internal/assert.js', 'lib/internal/assert/assertion_error.js', 'lib/internal/assert/calltracker.js', 'lib/internal/assert/myers_diff.js', 'lib/internal/assert/utils.js', 'lib/internal/async_context_frame.js', 'lib/internal/async_hooks.js', 'lib/internal/async_local_storage/async_context_frame.js', 'lib/internal/async_local_storage/async_hooks.js', 'lib/internal/blob.js', 'lib/internal/blocklist.js', 'lib/internal/bootstrap/node.js', 'lib/internal/bootstrap/realm.js', 'lib/internal/bootstrap/shadow_realm.js', 'lib/internal/bootstrap/switches/does_not_own_process_state.js', 'lib/internal/bootstrap/switches/does_own_process_state.js', 'lib/internal/bootstrap/switches/is_main_thread.js', 'lib/internal/bootstrap/switches/is_not_main_thread.js', 'lib/internal/bootstrap/web/exposed-wildcard.js', 'lib/internal/bootstrap/web/exposed-window-or-worker.js', 'lib/internal/buffer.js', 'lib/internal/child_process.js', 'lib/internal/child_process/serialization.js', 'lib/internal/cli_table.js', 'lib/internal/cluster/child.js', 'lib/internal/cluster/primary.js', 'lib/internal/cluster/round_robin_handle.js', 'lib/internal/cluster/shared_handle.js', 'lib/internal/cluster/utils.js', 'lib/internal/cluster/worker.js', 'lib/internal/console/constructor.js', 'lib/internal/console/global.js', 'lib/internal/constants.js', 'lib/internal/crypto/aes.js', 'lib/internal/crypto/certificate.js', 'lib/internal/crypto/cfrg.js', 'lib/internal/crypto/cipher.js', 'lib/internal/crypto/diffiehellman.js', 'lib/internal/crypto/ec.js', 'lib/internal/crypto/hash.js', 'lib/internal/crypto/hashnames.js', 'lib/internal/crypto/hkdf.js', 'lib/internal/crypto/keygen.js', 'lib/internal/crypto/keys.js', 'lib/internal/crypto/mac.js', 'lib/internal/crypto/pbkdf2.js', 'lib/internal/crypto/random.js', 'lib/internal/crypto/rsa.js', 'lib/internal/crypto/scrypt.js', 'lib/internal/crypto/sig.js', 'lib/internal/crypto/util.js', 'lib/internal/crypto/webcrypto.js', 'lib/internal/crypto/webidl.js', 'lib/internal/crypto/x509.js', 'lib/internal/data_url.js', 'lib/internal/debugger/inspect.js', 'lib/internal/debugger/inspect_client.js', 'lib/internal/debugger/inspect_repl.js', 'lib/internal/dgram.js', 'lib/internal/dns/callback_resolver.js', 'lib/internal/dns/promises.js', 'lib/internal/dns/utils.js', 'lib/internal/encoding.js', 'lib/internal/error_serdes.js', 'lib/internal/errors.js', 'lib/internal/event_target.js', 'lib/internal/events/abort_listener.js', 'lib/internal/events/symbols.js', 'lib/internal/file.js', 'lib/internal/fixed_queue.js', 'lib/internal/freelist.js', 'lib/internal/freeze_intrinsics.js', 'lib/internal/fs/cp/cp-sync.js', 'lib/internal/fs/cp/cp.js', 'lib/internal/fs/dir.js', 'lib/internal/fs/glob.js', 'lib/internal/fs/promises.js', 'lib/internal/fs/read/context.js', 'lib/internal/fs/recursive_watch.js', 'lib/internal/fs/rimraf.js', 'lib/internal/fs/streams.js', 'lib/internal/fs/sync_write_stream.js', 'lib/internal/fs/utils.js', 'lib/internal/fs/watchers.js', 'lib/internal/heap_utils.js', 'lib/internal/histogram.js', 'lib/internal/http.js', 'lib/internal/http2/compat.js', 'lib/internal/http2/core.js', 'lib/internal/http2/util.js', 'lib/internal/inspector/network.js', 'lib/internal/inspector/network_http.js', 'lib/internal/inspector/network_undici.js', 'lib/internal/inspector_async_hook.js', 'lib/internal/inspector_network_tracking.js', 'lib/internal/js_stream_socket.js', 'lib/internal/legacy/processbinding.js', 'lib/internal/linkedlist.js', 'lib/internal/main/check_syntax.js', 'lib/internal/main/embedding.js', 'lib/internal/main/eval_stdin.js', 'lib/internal/main/eval_string.js', 'lib/internal/main/inspect.js', 'lib/internal/main/mksnapshot.js', 'lib/internal/main/print_help.js', 'lib/internal/main/prof_process.js', 'lib/internal/main/repl.js', 'lib/internal/main/run_main_module.js', 'lib/internal/main/test_runner.js', 'lib/internal/main/watch_mode.js', 'lib/internal/main/worker_thread.js', 'lib/internal/mime.js', 'lib/internal/modules/cjs/loader.js', 'lib/internal/modules/esm/assert.js', 'lib/internal/modules/esm/create_dynamic_module.js', 'lib/internal/modules/esm/fetch_module.js', 'lib/internal/modules/esm/formats.js', 'lib/internal/modules/esm/get_format.js', 'lib/internal/modules/esm/hooks.js', 'lib/internal/modules/esm/initialize_import_meta.js', 'lib/internal/modules/esm/load.js', 'lib/internal/modules/esm/loader.js', 'lib/internal/modules/esm/module_job.js', 'lib/internal/modules/esm/module_map.js', 'lib/internal/modules/esm/resolve.js', 'lib/internal/modules/esm/shared_constants.js', 'lib/internal/modules/esm/translators.js', 'lib/internal/modules/esm/utils.js', 'lib/internal/modules/esm/worker.js', 'lib/internal/modules/helpers.js', 'lib/internal/modules/package_json_reader.js', 'lib/internal/modules/run_main.js', 'lib/internal/modules/typescript.js', 'lib/internal/navigator.js', 'lib/internal/net.js', 'lib/internal/options.js', 'lib/internal/per_context/domexception.js', 'lib/internal/per_context/messageport.js', 'lib/internal/per_context/primordials.js', 'lib/internal/perf/event_loop_delay.js', 'lib/internal/perf/event_loop_utilization.js', 'lib/internal/perf/nodetiming.js', 'lib/internal/perf/observe.js', 'lib/internal/perf/performance.js', 'lib/internal/perf/performance_entry.js', 'lib/internal/perf/resource_timing.js', 'lib/internal/perf/timerify.js', 'lib/internal/perf/usertiming.js', 'lib/internal/perf/utils.js', 'lib/internal/priority_queue.js', 'lib/internal/process/execution.js', 'lib/internal/process/finalization.js', 'lib/internal/process/per_thread.js', 'lib/internal/process/permission.js', 'lib/internal/process/pre_execution.js', 'lib/internal/process/promises.js', 'lib/internal/process/report.js', 'lib/internal/process/signal.js', 'lib/internal/process/task_queues.js', 'lib/internal/process/warning.js', 'lib/internal/process/worker_thread_only.js', 'lib/internal/promise_hooks.js', 'lib/internal/querystring.js', 'lib/internal/quic/quic.js', 'lib/internal/quic/state.js', 'lib/internal/quic/stats.js', 'lib/internal/quic/symbols.js', 'lib/internal/readline/callbacks.js', 'lib/internal/readline/emitKeypressEvents.js', 'lib/internal/readline/interface.js', 'lib/internal/readline/promises.js', 'lib/internal/readline/utils.js', 'lib/internal/repl.js', 'lib/internal/repl/await.js', 'lib/internal/repl/history.js', 'lib/internal/repl/utils.js', 'lib/internal/socket_list.js', 'lib/internal/socketaddress.js', 'lib/internal/source_map/prepare_stack_trace.js', 'lib/internal/source_map/source_map.js', 'lib/internal/source_map/source_map_cache.js', 'lib/internal/source_map/source_map_cache_map.js', 'lib/internal/stream_base_commons.js', 'lib/internal/streams/add-abort-signal.js', 'lib/internal/streams/compose.js', 'lib/internal/streams/destroy.js', 'lib/internal/streams/duplex.js', 'lib/internal/streams/duplexify.js', 'lib/internal/streams/duplexpair.js', 'lib/internal/streams/end-of-stream.js', 'lib/internal/streams/from.js', 'lib/internal/streams/lazy_transform.js', 'lib/internal/streams/legacy.js', 'lib/internal/streams/operators.js', 'lib/internal/streams/passthrough.js', 'lib/internal/streams/pipeline.js', 'lib/internal/streams/readable.js', 'lib/internal/streams/state.js', 'lib/internal/streams/transform.js', 'lib/internal/streams/utils.js', 'lib/internal/streams/writable.js', 'lib/internal/test/binding.js', 'lib/internal/test/transfer.js', 'lib/internal/test_runner/assert.js', 'lib/internal/test_runner/coverage.js', 'lib/internal/test_runner/harness.js', 'lib/internal/test_runner/mock/loader.js', 'lib/internal/test_runner/mock/mock.js', 'lib/internal/test_runner/mock/mock_timers.js', 'lib/internal/test_runner/reporter/dot.js', 'lib/internal/test_runner/reporter/junit.js', 'lib/internal/test_runner/reporter/lcov.js', 'lib/internal/test_runner/reporter/spec.js', 'lib/internal/test_runner/reporter/tap.js', 'lib/internal/test_runner/reporter/utils.js', 'lib/internal/test_runner/reporter/v8-serializer.js', 'lib/internal/test_runner/runner.js', 'lib/internal/test_runner/snapshot.js', 'lib/internal/test_runner/test.js', 'lib/internal/test_runner/tests_stream.js', 'lib/internal/test_runner/utils.js', 'lib/internal/timers.js', 'lib/internal/tls/secure-context.js', 'lib/internal/tls/secure-pair.js', 'lib/internal/trace_events_async_hooks.js', 'lib/internal/tty.js', 'lib/internal/url.js', 'lib/internal/util.js', 'lib/internal/util/colors.js', 'lib/internal/util/comparisons.js', 'lib/internal/util/debuglog.js', 'lib/internal/util/inspect.js', 'lib/internal/util/inspector.js', 'lib/internal/util/parse_args/parse_args.js', 'lib/internal/util/parse_args/utils.js', 'lib/internal/util/types.js', 'lib/internal/v8/startup_snapshot.js', 'lib/internal/v8_prof_polyfill.js', 'lib/internal/v8_prof_processor.js', 'lib/internal/validators.js', 'lib/internal/vm.js', 'lib/internal/vm/module.js', 'lib/internal/wasm_web_api.js', 'lib/internal/watch_mode/files_watcher.js', 'lib/internal/watchdog.js', 'lib/internal/webidl.js', 'lib/internal/webstorage.js', 'lib/internal/webstreams/adapters.js', 'lib/internal/webstreams/compression.js', 'lib/internal/webstreams/encoding.js', 'lib/internal/webstreams/queuingstrategies.js', 'lib/internal/webstreams/readablestream.js', 'lib/internal/webstreams/transfer.js', 'lib/internal/webstreams/transformstream.js', 'lib/internal/webstreams/util.js', 'lib/internal/webstreams/writablestream.js', 'lib/internal/worker.js', 'lib/internal/worker/io.js', 'lib/internal/worker/js_transferable.js', 'lib/internal/worker/messaging.js', 'lib/module.js', 'lib/net.js', 'lib/os.js', 'lib/path.js', 'lib/path/posix.js', 'lib/path/win32.js', 'lib/perf_hooks.js', 'lib/process.js', 'lib/punycode.js', 'lib/querystring.js', 'lib/readline.js', 'lib/readline/promises.js', 'lib/repl.js', 'lib/sea.js', 'lib/sqlite.js', 'lib/stream.js', 'lib/stream/consumers.js', 'lib/stream/promises.js', 'lib/stream/web.js', 'lib/string_decoder.js', 'lib/sys.js', 'lib/test.js', 'lib/test/reporters.js', 'lib/timers.js', 'lib/timers/promises.js', 'lib/tls.js', 'lib/trace_events.js', 'lib/tty.js', 'lib/url.js', 'lib/util.js', 'lib/util/types.js', 'lib/v8.js', 'lib/vm.js', 'lib/wasi.js', 'lib/worker_threads.js', 'lib/zlib.js'], 'node_module_version': 127, 'node_no_browser_globals': 'false', 'node_prefix': '/opt/alt/alt-nodejs22/root/usr', 'node_release_urlbase': '', 'node_section_ordering_info': '', 'node_shared': 'true', 'node_shared_ada': 'false', 'node_shared_brotli': 'false', 'node_shared_cares': 'false', 'node_shared_http_parser': 'false', 'node_shared_libuv': 'false', 'node_shared_nghttp2': 'false', 'node_shared_nghttp3': 'false', 'node_shared_ngtcp2': 'false', 'node_shared_openssl': 'true', 'node_shared_simdjson': 'false', 'node_shared_simdutf': 'false', 'node_shared_sqlite': 'false', 'node_shared_uvwasi': 'false', 'node_shared_zlib': 'true', 'node_tag': '', 'node_target_type': 'shared_library', 'node_use_amaro': 'true', 'node_use_bundled_v8': 'true', 'node_use_node_code_cache': 'false', 'node_use_node_snapshot': 'false', 'node_use_openssl': 'true', 'node_use_v8_platform': 'true', 'node_with_ltcg': 'false', 'node_without_node_options': 'false', 'node_write_snapshot_as_array_literals': 'false', 'openssl_is_fips': 'false', 'openssl_quic': 'false', 'ossfuzz': 'false', 'shlib_suffix': 'so.127', 'single_executable_application': 'true', 'target_arch': 'x64', 'ubsan': 0, 'use_prefix_to_find_headers': 'false', 'v8_enable_31bit_smis_on_64bit_arch': 0, 'v8_enable_extensible_ro_snapshot': 0, 'v8_enable_gdbjit': 0, 'v8_enable_hugepage': 0, 'v8_enable_i18n_support': 1, 'v8_enable_inspector': 1, 'v8_enable_javascript_promise_hooks': 1, 'v8_enable_lite_mode': 0, 'v8_enable_maglev': 0, 'v8_enable_object_print': 1, 'v8_enable_pointer_compression': 0, 'v8_enable_sandbox': 0, 'v8_enable_shared_ro_heap': 1, 'v8_enable_short_builtin_calls': 1, 'v8_enable_wasm_simd256_revec': 1, 'v8_enable_webassembly': 1, 'v8_optimized_debug': 1, 'v8_promise_internal_field_count': 1, 'v8_random_seed': 0, 'v8_trace_maps': 0, 'v8_use_siphash': 1, 'want_separate_host_toolset': 0}}	29.01 KB	2025-03-03 12:37
📁 cppgc	-	2025-10-13 08:01
📄 js_native_api.h #ifndef SRC_JS_NATIVE_API_H_ #define SRC_JS_NATIVE_API_H_ // This file needs to be compatible with C compilers. #include <stdbool.h> // NOLINT(modernize-deprecated-headers) #include <stddef.h> // NOLINT(modernize-deprecated-headers) // Use INT_MAX, this should only be consumed by the pre-processor anyway. #define NAPI_VERSION_EXPERIMENTAL 2147483647 #ifndef NAPI_VERSION #ifdef NAPI_EXPERIMENTAL #define NAPI_VERSION NAPI_VERSION_EXPERIMENTAL #else // The baseline version for N-API. // The NAPI_VERSION controls which version will be used by default when // compilling a native addon. If the addon developer specifically wants to use // functions available in a new version of N-API that is not yet ported in all // LTS versions, they can set NAPI_VERSION knowing that they have specifically // depended on that version. #define NAPI_VERSION 8 #endif #endif #include "js_native_api_types.h" // If you need __declspec(dllimport), either include <node_api.h> instead, or // define NAPI_EXTERN as __declspec(dllimport) on the compiler's command line. #ifndef NAPI_EXTERN #ifdef _WIN32 #define NAPI_EXTERN __declspec(dllexport) #elif defined(__wasm__) #define NAPI_EXTERN \ __attribute__((visibility("default"))) \ __attribute__((__import_module__("napi"))) #else #define NAPI_EXTERN __attribute__((visibility("default"))) #endif #endif #define NAPI_AUTO_LENGTH SIZE_MAX #ifdef __cplusplus #define EXTERN_C_START extern "C" { #define EXTERN_C_END } #else #define EXTERN_C_START #define EXTERN_C_END #endif EXTERN_C_START NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info( node_api_basic_env env, const napi_extended_error_info** result); // Getters for defined singletons NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_null(napi_env env, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_global(napi_env env, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_boolean(napi_env env, bool value, napi_value* result); // Methods to create Primitive types/Objects NAPI_EXTERN napi_status NAPI_CDECL napi_create_object(napi_env env, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_array(napi_env env, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_array_with_length(napi_env env, size_t length, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_double(napi_env env, double value, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_int32(napi_env env, int32_t value, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_uint32(napi_env env, uint32_t value, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_int64(napi_env env, int64_t value, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_latin1( napi_env env, const char* str, size_t length, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf8(napi_env env, const char* str, size_t length, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf16(napi_env env, const char16_t* str, size_t length, napi_value* result); #if NAPI_VERSION >= 10 NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_latin1( napi_env env, char* str, size_t length, node_api_basic_finalize finalize_callback, void* finalize_hint, napi_value* result, bool* copied); NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_utf16(napi_env env, char16_t* str, size_t length, node_api_basic_finalize finalize_callback, void* finalize_hint, napi_value* result, bool* copied); NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_latin1( napi_env env, const char* str, size_t length, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf8( napi_env env, const char* str, size_t length, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf16( napi_env env, const char16_t* str, size_t length, napi_value* result); #endif // NAPI_VERSION >= 10 NAPI_EXTERN napi_status NAPI_CDECL napi_create_symbol(napi_env env, napi_value description, napi_value* result); #if NAPI_VERSION >= 9 NAPI_EXTERN napi_status NAPI_CDECL node_api_symbol_for(napi_env env, const char* utf8description, size_t length, napi_value* result); #endif // NAPI_VERSION >= 9 NAPI_EXTERN napi_status NAPI_CDECL napi_create_function(napi_env env, const char* utf8name, size_t length, napi_callback cb, void* data, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_error(napi_env env, napi_value code, napi_value msg, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_type_error(napi_env env, napi_value code, napi_value msg, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_range_error(napi_env env, napi_value code, napi_value msg, napi_value* result); #if NAPI_VERSION >= 9 NAPI_EXTERN napi_status NAPI_CDECL node_api_create_syntax_error( napi_env env, napi_value code, napi_value msg, napi_value* result); #endif // NAPI_VERSION >= 9 // Methods to get the native napi_value from Primitive type NAPI_EXTERN napi_status NAPI_CDECL napi_typeof(napi_env env, napi_value value, napi_valuetype* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_double(napi_env env, napi_value value, double* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int32(napi_env env, napi_value value, int32_t* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_uint32(napi_env env, napi_value value, uint32_t* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int64(napi_env env, napi_value value, int64_t* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bool(napi_env env, napi_value value, bool* result); // Copies LATIN-1 encoded bytes from a string into a buffer. NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_latin1( napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result); // Copies UTF-8 encoded bytes from a string into a buffer. NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_utf8( napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result); // Copies UTF-16 encoded bytes from a string into a buffer. NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_utf16(napi_env env, napi_value value, char16_t* buf, size_t bufsize, size_t* result); // Methods to coerce values // These APIs may execute user scripts NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_bool(napi_env env, napi_value value, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_number(napi_env env, napi_value value, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_object(napi_env env, napi_value value, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_string(napi_env env, napi_value value, napi_value* result); // Methods to work with Objects NAPI_EXTERN napi_status NAPI_CDECL napi_get_prototype(napi_env env, napi_value object, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_property_names(napi_env env, napi_value object, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_set_property(napi_env env, napi_value object, napi_value key, napi_value value); NAPI_EXTERN napi_status NAPI_CDECL napi_has_property(napi_env env, napi_value object, napi_value key, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_property(napi_env env, napi_value object, napi_value key, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_delete_property(napi_env env, napi_value object, napi_value key, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_has_own_property(napi_env env, napi_value object, napi_value key, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_set_named_property(napi_env env, napi_value object, const char* utf8name, napi_value value); NAPI_EXTERN napi_status NAPI_CDECL napi_has_named_property(napi_env env, napi_value object, const char* utf8name, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_named_property(napi_env env, napi_value object, const char* utf8name, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_set_element(napi_env env, napi_value object, uint32_t index, napi_value value); NAPI_EXTERN napi_status NAPI_CDECL napi_has_element(napi_env env, napi_value object, uint32_t index, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_element(napi_env env, napi_value object, uint32_t index, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_delete_element(napi_env env, napi_value object, uint32_t index, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_define_properties(napi_env env, napi_value object, size_t property_count, const napi_property_descriptor* properties); // Methods to work with Arrays NAPI_EXTERN napi_status NAPI_CDECL napi_is_array(napi_env env, napi_value value, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_array_length(napi_env env, napi_value value, uint32_t* result); // Methods to compare values NAPI_EXTERN napi_status NAPI_CDECL napi_strict_equals(napi_env env, napi_value lhs, napi_value rhs, bool* result); // Methods to work with Functions NAPI_EXTERN napi_status NAPI_CDECL napi_call_function(napi_env env, napi_value recv, napi_value func, size_t argc, const napi_value* argv, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_new_instance(napi_env env, napi_value constructor, size_t argc, const napi_value* argv, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_instanceof(napi_env env, napi_value object, napi_value constructor, bool* result); // Methods to work with napi_callbacks // Gets all callback info in a single call. (Ugly, but faster.) NAPI_EXTERN napi_status NAPI_CDECL napi_get_cb_info( napi_env env, // [in] Node-API environment handle napi_callback_info cbinfo, // [in] Opaque callback-info handle size_t* argc, // [in-out] Specifies the size of the provided argv array // and receives the actual count of args. napi_value* argv, // [out] Array of values napi_value* this_arg, // [out] Receives the JS 'this' arg for the call void** data); // [out] Receives the data pointer for the callback. NAPI_EXTERN napi_status NAPI_CDECL napi_get_new_target( napi_env env, napi_callback_info cbinfo, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_define_class(napi_env env, const char* utf8name, size_t length, napi_callback constructor, void* data, size_t property_count, const napi_property_descriptor* properties, napi_value* result); // Methods to work with external data objects NAPI_EXTERN napi_status NAPI_CDECL napi_wrap(napi_env env, napi_value js_object, void* native_object, node_api_basic_finalize finalize_cb, void* finalize_hint, napi_ref* result); NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(napi_env env, napi_value js_object, void result); NAPI_EXTERN napi_status NAPI_CDECL napi_remove_wrap(napi_env env, napi_value js_object, void result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_external(napi_env env, void* data, node_api_basic_finalize finalize_cb, void* finalize_hint, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(napi_env env, napi_value value, void** result); // Methods to control object lifespan // Set initial_refcount to 0 for a weak reference, >0 for a strong reference. NAPI_EXTERN napi_status NAPI_CDECL napi_create_reference(napi_env env, napi_value value, uint32_t initial_refcount, napi_ref* result); // Deletes a reference. The referenced value is released, and may // be GC'd unless there are other references to it. NAPI_EXTERN napi_status NAPI_CDECL napi_delete_reference(napi_env env, napi_ref ref); // Increments the reference count, optionally returning the resulting count. // After this call the reference will be a strong reference because its // refcount is >0, and the referenced object is effectively "pinned". // Calling this when the refcount is 0 and the object is unavailable // results in an error. NAPI_EXTERN napi_status NAPI_CDECL napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result); // Decrements the reference count, optionally returning the resulting count. // If the result is 0 the reference is now weak and the object may be GC'd // at any time if there are no other references. Calling this when the // refcount is already 0 results in an error. NAPI_EXTERN napi_status NAPI_CDECL napi_reference_unref(napi_env env, napi_ref ref, uint32_t* result); // Attempts to get a referenced value. If the reference is weak, // the value might no longer be available, in that case the call // is still successful but the result is NULL. NAPI_EXTERN napi_status NAPI_CDECL napi_get_reference_value(napi_env env, napi_ref ref, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_open_handle_scope(napi_env env, napi_handle_scope* result); NAPI_EXTERN napi_status NAPI_CDECL napi_close_handle_scope(napi_env env, napi_handle_scope scope); NAPI_EXTERN napi_status NAPI_CDECL napi_open_escapable_handle_scope( napi_env env, napi_escapable_handle_scope* result); NAPI_EXTERN napi_status NAPI_CDECL napi_close_escapable_handle_scope( napi_env env, napi_escapable_handle_scope scope); NAPI_EXTERN napi_status NAPI_CDECL napi_escape_handle(napi_env env, napi_escapable_handle_scope scope, napi_value escapee, napi_value* result); // Methods to support error handling NAPI_EXTERN napi_status NAPI_CDECL napi_throw(napi_env env, napi_value error); NAPI_EXTERN napi_status NAPI_CDECL napi_throw_error(napi_env env, const char* code, const char* msg); NAPI_EXTERN napi_status NAPI_CDECL napi_throw_type_error(napi_env env, const char* code, const char* msg); NAPI_EXTERN napi_status NAPI_CDECL napi_throw_range_error(napi_env env, const char* code, const char* msg); #if NAPI_VERSION >= 9 NAPI_EXTERN napi_status NAPI_CDECL node_api_throw_syntax_error(napi_env env, const char* code, const char* msg); #endif // NAPI_VERSION >= 9 NAPI_EXTERN napi_status NAPI_CDECL napi_is_error(napi_env env, napi_value value, bool* result); // Methods to support catching exceptions NAPI_EXTERN napi_status NAPI_CDECL napi_is_exception_pending(napi_env env, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_and_clear_last_exception(napi_env env, napi_value* result); // Methods to work with array buffers and typed arrays NAPI_EXTERN napi_status NAPI_CDECL napi_is_arraybuffer(napi_env env, napi_value value, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_arraybuffer(napi_env env, size_t byte_length, void** data, napi_value* result); #ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED NAPI_EXTERN napi_status NAPI_CDECL napi_create_external_arraybuffer(napi_env env, void* external_data, size_t byte_length, node_api_basic_finalize finalize_cb, void* finalize_hint, napi_value* result); #endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED NAPI_EXTERN napi_status NAPI_CDECL napi_get_arraybuffer_info( napi_env env, napi_value arraybuffer, void** data, size_t* byte_length); NAPI_EXTERN napi_status NAPI_CDECL napi_is_typedarray(napi_env env, napi_value value, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_typedarray(napi_env env, napi_typedarray_type type, size_t length, napi_value arraybuffer, size_t byte_offset, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_typedarray_info(napi_env env, napi_value typedarray, napi_typedarray_type* type, size_t* length, void** data, napi_value* arraybuffer, size_t* byte_offset); NAPI_EXTERN napi_status NAPI_CDECL napi_create_dataview(napi_env env, size_t length, napi_value arraybuffer, size_t byte_offset, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_is_dataview(napi_env env, napi_value value, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_dataview_info(napi_env env, napi_value dataview, size_t* bytelength, void** data, napi_value* arraybuffer, size_t* byte_offset); // version management NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env, uint32_t* result); // Promises NAPI_EXTERN napi_status NAPI_CDECL napi_create_promise(napi_env env, napi_deferred* deferred, napi_value* promise); NAPI_EXTERN napi_status NAPI_CDECL napi_resolve_deferred(napi_env env, napi_deferred deferred, napi_value resolution); NAPI_EXTERN napi_status NAPI_CDECL napi_reject_deferred(napi_env env, napi_deferred deferred, napi_value rejection); NAPI_EXTERN napi_status NAPI_CDECL napi_is_promise(napi_env env, napi_value value, bool* is_promise); // Running a script NAPI_EXTERN napi_status NAPI_CDECL napi_run_script(napi_env env, napi_value script, napi_value* result); // Memory management NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory( node_api_basic_env env, int64_t change_in_bytes, int64_t* adjusted_value); #if NAPI_VERSION >= 5 // Dates NAPI_EXTERN napi_status NAPI_CDECL napi_create_date(napi_env env, double time, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_is_date(napi_env env, napi_value value, bool* is_date); NAPI_EXTERN napi_status NAPI_CDECL napi_get_date_value(napi_env env, napi_value value, double* result); // Add finalizer for pointer NAPI_EXTERN napi_status NAPI_CDECL napi_add_finalizer(napi_env env, napi_value js_object, void* finalize_data, node_api_basic_finalize finalize_cb, void* finalize_hint, napi_ref* result); #endif // NAPI_VERSION >= 5 #ifdef NAPI_EXPERIMENTAL #define NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER NAPI_EXTERN napi_status NAPI_CDECL node_api_post_finalizer(node_api_basic_env env, napi_finalize finalize_cb, void* finalize_data, void* finalize_hint); #endif // NAPI_EXPERIMENTAL #if NAPI_VERSION >= 6 // BigInt NAPI_EXTERN napi_status NAPI_CDECL napi_create_bigint_int64(napi_env env, int64_t value, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_create_bigint_words(napi_env env, int sign_bit, size_t word_count, const uint64_t* words, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bigint_int64(napi_env env, napi_value value, int64_t* result, bool* lossless); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bigint_uint64( napi_env env, napi_value value, uint64_t* result, bool* lossless); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bigint_words(napi_env env, napi_value value, int* sign_bit, size_t* word_count, uint64_t* words); // Object NAPI_EXTERN napi_status NAPI_CDECL napi_get_all_property_names(napi_env env, napi_value object, napi_key_collection_mode key_mode, napi_key_filter key_filter, napi_key_conversion key_conversion, napi_value* result); // Instance data NAPI_EXTERN napi_status NAPI_CDECL napi_set_instance_data(node_api_basic_env env, void* data, napi_finalize finalize_cb, void* finalize_hint); NAPI_EXTERN napi_status NAPI_CDECL napi_get_instance_data(node_api_basic_env env, void** data); #endif // NAPI_VERSION >= 6 #if NAPI_VERSION >= 7 // ArrayBuffer detaching NAPI_EXTERN napi_status NAPI_CDECL napi_detach_arraybuffer(napi_env env, napi_value arraybuffer); NAPI_EXTERN napi_status NAPI_CDECL napi_is_detached_arraybuffer(napi_env env, napi_value value, bool* result); #endif // NAPI_VERSION >= 7 #if NAPI_VERSION >= 8 // Type tagging NAPI_EXTERN napi_status NAPI_CDECL napi_type_tag_object( napi_env env, napi_value value, const napi_type_tag* type_tag); NAPI_EXTERN napi_status NAPI_CDECL napi_check_object_type_tag(napi_env env, napi_value value, const napi_type_tag* type_tag, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_object_freeze(napi_env env, napi_value object); NAPI_EXTERN napi_status NAPI_CDECL napi_object_seal(napi_env env, napi_value object); #endif // NAPI_VERSION >= 8 EXTERN_C_END #endif // SRC_JS_NATIVE_API_H_	31.28 KB	2025-03-03 12:36
📄 js_native_api_types.h #ifndef SRC_JS_NATIVE_API_TYPES_H_ #define SRC_JS_NATIVE_API_TYPES_H_ // This file needs to be compatible with C compilers. // This is a public include file, and these includes have essentially // became part of it's API. #include <stddef.h> // NOLINT(modernize-deprecated-headers) #include <stdint.h> // NOLINT(modernize-deprecated-headers) #if !defined __cplusplus \|\| (defined(_MSC_VER) && _MSC_VER < 1900) typedef uint16_t char16_t; #endif #ifndef NAPI_CDECL #ifdef _WIN32 #define NAPI_CDECL __cdecl #else #define NAPI_CDECL #endif #endif // JSVM API types are all opaque pointers for ABI stability // typedef undefined structs instead of void* for compile time type safety typedef struct napi_env__* napi_env; // We need to mark APIs which can be called during garbage collection (GC), // meaning that they do not affect the state of the JS engine, and can // therefore be called synchronously from a finalizer that itself runs // synchronously during GC. Such APIs can receive either a `napi_env` or a // `node_api_basic_env` as their first parameter, because we should be able to // also call them during normal, non-garbage-collecting operations, whereas // APIs that affect the state of the JS engine can only receive a `napi_env` as // their first parameter, because we must not call them during GC. In lieu of // inheritance, we use the properties of the const qualifier to accomplish // this, because both a const and a non-const value can be passed to an API // expecting a const value, but only a non-const value can be passed to an API // expecting a non-const value. // // In conjunction with appropriate CFLAGS to warn us if we're passing a const // (basic) environment into an API that expects a non-const environment, and // the definition of basic finalizer function pointer types below, which // receive a basic environment as their first parameter, and can thus only call // basic APIs (unless the user explicitly casts the environment), we achieve // the ability to ensure at compile time that we do not call APIs that affect // the state of the JS engine from a synchronous (basic) finalizer. #if !defined(NAPI_EXPERIMENTAL) \|\| \ (defined(NAPI_EXPERIMENTAL) && \ (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) \|\| \ defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT))) typedef struct napi_env__* node_api_nogc_env; #else typedef const struct napi_env__* node_api_nogc_env; #endif typedef node_api_nogc_env node_api_basic_env; typedef struct napi_value__* napi_value; typedef struct napi_ref__* napi_ref; typedef struct napi_handle_scope__* napi_handle_scope; typedef struct napi_escapable_handle_scope__* napi_escapable_handle_scope; typedef struct napi_callback_info__* napi_callback_info; typedef struct napi_deferred__* napi_deferred; typedef enum { napi_default = 0, napi_writable = 1 << 0, napi_enumerable = 1 << 1, napi_configurable = 1 << 2, // Used with napi_define_class to distinguish static properties // from instance properties. Ignored by napi_define_properties. napi_static = 1 << 10, #if NAPI_VERSION >= 8 // Default for class methods. napi_default_method = napi_writable \| napi_configurable, // Default for object properties, like in JS obj[prop]. napi_default_jsproperty = napi_writable \| napi_enumerable \| napi_configurable, #endif // NAPI_VERSION >= 8 } napi_property_attributes; typedef enum { // ES6 types (corresponds to typeof) napi_undefined, napi_null, napi_boolean, napi_number, napi_string, napi_symbol, napi_object, napi_function, napi_external, napi_bigint, } napi_valuetype; typedef enum { napi_int8_array, napi_uint8_array, napi_uint8_clamped_array, napi_int16_array, napi_uint16_array, napi_int32_array, napi_uint32_array, napi_float32_array, napi_float64_array, napi_bigint64_array, napi_biguint64_array, } napi_typedarray_type; typedef enum { napi_ok, napi_invalid_arg, napi_object_expected, napi_string_expected, napi_name_expected, napi_function_expected, napi_number_expected, napi_boolean_expected, napi_array_expected, napi_generic_failure, napi_pending_exception, napi_cancelled, napi_escape_called_twice, napi_handle_scope_mismatch, napi_callback_scope_mismatch, napi_queue_full, napi_closing, napi_bigint_expected, napi_date_expected, napi_arraybuffer_expected, napi_detachable_arraybuffer_expected, napi_would_deadlock, // unused napi_no_external_buffers_allowed, napi_cannot_run_js, } napi_status; // Note: when adding a new enum value to `napi_status`, please also update // * `const int last_status` in the definition of `napi_get_last_error_info()' // in file js_native_api_v8.cc. // * `const char* error_messages[]` in file js_native_api_v8.cc with a brief // message explaining the error. // * the definition of `napi_status` in doc/api/n-api.md to reflect the newly // added value(s). typedef napi_value(NAPI_CDECL* napi_callback)(napi_env env, napi_callback_info info); typedef void(NAPI_CDECL* napi_finalize)(napi_env env, void* finalize_data, void* finalize_hint); #if !defined(NAPI_EXPERIMENTAL) \|\| \ (defined(NAPI_EXPERIMENTAL) && \ (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) \|\| \ defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT))) typedef napi_finalize node_api_nogc_finalize; #else typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env, void* finalize_data, void* finalize_hint); #endif typedef node_api_nogc_finalize node_api_basic_finalize; typedef struct { // One of utf8name or name should be NULL. const char* utf8name; napi_value name; napi_callback method; napi_callback getter; napi_callback setter; napi_value value; napi_property_attributes attributes; void* data; } napi_property_descriptor; typedef struct { const char* error_message; void* engine_reserved; uint32_t engine_error_code; napi_status error_code; } napi_extended_error_info; #if NAPI_VERSION >= 6 typedef enum { napi_key_include_prototypes, napi_key_own_only } napi_key_collection_mode; typedef enum { napi_key_all_properties = 0, napi_key_writable = 1, napi_key_enumerable = 1 << 1, napi_key_configurable = 1 << 2, napi_key_skip_strings = 1 << 3, napi_key_skip_symbols = 1 << 4 } napi_key_filter; typedef enum { napi_key_keep_numbers, napi_key_numbers_to_strings } napi_key_conversion; #endif // NAPI_VERSION >= 6 #if NAPI_VERSION >= 8 typedef struct { uint64_t lower; uint64_t upper; } napi_type_tag; #endif // NAPI_VERSION >= 8 #endif // SRC_JS_NATIVE_API_TYPES_H_	6.87 KB	2025-03-03 12:36
📁 libplatform	-	2025-10-13 08:01
📄 node.h // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. #ifndef SRC_NODE_H_ #define SRC_NODE_H_ #ifdef _WIN32 # ifndef BUILDING_NODE_EXTENSION # define NODE_EXTERN __declspec(dllexport) # else # define NODE_EXTERN __declspec(dllimport) # endif #else # define NODE_EXTERN __attribute__((visibility("default"))) #endif // Declarations annotated with NODE_EXTERN_PRIVATE do not form part of // the public API. They are implementation details that can and will // change between releases, even in semver patch releases. Do not use // any such symbol in external code. #ifdef NODE_SHARED_MODE #define NODE_EXTERN_PRIVATE NODE_EXTERN #else #define NODE_EXTERN_PRIVATE #endif #ifdef BUILDING_NODE_EXTENSION # undef BUILDING_V8_SHARED # undef BUILDING_UV_SHARED # define USING_V8_SHARED 1 # define USING_UV_SHARED 1 #endif // This should be defined in make system. // See issue https://github.com/nodejs/node-v0.x-archive/issues/1236 #if defined(__MINGW32__) \|\| defined(_MSC_VER) #ifndef _WIN32_WINNT # define _WIN32_WINNT 0x0600 // Windows Server 2008 #endif #ifndef NOMINMAX # define NOMINMAX #endif #endif #if defined(_MSC_VER) #define PATH_MAX MAX_PATH #endif #ifdef _WIN32 # define SIGKILL 9 #endif #include "v8.h" // NOLINT(build/include_order) #include "v8-platform.h" // NOLINT(build/include_order) #include "node_version.h" // NODE_MODULE_VERSION #define NAPI_EXPERIMENTAL #include "node_api.h" #include <functional> #include <memory> #include <optional> #include <ostream> // We cannot use __POSIX__ in this header because that's only defined when // building Node.js. #ifndef _WIN32 #include <signal.h> #endif // _WIN32 #define NODE_MAKE_VERSION(major, minor, patch) \ ((major) * 0x1000 + (minor) * 0x100 + (patch)) #ifdef __clang__ # define NODE_CLANG_AT_LEAST(major, minor, patch) \ (NODE_MAKE_VERSION(major, minor, patch) <= \ NODE_MAKE_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)) #else # define NODE_CLANG_AT_LEAST(major, minor, patch) (0) #endif #ifdef __GNUC__ # define NODE_GNUC_AT_LEAST(major, minor, patch) \ (NODE_MAKE_VERSION(major, minor, patch) <= \ NODE_MAKE_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)) #else # define NODE_GNUC_AT_LEAST(major, minor, patch) (0) #endif #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS # define NODE_DEPRECATED(message, declarator) declarator #else // NODE_WANT_INTERNALS # if NODE_CLANG_AT_LEAST(2, 9, 0) \|\| NODE_GNUC_AT_LEAST(4, 5, 0) # define NODE_DEPRECATED(message, declarator) \ __attribute__((deprecated(message))) declarator # elif defined(_MSC_VER) # define NODE_DEPRECATED(message, declarator) \ __declspec(deprecated) declarator # else # define NODE_DEPRECATED(message, declarator) declarator # endif #endif // Forward-declare libuv loop struct uv_loop_s; // Forward-declare these functions now to stop MSVS from becoming // terminally confused when it's done in node_internals.h namespace node { struct SnapshotData; namespace tracing { class TracingController; } NODE_EXTERN v8::Local<v8::Value> ErrnoException(v8::Isolate* isolate, int errorno, const char* syscall = nullptr, const char* message = nullptr, const char* path = nullptr); NODE_EXTERN v8::Local<v8::Value> UVException(v8::Isolate* isolate, int errorno, const char* syscall = nullptr, const char* message = nullptr, const char* path = nullptr, const char* dest = nullptr); NODE_DEPRECATED("Use ErrnoException(isolate, ...)", inline v8::Local<v8::Value> ErrnoException( int errorno, const char* syscall = nullptr, const char* message = nullptr, const char* path = nullptr) { return ErrnoException(v8::Isolate::GetCurrent(), errorno, syscall, message, path); }) NODE_DEPRECATED("Use UVException(isolate, ...)", inline v8::Local<v8::Value> UVException(int errorno, const char* syscall = nullptr, const char* message = nullptr, const char* path = nullptr) { return UVException(v8::Isolate::GetCurrent(), errorno, syscall, message, path); }) /* * These methods need to be called in a HandleScope. * * It is preferred that you use the `MakeCallback` overloads taking * `async_context` arguments. / NODE_DEPRECATED("Use MakeCallback(..., async_context)", NODE_EXTERN v8::Local<v8::Value> MakeCallback( v8::Isolate isolate, v8::Local<v8::Object> recv, const char* method, int argc, v8::Local<v8::Value>* argv)); NODE_DEPRECATED("Use MakeCallback(..., async_context)", NODE_EXTERN v8::Local<v8::Value> MakeCallback( v8::Isolate* isolate, v8::Local<v8::Object> recv, v8::Local<v8::String> symbol, int argc, v8::Local<v8::Value>* argv)); NODE_DEPRECATED("Use MakeCallback(..., async_context)", NODE_EXTERN v8::Local<v8::Value> MakeCallback( v8::Isolate* isolate, v8::Local<v8::Object> recv, v8::Local<v8::Function> callback, int argc, v8::Local<v8::Value>* argv)); } // namespace node #include <cassert> #include <cstdint> #ifndef NODE_STRINGIFY # define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n) # define NODE_STRINGIFY_HELPER(n) #n #endif #ifdef _WIN32 #if !defined(_SSIZE_T_) && !defined(_SSIZE_T_DEFINED) typedef intptr_t ssize_t; # define _SSIZE_T_ # define _SSIZE_T_DEFINED #endif #else // !_WIN32 # include <sys/types.h> // size_t, ssize_t #endif // _WIN32 namespace node { class IsolateData; class Environment; class MultiIsolatePlatform; class InitializationResultImpl; namespace ProcessInitializationFlags { enum Flags : uint32_t { kNoFlags = 0, // Enable stdio inheritance, which is disabled by default. // This flag is also implied by kNoStdioInitialization. kEnableStdioInheritance = 1 << 0, // Disable reading the NODE_OPTIONS environment variable. kDisableNodeOptionsEnv = 1 << 1, // Do not parse CLI options. kDisableCLIOptions = 1 << 2, // Do not initialize ICU. kNoICU = 1 << 3, // Do not modify stdio file descriptor or TTY state. kNoStdioInitialization = 1 << 4, // Do not register Node.js-specific signal handlers // and reset other signal handlers to default state. kNoDefaultSignalHandling = 1 << 5, // Do not perform V8 initialization. kNoInitializeV8 = 1 << 6, // Do not initialize a default Node.js-provided V8 platform instance. kNoInitializeNodeV8Platform = 1 << 7, // Do not initialize OpenSSL config. kNoInitOpenSSL = 1 << 8, // Do not initialize Node.js debugging based on environment variables. kNoParseGlobalDebugVariables = 1 << 9, // Do not adjust OS resource limits for this process. kNoAdjustResourceLimits = 1 << 10, // Do not map code segments into large pages for this process. kNoUseLargePages = 1 << 11, // Skip printing output for --help, --version, --v8-options. kNoPrintHelpOrVersionOutput = 1 << 12, // Do not perform cppgc initialization. If set, the embedder must call // cppgc::InitializeProcess() before creating a Node.js environment // and call cppgc::ShutdownProcess() before process shutdown. kNoInitializeCppgc = 1 << 13, // Initialize the process for predictable snapshot generation. kGeneratePredictableSnapshot = 1 << 14, // Emulate the behavior of InitializeNodeWithArgs() when passing // a flags argument to the InitializeOncePerProcess() replacement // function. kLegacyInitializeNodeWithArgsBehavior = kNoStdioInitialization \| kNoDefaultSignalHandling \| kNoInitializeV8 \| kNoInitializeNodeV8Platform \| kNoInitOpenSSL \| kNoParseGlobalDebugVariables \| kNoAdjustResourceLimits \| kNoUseLargePages \| kNoPrintHelpOrVersionOutput \| kNoInitializeCppgc, }; } // namespace ProcessInitializationFlags namespace ProcessFlags = ProcessInitializationFlags; // Legacy alias. namespace StopFlags { enum Flags : uint32_t { kNoFlags = 0, // Do not explicitly terminate the Isolate // when exiting the Environment. kDoNotTerminateIsolate = 1 << 0, }; } // namespace StopFlags class NODE_EXTERN InitializationResult { public: virtual ~InitializationResult() = default; // Returns a suggested process exit code. virtual int exit_code() const = 0; // Returns 'true' if initialization was aborted early due to errors. virtual bool early_return() const = 0; // Returns the parsed list of non-Node.js arguments. virtual const std::vector<std::string>& args() const = 0; // Returns the parsed list of Node.js arguments. virtual const std::vector<std::string>& exec_args() const = 0; // Returns an array of errors. Note that these may be warnings // whose existence does not imply a non-zero exit code. virtual const std::vector<std::string>& errors() const = 0; // If kNoInitializeNodeV8Platform was not specified, the global Node.js // platform instance. virtual MultiIsolatePlatform* platform() const = 0; private: InitializationResult() = default; friend class InitializationResultImpl; }; // TODO(addaleax): Officially deprecate this and replace it with something // better suited for a public embedder API. NODE_EXTERN int Start(int argc, char* argv[]); // Tear down Node.js while it is running (there are active handles // in the loop and / or actively executing JavaScript code). NODE_EXTERN int Stop(Environment* env, StopFlags::Flags flags = StopFlags::kNoFlags); // Set up per-process state needed to run Node.js. This will consume arguments // from argv, fill exec_argv, and possibly add errors resulting from parsing // the arguments to `errors`. The return value is a suggested exit code for the // program; If it is 0, then initializing Node.js succeeded. // This runs a subset of the initialization performed by // InitializeOncePerProcess(), which supersedes this function. // The subset is roughly equivalent to the one given by // `ProcessInitializationFlags::kLegacyInitializeNodeWithArgsBehavior`. NODE_DEPRECATED("Use InitializeOncePerProcess() instead", NODE_EXTERN int InitializeNodeWithArgs( std::vector<std::string>* argv, std::vector<std::string>* exec_argv, std::vector<std::string>* errors, ProcessInitializationFlags::Flags flags = ProcessInitializationFlags::kNoFlags)); // Set up per-process state needed to run Node.js. This will consume arguments // from args, and return information about the initialization success, // including the arguments split into argv/exec_argv, a list of potential // errors encountered during initialization, and a potential suggested // exit code. NODE_EXTERN std::shared_ptr<InitializationResult> InitializeOncePerProcess( const std::vector<std::string>& args, ProcessInitializationFlags::Flags flags = ProcessInitializationFlags::kNoFlags); // Undoes the initialization performed by InitializeOncePerProcess(), // where cleanup is necessary. NODE_EXTERN void TearDownOncePerProcess(); // Convenience overload for specifying multiple flags without having // to worry about casts. inline std::shared_ptr<InitializationResult> InitializeOncePerProcess( const std::vector<std::string>& args, std::initializer_list<ProcessInitializationFlags::Flags> list) { uint64_t flags_accum = ProcessInitializationFlags::kNoFlags; for (const auto flag : list) flags_accum \|= static_cast<uint64_t>(flag); return InitializeOncePerProcess( args, static_cast<ProcessInitializationFlags::Flags>(flags_accum)); } enum OptionEnvvarSettings { // Allow the options to be set via the environment variable, like // `NODE_OPTIONS`. kAllowedInEnvvar = 0, // Disallow the options to be set via the environment variable, like // `NODE_OPTIONS`. kDisallowedInEnvvar = 1, // Deprecated, use kAllowedInEnvvar instead. kAllowedInEnvironment = kAllowedInEnvvar, // Deprecated, use kDisallowedInEnvvar instead. kDisallowedInEnvironment = kDisallowedInEnvvar, }; // Process the arguments and set up the per-process options. // If the `settings` is set as OptionEnvvarSettings::kAllowedInEnvvar, the // options that are allowed in the environment variable are processed. Options // that are disallowed to be set via environment variable are processed as // errors. // Otherwise all the options that are disallowed (and those are allowed) to be // set via environment variable are processed. NODE_EXTERN int ProcessGlobalArgs(std::vector<std::string>* args, std::vector<std::string>* exec_args, std::vector<std::string>* errors, OptionEnvvarSettings settings); class NodeArrayBufferAllocator; // An ArrayBuffer::Allocator class with some Node.js-specific tweaks. If you do // not have to use another allocator, using this class is recommended: // - It supports Buffer.allocUnsafe() and Buffer.allocUnsafeSlow() with // uninitialized memory. // - It supports transferring, rather than copying, ArrayBuffers when using // MessagePorts. class NODE_EXTERN ArrayBufferAllocator : public v8::ArrayBuffer::Allocator { public: // If `always_debug` is true, create an ArrayBuffer::Allocator instance // that performs additional integrity checks (e.g. make sure that only memory // that was allocated by the it is also freed by it). // This can also be set using the --debug-arraybuffer-allocations flag. static std::unique_ptr<ArrayBufferAllocator> Create( bool always_debug = false); private: virtual NodeArrayBufferAllocator* GetImpl() = 0; friend class IsolateData; }; // Legacy equivalents for ArrayBufferAllocator::Create(). NODE_EXTERN ArrayBufferAllocator* CreateArrayBufferAllocator(); NODE_EXTERN void FreeArrayBufferAllocator(ArrayBufferAllocator* allocator); class NODE_EXTERN IsolatePlatformDelegate { public: virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner() = 0; virtual bool IdleTasksEnabled() = 0; }; class NODE_EXTERN MultiIsolatePlatform : public v8::Platform { public: ~MultiIsolatePlatform() override = default; // Returns true if work was dispatched or executed. New tasks that are // posted during flushing of the queue are postponed until the next // flushing. virtual bool FlushForegroundTasks(v8::Isolate* isolate) = 0; virtual void DrainTasks(v8::Isolate* isolate) = 0; // This needs to be called between the calls to `Isolate::Allocate()` and // `Isolate::Initialize()`, so that initialization can already start // using the platform. // When using `NewIsolate()`, this is taken care of by that function. // This function may only be called once per `Isolate`. virtual void RegisterIsolate(v8::Isolate* isolate, struct uv_loop_s* loop) = 0; // This method can be used when an application handles task scheduling on its // own through `IsolatePlatformDelegate`. Upon registering an isolate with // this overload any other method in this class with the exception of // `UnregisterIsolate` must not be used on that isolate. virtual void RegisterIsolate(v8::Isolate* isolate, IsolatePlatformDelegate* delegate) = 0; // This function may only be called once per `Isolate`, and discard any // pending delayed tasks scheduled for that isolate. // This needs to be called right before calling `Isolate::Dispose()`. virtual void UnregisterIsolate(v8::Isolate* isolate) = 0; // The platform should call the passed function once all state associated // with the given isolate has been cleaned up. This can, but does not have to, // happen asynchronously. virtual void AddIsolateFinishedCallback(v8::Isolate* isolate, void (callback)(void), void* data) = 0; static std::unique_ptr<MultiIsolatePlatform> Create( int thread_pool_size, v8::TracingController* tracing_controller = nullptr, v8::PageAllocator* page_allocator = nullptr); }; enum IsolateSettingsFlags { MESSAGE_LISTENER_WITH_ERROR_LEVEL = 1 << 0, DETAILED_SOURCE_POSITIONS_FOR_PROFILING = 1 << 1, SHOULD_NOT_SET_PROMISE_REJECTION_CALLBACK = 1 << 2, SHOULD_NOT_SET_PREPARE_STACK_TRACE_CALLBACK = 1 << 3, ALLOW_MODIFY_CODE_GENERATION_FROM_STRINGS_CALLBACK = 0, /* legacy no-op / }; struct IsolateSettings { uint64_t flags = MESSAGE_LISTENER_WITH_ERROR_LEVEL \| DETAILED_SOURCE_POSITIONS_FOR_PROFILING; v8::MicrotasksPolicy policy = v8::MicrotasksPolicy::kExplicit; // Error handling callbacks v8::Isolate::AbortOnUncaughtExceptionCallback should_abort_on_uncaught_exception_callback = nullptr; v8::FatalErrorCallback fatal_error_callback = nullptr; v8::PrepareStackTraceCallback prepare_stack_trace_callback = nullptr; // Miscellaneous callbacks v8::PromiseRejectCallback promise_reject_callback = nullptr; v8::AllowWasmCodeGenerationCallback allow_wasm_code_generation_callback = nullptr; v8::ModifyCodeGenerationFromStringsCallback2 modify_code_generation_from_strings_callback = nullptr; }; // Represents a startup snapshot blob, e.g. created by passing // --node-snapshot-main=entry.js to the configure script at build time, // or by running Node.js with the --build-snapshot option. // // If used, the snapshot must* have been built with the same Node.js // version and V8 flags as the version that is currently running, and will // be rejected otherwise. // The same EmbedderSnapshotData instance must be passed to both // `NewIsolate()` and `CreateIsolateData()`. The first `Environment` instance // should be created with an empty `context` argument and will then // use the main context included in the snapshot blob. It can be retrieved // using `GetMainContext()`. `LoadEnvironment` can receive an empty // `StartExecutionCallback` in this case. // If V8 was configured with the shared-readonly-heap option, it requires // all snapshots used to create `Isolate` instances to be identical. // This option must be unset by embedders who wish to use the startup // feature during the build step by passing the --disable-shared-readonly-heap // flag to the configure script. // // The snapshot must be kept alive during the execution of the Isolate // that was created using it. // // Snapshots are an experimental feature. In particular, the embedder API // exposed through this class is subject to change or removal between Node.js // versions, including possible API and ABI breakage. class EmbedderSnapshotData { public: struct DeleteSnapshotData { void operator()(const EmbedderSnapshotData) const; }; using Pointer = std::unique_ptr<const EmbedderSnapshotData, DeleteSnapshotData>; // Return an EmbedderSnapshotData object that refers to the built-in // snapshot of Node.js. This can have been configured through e.g. // --node-snapshot-main=entry.js. static Pointer BuiltinSnapshotData(); // Return an EmbedderSnapshotData object that is based on an input file. // Calling this method will consume but not close the FILE handle. // The FILE* handle can be closed immediately following this call. // If the snapshot is invalid, this returns an empty pointer. static Pointer FromFile(FILE* in); static Pointer FromBlob(const std::vector<char>& in); static Pointer FromBlob(std::string_view in); // Write this EmbedderSnapshotData object to an output file. // Calling this method will not close the FILE* handle. // The FILE* handle can be closed immediately following this call. void ToFile(FILE* out) const; std::vector<char> ToBlob() const; // Returns whether custom snapshots can be used. Currently, this means // that V8 was configured without the shared-readonly-heap feature. static bool CanUseCustomSnapshotPerIsolate(); EmbedderSnapshotData(const EmbedderSnapshotData&) = delete; EmbedderSnapshotData& operator=(const EmbedderSnapshotData&) = delete; EmbedderSnapshotData(EmbedderSnapshotData&&) = delete; EmbedderSnapshotData& operator=(EmbedderSnapshotData&&) = delete; protected: EmbedderSnapshotData(const SnapshotData* impl, bool owns_impl); private: const SnapshotData* impl_; bool owns_impl_; friend struct SnapshotData; friend class CommonEnvironmentSetup; }; // Overriding IsolateSettings may produce unexpected behavior // in Node.js core functionality, so proceed at your own risk. NODE_EXTERN void SetIsolateUpForNode(v8::Isolate* isolate, const IsolateSettings& settings); // Set a number of callbacks for the `isolate`, in particular the Node.js // uncaught exception listener. NODE_EXTERN void SetIsolateUpForNode(v8::Isolate* isolate); // Creates a new isolate with Node.js-specific settings. // This is a convenience method equivalent to using SetIsolateCreateParams(), // Isolate::Allocate(), MultiIsolatePlatform::RegisterIsolate(), // Isolate::Initialize(), and SetIsolateUpForNode(). NODE_EXTERN v8::Isolate* NewIsolate( ArrayBufferAllocator* allocator, struct uv_loop_s* event_loop, MultiIsolatePlatform* platform, const EmbedderSnapshotData* snapshot_data = nullptr, const IsolateSettings& settings = {}); NODE_EXTERN v8::Isolate* NewIsolate( std::shared_ptr<ArrayBufferAllocator> allocator, struct uv_loop_s* event_loop, MultiIsolatePlatform* platform, const EmbedderSnapshotData* snapshot_data = nullptr, const IsolateSettings& settings = {}); // Creates a new context with Node.js-specific tweaks. NODE_EXTERN v8::Local<v8::Context> NewContext( v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> object_template = v8::Local<v8::ObjectTemplate>()); // Runs Node.js-specific tweaks on an already constructed context // Return value indicates success of operation NODE_EXTERN v8::Maybe<bool> InitializeContext(v8::Local<v8::Context> context); // If `platform` is passed, it will be used to register new Worker instances. // It can be `nullptr`, in which case creating new Workers inside of // Environments that use this `IsolateData` will not work. NODE_EXTERN IsolateData* CreateIsolateData( v8::Isolate* isolate, struct uv_loop_s* loop, MultiIsolatePlatform* platform = nullptr, ArrayBufferAllocator* allocator = nullptr, const EmbedderSnapshotData* snapshot_data = nullptr); NODE_EXTERN void FreeIsolateData(IsolateData* isolate_data); struct ThreadId { uint64_t id = static_cast<uint64_t>(-1); }; NODE_EXTERN ThreadId AllocateEnvironmentThreadId(); namespace EnvironmentFlags { enum Flags : uint64_t { kNoFlags = 0, // Use the default behaviour for Node.js instances. kDefaultFlags = 1 << 0, // Controls whether this Environment is allowed to affect per-process state // (e.g. cwd, process title, uid, etc.). // This is set when using kDefaultFlags. kOwnsProcessState = 1 << 1, // Set if this Environment instance is associated with the global inspector // handling code (i.e. listening on SIGUSR1). // This is set when using kDefaultFlags. kOwnsInspector = 1 << 2, // Set if Node.js should not run its own esm loader. This is needed by some // embedders, because it's possible for the Node.js esm loader to conflict // with another one in an embedder environment, e.g. Blink's in Chromium. kNoRegisterESMLoader = 1 << 3, // Set this flag to make Node.js track "raw" file descriptors, i.e. managed // by fs.open() and fs.close(), and close them during FreeEnvironment(). kTrackUnmanagedFds = 1 << 4, // Set this flag to force hiding console windows when spawning child // processes. This is usually used when embedding Node.js in GUI programs on // Windows. kHideConsoleWindows = 1 << 5, // Set this flag to disable loading native addons via `process.dlopen`. // This environment flag is especially important for worker threads // so that a worker thread can't load a native addon even if `execArgv` // is overwritten and `--no-addons` is not specified but was specified // for this Environment instance. kNoNativeAddons = 1 << 6, // Set this flag to disable searching modules from global paths like // $HOME/.node_modules and $NODE_PATH. This is used by standalone apps that // do not expect to have their behaviors changed because of globally // installed modules. kNoGlobalSearchPaths = 1 << 7, // Do not export browser globals like setTimeout, console, etc. kNoBrowserGlobals = 1 << 8, // Controls whether or not the Environment should call V8Inspector::create(). // This control is needed by embedders who may not want to initialize the V8 // inspector in situations where one has already been created, // e.g. Blink's in Chromium. kNoCreateInspector = 1 << 9, // Controls whether or not the InspectorAgent for this Environment should // call StartDebugSignalHandler. This control is needed by embedders who may // not want to allow other processes to start the V8 inspector. kNoStartDebugSignalHandler = 1 << 10, // Controls whether the InspectorAgent created for this Environment waits for // Inspector frontend events during the Environment creation. It's used to // call node::Stop(env) on a Worker thread that is waiting for the events. kNoWaitForInspectorFrontend = 1 << 11 }; } // namespace EnvironmentFlags enum class SnapshotFlags : uint32_t { kDefault = 0, // Whether code cache should be generated as part of the snapshot. // Code cache reduces the time spent on compiling functions included // in the snapshot at the expense of a bigger snapshot size and // potentially breaking portability of the snapshot. kWithoutCodeCache = 1 << 0, }; struct SnapshotConfig { SnapshotFlags flags = SnapshotFlags::kDefault; // When builder_script_path is std::nullopt, the snapshot is generated as a // built-in snapshot instead of a custom one, and it's expected that the // built-in snapshot only contains states that reproduce in every run of the // application. The event loop won't be run when generating a built-in // snapshot, so asynchronous operations should be avoided. // // When builder_script_path is an std::string, it should match args[1] // passed to CreateForSnapshotting(). The embedder is also expected to use // LoadEnvironment() to run a script matching this path. In that case the // snapshot is generated as a custom snapshot and the event loop is run, so // the snapshot builder can execute asynchronous operations as long as they // are run to completion when the snapshot is taken. std::optional<std::string> builder_script_path; }; struct InspectorParentHandle { virtual ~InspectorParentHandle() = default; }; // TODO(addaleax): Maybe move per-Environment options parsing here. // Returns nullptr when the Environment cannot be created e.g. there are // pending JavaScript exceptions. // `context` may be empty if an `EmbedderSnapshotData` instance was provided // to `NewIsolate()` and `CreateIsolateData()`. NODE_EXTERN Environment* CreateEnvironment( IsolateData* isolate_data, v8::Local<v8::Context> context, const std::vector<std::string>& args, const std::vector<std::string>& exec_args, EnvironmentFlags::Flags flags = EnvironmentFlags::kDefaultFlags, ThreadId thread_id = {} /* allocates a thread id automatically /, std::unique_ptr<InspectorParentHandle> inspector_parent_handle = {}); // Returns a handle that can be passed to `LoadEnvironment()`, making the // child Environment accessible to the inspector as if it were a Node.js Worker. // `child_thread_id` can be created using `AllocateEnvironmentThreadId()` // and then later passed on to `CreateEnvironment()` to create the child // Environment, together with the inspector handle. // This method should not be called while the parent Environment is active // on another thread. NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle( Environment parent_env, ThreadId child_thread_id, const char* child_url); NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle( Environment* parent_env, ThreadId child_thread_id, const char* child_url, const char* name); struct StartExecutionCallbackInfo { v8::Local<v8::Object> process_object; v8::Local<v8::Function> native_require; v8::Local<v8::Function> run_cjs; }; using StartExecutionCallback = std::function<v8::MaybeLocal<v8::Value>(const StartExecutionCallbackInfo&)>; using EmbedderPreloadCallback = std::function<void(Environment* env, v8::Local<v8::Value> process, v8::Local<v8::Value> require)>; // Run initialization for the environment. // // The \|preload\| function, usually used by embedders to inject scripts, // will be run by Node.js before Node.js executes the entry point. // The function is guaranteed to run before the user land module loader running // any user code, so it is safe to assume that at this point, no user code has // been run yet. // The function will be executed with preload(process, require), and the passed // require function has access to internal Node.js modules. There is no // stability guarantee about the internals exposed to the internal require // function. Expect breakages when updating Node.js versions if the embedder // imports internal modules with the internal require function. // Worker threads created in the environment will also respect The \|preload\| // function, so make sure the function is thread-safe. NODE_EXTERN v8::MaybeLocal<v8::Value> LoadEnvironment( Environment* env, StartExecutionCallback cb, EmbedderPreloadCallback preload = nullptr); NODE_EXTERN v8::MaybeLocal<v8::Value> LoadEnvironment( Environment* env, std::string_view main_script_source_utf8, EmbedderPreloadCallback preload = nullptr); NODE_EXTERN void FreeEnvironment(Environment* env); // Set a callback that is called when process.exit() is called from JS, // overriding the default handler. // It receives the Environment* instance and the exit code as arguments. // This could e.g. call Stop(env); in order to terminate execution and stop // the event loop. // The default handler disposes of the global V8 platform instance, if one is // being used, and calls exit(). NODE_EXTERN void SetProcessExitHandler( Environment* env, std::function<void(Environment, int)>&& handler); NODE_EXTERN void DefaultProcessExitHandler(Environment env, int exit_code); // This may return nullptr if context is not associated with a Node instance. NODE_EXTERN Environment* GetCurrentEnvironment(v8::Local<v8::Context> context); NODE_EXTERN IsolateData* GetEnvironmentIsolateData(Environment* env); NODE_EXTERN ArrayBufferAllocator* GetArrayBufferAllocator(IsolateData* data); // This is mostly useful for Environment* instances that were created through // a snapshot and have a main context that was read from that snapshot. NODE_EXTERN v8::Local<v8::Context> GetMainContext(Environment* env); [[noreturn]] NODE_EXTERN void OnFatalError(const char* location, const char* message); NODE_EXTERN void PromiseRejectCallback(v8::PromiseRejectMessage message); NODE_EXTERN bool AllowWasmCodeGenerationCallback(v8::Local<v8::Context> context, v8::Local<v8::String>); NODE_EXTERN bool ShouldAbortOnUncaughtException(v8::Isolate* isolate); NODE_EXTERN v8::MaybeLocal<v8::Value> PrepareStackTraceCallback( v8::Local<v8::Context> context, v8::Local<v8::Value> exception, v8::Local<v8::Array> trace); // Writes a diagnostic report to a file. If filename is not provided, the // default filename includes the date, time, PID, and a sequence number. // The report's JavaScript stack trace is taken from err, if present. // If isolate is nullptr, no information about the JavaScript environment // is included in the report. // Returns the filename of the written report. NODE_EXTERN std::string TriggerNodeReport(v8::Isolate* isolate, const char* message, const char* trigger, const std::string& filename, v8::Local<v8::Value> error); NODE_EXTERN std::string TriggerNodeReport(Environment* env, const char* message, const char* trigger, const std::string& filename, v8::Local<v8::Value> error); NODE_EXTERN void GetNodeReport(v8::Isolate* isolate, const char* message, const char* trigger, v8::Local<v8::Value> error, std::ostream& out); NODE_EXTERN void GetNodeReport(Environment* env, const char* message, const char* trigger, v8::Local<v8::Value> error, std::ostream& out); // This returns the MultiIsolatePlatform used for an Environment or IsolateData // instance, if one exists. NODE_EXTERN MultiIsolatePlatform* GetMultiIsolatePlatform(Environment* env); NODE_EXTERN MultiIsolatePlatform* GetMultiIsolatePlatform(IsolateData* env); NODE_DEPRECATED("Use MultiIsolatePlatform::Create() instead", NODE_EXTERN MultiIsolatePlatform* CreatePlatform( int thread_pool_size, v8::TracingController* tracing_controller)); NODE_DEPRECATED("Use MultiIsolatePlatform::Create() instead", NODE_EXTERN void FreePlatform(MultiIsolatePlatform* platform)); // Get/set the currently active tracing controller. Using CreatePlatform() // will implicitly set this by default. This is global and should be initialized // along with the v8::Platform instance that is being used. `controller` // is allowed to be `nullptr`. // This is used for tracing events from Node.js itself. V8 uses the tracing // controller returned from the active `v8::Platform` instance. NODE_EXTERN v8::TracingController* GetTracingController(); NODE_EXTERN void SetTracingController(v8::TracingController* controller); // Run `process.emit('beforeExit')` as it would usually happen when Node.js is // run in standalone mode. NODE_EXTERN v8::Maybe<bool> EmitProcessBeforeExit(Environment* env); NODE_DEPRECATED("Use Maybe version (EmitProcessBeforeExit) instead", NODE_EXTERN void EmitBeforeExit(Environment* env)); // Run `process.emit('exit')` as it would usually happen when Node.js is run // in standalone mode. The return value corresponds to the exit code. NODE_EXTERN v8::Maybe<int> EmitProcessExit(Environment* env); NODE_DEPRECATED("Use Maybe version (EmitProcessExit) instead", NODE_EXTERN int EmitExit(Environment* env)); // Runs hooks added through `AtExit()`. This is part of `FreeEnvironment()`, // so calling it manually is typically not necessary. NODE_EXTERN void RunAtExit(Environment* env); // This may return nullptr if the current v8::Context is not associated // with a Node instance. NODE_EXTERN struct uv_loop_s* GetCurrentEventLoop(v8::Isolate* isolate); // Runs the main loop for a given Environment. This roughly performs the // following steps: // 1. Call uv_run() on the event loop until it is drained. // 2. Call platform->DrainTasks() on the associated platform/isolate. // 3. If the event loop is alive again, go to Step 1. // 4. Call EmitProcessBeforeExit(). // 5. If the event loop is alive again, go to Step 1. // 6. Call EmitProcessExit() and forward the return value. // If at any point node::Stop() is called, the function will attempt to return // as soon as possible, returning an empty `Maybe`. // This function only works if `env` has an associated `MultiIsolatePlatform`. NODE_EXTERN v8::Maybe<int> SpinEventLoop(Environment* env); NODE_EXTERN std::string GetAnonymousMainPath(); class NODE_EXTERN CommonEnvironmentSetup { public: ~CommonEnvironmentSetup(); // Create a new CommonEnvironmentSetup, that is, a group of objects that // together form the typical setup for a single Node.js Environment instance. // If any error occurs, `errors` will be populated and the returned pointer // will be empty. // env_args will be passed through as arguments to CreateEnvironment(), after // `isolate_data` and `context`. template <typename... EnvironmentArgs> static std::unique_ptr<CommonEnvironmentSetup> Create( MultiIsolatePlatform platform, std::vector<std::string>* errors, EnvironmentArgs&&... env_args); template <typename... EnvironmentArgs> static std::unique_ptr<CommonEnvironmentSetup> CreateFromSnapshot( MultiIsolatePlatform* platform, std::vector<std::string>* errors, const EmbedderSnapshotData* snapshot_data, EnvironmentArgs&&... env_args); // Create an embedding setup which will be used for creating a snapshot // using CreateSnapshot(). // // This will create and attach a v8::SnapshotCreator to this instance, // and the same restrictions apply to this instance that also apply to // other V8 snapshotting environments. // Not all Node.js APIs are supported in this case. Currently, there is // no support for native/host objects other than Node.js builtins // in the snapshot. // // If the embedder wants to use LoadEnvironment() later to run a snapshot // builder script they should make sure args[1] contains the path of the // snapshot script, which will be used to create __filename and __dirname // in the context where the builder script is run. If they do not want to // include the build-time paths into the snapshot, use the string returned // by GetAnonymousMainPath() as args[1] to anonymize the script. // // Snapshots are an experimental feature. In particular, the embedder API // exposed through this class is subject to change or removal between Node.js // versions, including possible API and ABI breakage. static std::unique_ptr<CommonEnvironmentSetup> CreateForSnapshotting( MultiIsolatePlatform* platform, std::vector<std::string>* errors, const std::vector<std::string>& args = {}, const std::vector<std::string>& exec_args = {}, const SnapshotConfig& snapshot_config = {}); EmbedderSnapshotData::Pointer CreateSnapshot(); struct uv_loop_s* event_loop() const; v8::SnapshotCreator* snapshot_creator(); // Empty for snapshotting environments. std::shared_ptr<ArrayBufferAllocator> array_buffer_allocator() const; v8::Isolate* isolate() const; IsolateData* isolate_data() const; Environment* env() const; v8::Local<v8::Context> context() const; CommonEnvironmentSetup(const CommonEnvironmentSetup&) = delete; CommonEnvironmentSetup& operator=(const CommonEnvironmentSetup&) = delete; CommonEnvironmentSetup(CommonEnvironmentSetup&&) = delete; CommonEnvironmentSetup& operator=(CommonEnvironmentSetup&&) = delete; private: enum Flags : uint32_t { kNoFlags = 0, kIsForSnapshotting = 1, }; struct Impl; Impl* impl_; CommonEnvironmentSetup( MultiIsolatePlatform, std::vector<std::string>, std::function<Environment(const CommonEnvironmentSetup)>); CommonEnvironmentSetup( MultiIsolatePlatform, std::vector<std::string>, const EmbedderSnapshotData, uint32_t flags, std::function<Environment(const CommonEnvironmentSetup)>, const SnapshotConfig config = nullptr); }; // Implementation for CommonEnvironmentSetup::Create template <typename... EnvironmentArgs> std::unique_ptr<CommonEnvironmentSetup> CommonEnvironmentSetup::Create( MultiIsolatePlatform* platform, std::vector<std::string>* errors, EnvironmentArgs&&... env_args) { auto ret = std::unique_ptr<CommonEnvironmentSetup>(new CommonEnvironmentSetup( platform, errors, [&](const CommonEnvironmentSetup* setup) -> Environment* { return CreateEnvironment( setup->isolate_data(), setup->context(), std::forward<EnvironmentArgs>(env_args)...); })); if (!errors->empty()) ret.reset(); return ret; } // Implementation for ::CreateFromSnapshot -- the ::Create() method // could call this with a nullptr snapshot_data in a major version. template <typename... EnvironmentArgs> std::unique_ptr<CommonEnvironmentSetup> CommonEnvironmentSetup::CreateFromSnapshot( MultiIsolatePlatform* platform, std::vector<std::string>* errors, const EmbedderSnapshotData* snapshot_data, EnvironmentArgs&&... env_args) { auto ret = std::unique_ptr<CommonEnvironmentSetup>(new CommonEnvironmentSetup( platform, errors, snapshot_data, Flags::kNoFlags, [&](const CommonEnvironmentSetup* setup) -> Environment* { return CreateEnvironment(setup->isolate_data(), setup->context(), std::forward<EnvironmentArgs>(env_args)...); })); if (!errors->empty()) ret.reset(); return ret; } /* Converts a unixtime to V8 Date / NODE_DEPRECATED("Use v8::Date::New() directly", inline v8::Local<v8::Value> NODE_UNIXTIME_V8(double time) { return v8::Date::New( v8::Isolate::GetCurrent()->GetCurrentContext(), 1000 time) .ToLocalChecked(); }) #define NODE_UNIXTIME_V8 node::NODE_UNIXTIME_V8 NODE_DEPRECATED("Use v8::Date::ValueOf() directly", inline double NODE_V8_UNIXTIME(v8::Local<v8::Date> date) { return date->ValueOf() / 1000; }) #define NODE_V8_UNIXTIME node::NODE_V8_UNIXTIME #define NODE_DEFINE_CONSTANT(target, constant) \ do { \ v8::Isolate* isolate = target->GetIsolate(); \ v8::Local<v8::Context> context = isolate->GetCurrentContext(); \ v8::Local<v8::String> constant_name = v8::String::NewFromUtf8Literal( \ isolate, #constant, v8::NewStringType::kInternalized); \ v8::Local<v8::Number> constant_value = \ v8::Number::New(isolate, static_cast<double>(constant)); \ v8::PropertyAttribute constant_attributes = \ static_cast<v8::PropertyAttribute>(v8::ReadOnly \| v8::DontDelete); \ (target) \ ->DefineOwnProperty( \ context, constant_name, constant_value, constant_attributes) \ .Check(); \ } while (0) #define NODE_DEFINE_HIDDEN_CONSTANT(target, constant) \ do { \ v8::Isolate* isolate = target->GetIsolate(); \ v8::Local<v8::Context> context = isolate->GetCurrentContext(); \ v8::Local<v8::String> constant_name = v8::String::NewFromUtf8Literal( \ isolate, #constant, v8::NewStringType::kInternalized); \ v8::Local<v8::Number> constant_value = \ v8::Number::New(isolate, static_cast<double>(constant)); \ v8::PropertyAttribute constant_attributes = \ static_cast<v8::PropertyAttribute>(v8::ReadOnly \| v8::DontDelete \| \ v8::DontEnum); \ (target) \ ->DefineOwnProperty( \ context, constant_name, constant_value, constant_attributes) \ .Check(); \ } while (0) // Used to be a macro, hence the uppercase name. inline void NODE_SET_METHOD(v8::Local<v8::Template> recv, const char* name, v8::FunctionCallback callback) { v8::Isolate* isolate = v8::Isolate::GetCurrent(); v8::HandleScope handle_scope(isolate); v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate, callback); v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized).ToLocalChecked(); t->SetClassName(fn_name); recv->Set(fn_name, t); } // Used to be a macro, hence the uppercase name. inline void NODE_SET_METHOD(v8::Local<v8::Object> recv, const char* name, v8::FunctionCallback callback) { v8::Isolate* isolate = v8::Isolate::GetCurrent(); v8::HandleScope handle_scope(isolate); v8::Local<v8::Context> context = isolate->GetCurrentContext(); v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate, callback); v8::Local<v8::Function> fn = t->GetFunction(context).ToLocalChecked(); v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized).ToLocalChecked(); fn->SetName(fn_name); recv->Set(context, fn_name, fn).Check(); } #define NODE_SET_METHOD node::NODE_SET_METHOD // Used to be a macro, hence the uppercase name. // Not a template because it only makes sense for FunctionTemplates. inline void NODE_SET_PROTOTYPE_METHOD(v8::Local<v8::FunctionTemplate> recv, const char* name, v8::FunctionCallback callback) { v8::Isolate* isolate = v8::Isolate::GetCurrent(); v8::HandleScope handle_scope(isolate); v8::Local<v8::Signature> s = v8::Signature::New(isolate, recv); v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate, callback, v8::Local<v8::Value>(), s); v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized).ToLocalChecked(); t->SetClassName(fn_name); recv->PrototypeTemplate()->Set(fn_name, t); } #define NODE_SET_PROTOTYPE_METHOD node::NODE_SET_PROTOTYPE_METHOD // BINARY is a deprecated alias of LATIN1. // BASE64URL is not currently exposed to the JavaScript side. enum encoding { ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER, BASE64URL, LATIN1 = BINARY }; NODE_EXTERN enum encoding ParseEncoding( v8::Isolate* isolate, v8::Local<v8::Value> encoding_v, enum encoding default_encoding = LATIN1); NODE_EXTERN void FatalException(v8::Isolate* isolate, const v8::TryCatch& try_catch); NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate, const char* buf, size_t len, enum encoding encoding = LATIN1); // Warning: This reverses endianness on Big Endian platforms, even though the // signature using uint16_t implies that it should not. NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate, const uint16_t* buf, size_t len); // Returns -1 if the handle was not valid for decoding NODE_EXTERN ssize_t DecodeBytes(v8::Isolate* isolate, v8::Local<v8::Value>, enum encoding encoding = LATIN1); // returns bytes written. NODE_EXTERN ssize_t DecodeWrite(v8::Isolate* isolate, char* buf, size_t buflen, v8::Local<v8::Value>, enum encoding encoding = LATIN1); #ifdef _WIN32 NODE_EXTERN v8::Local<v8::Value> WinapiErrnoException( v8::Isolate* isolate, int errorno, const char* syscall = nullptr, const char* msg = "", const char* path = nullptr); #endif const char* signo_string(int errorno); typedef void (addon_register_func)( v8::Local<v8::Object> exports, v8::Local<v8::Value> module, void priv); typedef void (addon_context_register_func)( v8::Local<v8::Object> exports, v8::Local<v8::Value> module, v8::Local<v8::Context> context, void priv); enum ModuleFlags { kLinked = 0x02 }; struct node_module { int nm_version; unsigned int nm_flags; void* nm_dso_handle; const char* nm_filename; node::addon_register_func nm_register_func; node::addon_context_register_func nm_context_register_func; const char* nm_modname; void* nm_priv; struct node_module* nm_link; }; extern "C" NODE_EXTERN void node_module_register(void* mod); #ifdef _WIN32 # define NODE_MODULE_EXPORT __declspec(dllexport) #else # define NODE_MODULE_EXPORT __attribute__((visibility("default"))) #endif #ifdef NODE_SHARED_MODE # define NODE_CTOR_PREFIX #else # define NODE_CTOR_PREFIX static #endif #if defined(_MSC_VER) #define NODE_C_CTOR(fn) \ NODE_CTOR_PREFIX void __cdecl fn(void); \ namespace { \ struct fn##_ { \ fn##_() { fn(); }; \ } fn##_v_; \ } \ NODE_CTOR_PREFIX void __cdecl fn(void) #else #define NODE_C_CTOR(fn) \ NODE_CTOR_PREFIX void fn(void) __attribute__((constructor)); \ NODE_CTOR_PREFIX void fn(void) #endif #define NODE_MODULE_X(modname, regfunc, priv, flags) \ extern "C" { \ static node::node_module _module = \ { \ NODE_MODULE_VERSION, \ flags, \ NULL, /* NOLINT (readability/null_usage) / \ __FILE__, \ (node::addon_register_func) (regfunc), \ NULL, / NOLINT (readability/null_usage) / \ NODE_STRINGIFY(modname), \ priv, \ NULL / NOLINT (readability/null_usage) / \ }; \ NODE_C_CTOR(_register_ ## modname) { \ node_module_register(&_module); \ } \ } #define NODE_MODULE_CONTEXT_AWARE_X(modname, regfunc, priv, flags) \ extern "C" { \ static node::node_module _module = \ { \ NODE_MODULE_VERSION, \ flags, \ NULL, / NOLINT (readability/null_usage) / \ __FILE__, \ NULL, / NOLINT (readability/null_usage) / \ (node::addon_context_register_func) (regfunc), \ NODE_STRINGIFY(modname), \ priv, \ NULL / NOLINT (readability/null_usage) / \ }; \ NODE_C_CTOR(_register_ ## modname) { \ node_module_register(&_module); \ } \ } // Usage: `NODE_MODULE(NODE_GYP_MODULE_NAME, InitializerFunction)` // If no NODE_MODULE is declared, Node.js looks for the well-known // symbol `node_register_module_v${NODE_MODULE_VERSION}`. #define NODE_MODULE(modname, regfunc) \ NODE_MODULE_X(modname, regfunc, NULL, 0) // NOLINT (readability/null_usage) #define NODE_MODULE_CONTEXT_AWARE(modname, regfunc) \ / NOLINTNEXTLINE (readability/null_usage) / \ NODE_MODULE_CONTEXT_AWARE_X(modname, regfunc, NULL, 0) // Embedders can use this type of binding for statically linked native bindings. // It is used the same way addon bindings are used, except that linked bindings // can be accessed through `process._linkedBinding(modname)`. #define NODE_MODULE_LINKED(modname, regfunc) \ / NOLINTNEXTLINE (readability/null_usage) / \ NODE_MODULE_CONTEXT_AWARE_X(modname, regfunc, NULL, \ node::ModuleFlags::kLinked) / * For backward compatibility in add-on modules. / #define NODE_MODULE_DECL / nothing / #define NODE_MODULE_INITIALIZER_BASE node_register_module_v #define NODE_MODULE_INITIALIZER_X(base, version) \ NODE_MODULE_INITIALIZER_X_HELPER(base, version) #define NODE_MODULE_INITIALIZER_X_HELPER(base, version) base##version #define NODE_MODULE_INITIALIZER \ NODE_MODULE_INITIALIZER_X(NODE_MODULE_INITIALIZER_BASE, \ NODE_MODULE_VERSION) #define NODE_MODULE_INIT() \ extern "C" NODE_MODULE_EXPORT void \ NODE_MODULE_INITIALIZER(v8::Local<v8::Object> exports, \ v8::Local<v8::Value> module, \ v8::Local<v8::Context> context); \ NODE_MODULE_CONTEXT_AWARE(NODE_GYP_MODULE_NAME, \ NODE_MODULE_INITIALIZER) \ void NODE_MODULE_INITIALIZER(v8::Local<v8::Object> exports, \ v8::Local<v8::Value> module, \ v8::Local<v8::Context> context) // Allows embedders to add a binding to the current Environment that can be // accessed through process._linkedBinding() in the target Environment and all // Worker threads that it creates. // In each variant, the registration function needs to be usable at least for // the time during which the Environment exists. NODE_EXTERN void AddLinkedBinding(Environment* env, const node_module& mod); NODE_EXTERN void AddLinkedBinding(Environment* env, const struct napi_module& mod); NODE_EXTERN void AddLinkedBinding(Environment* env, const char* name, addon_context_register_func fn, void* priv); NODE_EXTERN void AddLinkedBinding( Environment* env, const char* name, napi_addon_register_func fn, int32_t module_api_version = NODE_API_DEFAULT_MODULE_API_VERSION); /* Registers a callback with the passed-in Environment instance. The callback * is called after the event loop exits, but before the VM is disposed. * Callbacks are run in reverse order of registration, i.e. newest first. / NODE_EXTERN void AtExit(Environment env, void (cb)(void arg), void* arg); typedef double async_id; struct async_context { ::node::async_id async_id; ::node::async_id trigger_async_id; }; /* This is a lot like node::AtExit, except that the hooks added via this * function are run before the AtExit ones and will always be registered * for the current Environment instance. * These functions are safe to use in an addon supporting multiple * threads/isolates. / NODE_EXTERN void AddEnvironmentCleanupHook(v8::Isolate isolate, void (fun)(void arg), void* arg); NODE_EXTERN void RemoveEnvironmentCleanupHook(v8::Isolate* isolate, void (fun)(void arg), void* arg); /* These are async equivalents of the above. After the cleanup hook is invoked, * `cb(cbarg)` must be called, and attempting to remove the cleanup hook will * have no effect. / struct ACHHandle; struct NODE_EXTERN DeleteACHHandle { void operator()(ACHHandle) const; }; typedef std::unique_ptr<ACHHandle, DeleteACHHandle> AsyncCleanupHookHandle; /* This function is not intended to be used externally, it exists to aid in * keeping ABI compatibility between Node and Electron. / NODE_EXTERN ACHHandle AddEnvironmentCleanupHookInternal( v8::Isolate* isolate, void (fun)(void arg, void (cb)(void), void* cbarg), void* arg); inline AsyncCleanupHookHandle AddEnvironmentCleanupHook( v8::Isolate* isolate, void (fun)(void arg, void (cb)(void), void* cbarg), void* arg) { return AsyncCleanupHookHandle(AddEnvironmentCleanupHookInternal(isolate, fun, arg)); } /* This function is not intended to be used externally, it exists to aid in * keeping ABI compatibility between Node and Electron. / NODE_EXTERN void RemoveEnvironmentCleanupHookInternal(ACHHandle holder); inline void RemoveEnvironmentCleanupHook(AsyncCleanupHookHandle holder) { RemoveEnvironmentCleanupHookInternal(holder.get()); } // This behaves like V8's Isolate::RequestInterrupt(), but also wakes up // the event loop if it is currently idle. Interrupt requests are drained // in `FreeEnvironment()`. The passed callback can not call back into // JavaScript. // This function can be called from any thread. NODE_EXTERN void RequestInterrupt(Environment* env, void (fun)(void arg), void* arg); /* Returns the id of the current execution context. If the return value is * zero then no execution has been set. This will happen if the user handles * I/O from native code. / NODE_EXTERN async_id AsyncHooksGetExecutionAsyncId(v8::Isolate isolate); /* Return same value as async_hooks.triggerAsyncId(); / NODE_EXTERN async_id AsyncHooksGetTriggerAsyncId(v8::Isolate isolate); /* If the native API doesn't inherit from the helper class then the callbacks * must be triggered manually. This triggers the init() callback. The return * value is the async id assigned to the resource. * * The `trigger_async_id` parameter should correspond to the resource which is * creating the new resource, which will usually be the return value of * `AsyncHooksGetTriggerAsyncId()`. / NODE_EXTERN async_context EmitAsyncInit(v8::Isolate isolate, v8::Local<v8::Object> resource, const char* name, async_id trigger_async_id = -1); NODE_EXTERN async_context EmitAsyncInit(v8::Isolate* isolate, v8::Local<v8::Object> resource, v8::Local<v8::String> name, async_id trigger_async_id = -1); /* Emit the destroy() callback. The overload taking an `Environment` argument should be used when the Isolate’s current Context is not associated with * a Node.js Environment, or when there is no current Context, for example * when calling this function during garbage collection. In that case, the * `Environment` value should have been acquired previously, e.g. through `GetCurrentEnvironment()`. / NODE_EXTERN void EmitAsyncDestroy(v8::Isolate isolate, async_context asyncContext); NODE_EXTERN void EmitAsyncDestroy(Environment* env, async_context asyncContext); class InternalCallbackScope; /* This class works like `MakeCallback()` in that it sets up a specific * asyncContext as the current one and informs the async_hooks and domains * modules that this context is currently active. * * `MakeCallback()` is a wrapper around this class as well as * `Function::Call()`. Either one of these mechanisms needs to be used for * top-level calls into JavaScript (i.e. without any existing JS stack). * * This object should be stack-allocated to ensure that it is contained in a * valid HandleScope. * * Exceptions happening within this scope will be treated like uncaught * exceptions. If this behaviour is undesirable, a new `v8::TryCatch` scope * needs to be created inside of this scope. / class NODE_EXTERN CallbackScope { public: CallbackScope(v8::Isolate isolate, v8::Local<v8::Object> resource, async_context asyncContext); CallbackScope(Environment* env, v8::Local<v8::Object> resource, async_context asyncContext); ~CallbackScope(); void operator=(const CallbackScope&) = delete; void operator=(CallbackScope&&) = delete; CallbackScope(const CallbackScope&) = delete; CallbackScope(CallbackScope&&) = delete; private: InternalCallbackScope* private_; v8::TryCatch try_catch_; }; /* An API specific to emit before/after callbacks is unnecessary because * MakeCallback will automatically call them for you. * * These methods may create handles on their own, so run them inside a * HandleScope. * * `asyncId` and `triggerAsyncId` should correspond to the values returned by * `EmitAsyncInit()` and `AsyncHooksGetTriggerAsyncId()`, respectively, when the * invoking resource was created. If these values are unknown, 0 can be passed. * / NODE_EXTERN v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate isolate, v8::Local<v8::Object> recv, v8::Local<v8::Function> callback, int argc, v8::Local<v8::Value>* argv, async_context asyncContext); NODE_EXTERN v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate, v8::Local<v8::Object> recv, const char* method, int argc, v8::Local<v8::Value>* argv, async_context asyncContext); NODE_EXTERN v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate, v8::Local<v8::Object> recv, v8::Local<v8::String> symbol, int argc, v8::Local<v8::Value>* argv, async_context asyncContext); /* Helper class users can optionally inherit from. If * `AsyncResource::MakeCallback()` is used, then all four callbacks will be * called automatically. / class NODE_EXTERN AsyncResource { public: AsyncResource(v8::Isolate isolate, v8::Local<v8::Object> resource, const char* name, async_id trigger_async_id = -1); virtual ~AsyncResource(); AsyncResource(const AsyncResource&) = delete; void operator=(const AsyncResource&) = delete; v8::MaybeLocal<v8::Value> MakeCallback( v8::Local<v8::Function> callback, int argc, v8::Local<v8::Value>* argv); v8::MaybeLocal<v8::Value> MakeCallback( const char* method, int argc, v8::Local<v8::Value>* argv); v8::MaybeLocal<v8::Value> MakeCallback( v8::Local<v8::String> symbol, int argc, v8::Local<v8::Value>* argv); v8::Local<v8::Object> get_resource(); async_id get_async_id() const; async_id get_trigger_async_id() const; protected: class NODE_EXTERN CallbackScope : public node::CallbackScope { public: explicit CallbackScope(AsyncResource* res); }; private: Environment* env_; v8::Global<v8::Object> resource_; async_context async_context_; }; #ifndef _WIN32 // Register a signal handler without interrupting any handlers that node // itself needs. This does override handlers registered through // process.on('SIG...', function() { ... }). The `reset_handler` flag indicates // whether the signal handler for the given signal should be reset to its // default value before executing the handler (i.e. it works like SA_RESETHAND). // The `reset_handler` flag is invalid when `signal` is SIGSEGV. NODE_EXTERN void RegisterSignalHandler(int signal, void (handler)(int signal, siginfo_t info, void* ucontext), bool reset_handler = false); #endif // _WIN32 // Configure the layout of the JavaScript object with a cppgc::GarbageCollected // instance so that when the JavaScript object is reachable, the garbage // collected instance would have its Trace() method invoked per the cppgc // contract. To make it work, the process must have called // cppgc::InitializeProcess() before, which is usually the case for addons // loaded by the stand-alone Node.js executable. Embedders of Node.js can use // either need to call it themselves or make sure that // ProcessInitializationFlags::kNoInitializeCppgc is not set for cppgc to // work. // If the CppHeap is owned by Node.js, which is usually the case for addon, // the object must be created with at least two internal fields available, // and the first two internal fields would be configured by Node.js. // This may be superseded by a V8 API in the future, see // https://bugs.chromium.org/p/v8/issues/detail?id=13960. Until then this // serves as a helper for Node.js isolates. NODE_EXTERN void SetCppgcReference(v8::Isolate* isolate, v8::Local<v8::Object> object, void* wrappable); } // namespace node #endif // SRC_NODE_H_	67.12 KB	2025-03-03 12:36
📄 node_api.h #ifndef SRC_NODE_API_H_ #define SRC_NODE_API_H_ #if defined(BUILDING_NODE_EXTENSION) && !defined(NAPI_EXTERN) #ifdef _WIN32 // Building native addon against node #define NAPI_EXTERN __declspec(dllimport) #elif defined(__wasm__) #define NAPI_EXTERN __attribute__((__import_module__("napi"))) #endif #endif #include "js_native_api.h" #include "node_api_types.h" struct uv_loop_s; // Forward declaration. #ifdef _WIN32 #define NAPI_MODULE_EXPORT __declspec(dllexport) #else #ifdef __EMSCRIPTEN__ #define NAPI_MODULE_EXPORT \ __attribute__((visibility("default"))) __attribute__((used)) #else #define NAPI_MODULE_EXPORT __attribute__((visibility("default"))) #endif #endif #if defined(__GNUC__) #define NAPI_NO_RETURN __attribute__((noreturn)) #elif defined(_WIN32) #define NAPI_NO_RETURN __declspec(noreturn) #else #define NAPI_NO_RETURN #endif typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env, napi_value exports); typedef int32_t(NAPI_CDECL* node_api_addon_get_api_version_func)(void); // Used by deprecated registration method napi_module_register. typedef struct napi_module { int nm_version; unsigned int nm_flags; const char* nm_filename; napi_addon_register_func nm_register_func; const char* nm_modname; void* nm_priv; void* reserved[4]; } napi_module; #define NAPI_MODULE_VERSION 1 #define NAPI_MODULE_INITIALIZER_X(base, version) \ NAPI_MODULE_INITIALIZER_X_HELPER(base, version) #define NAPI_MODULE_INITIALIZER_X_HELPER(base, version) base##version #ifdef __wasm__ #define NAPI_MODULE_INITIALIZER_BASE napi_register_wasm_v #else #define NAPI_MODULE_INITIALIZER_BASE napi_register_module_v #endif #define NODE_API_MODULE_GET_API_VERSION_BASE node_api_module_get_api_version_v #define NAPI_MODULE_INITIALIZER \ NAPI_MODULE_INITIALIZER_X(NAPI_MODULE_INITIALIZER_BASE, NAPI_MODULE_VERSION) #define NODE_API_MODULE_GET_API_VERSION \ NAPI_MODULE_INITIALIZER_X(NODE_API_MODULE_GET_API_VERSION_BASE, \ NAPI_MODULE_VERSION) #define NAPI_MODULE_INIT() \ EXTERN_C_START \ NAPI_MODULE_EXPORT int32_t NODE_API_MODULE_GET_API_VERSION(void) { \ return NAPI_VERSION; \ } \ NAPI_MODULE_EXPORT napi_value NAPI_MODULE_INITIALIZER(napi_env env, \ napi_value exports); \ EXTERN_C_END \ napi_value NAPI_MODULE_INITIALIZER(napi_env env, napi_value exports) #define NAPI_MODULE(modname, regfunc) \ NAPI_MODULE_INIT() { return regfunc(env, exports); } // Deprecated. Use NAPI_MODULE. #define NAPI_MODULE_X(modname, regfunc, priv, flags) \ NAPI_MODULE(modname, regfunc) EXTERN_C_START // Deprecated. Replaced by symbol-based registration defined by NAPI_MODULE // and NAPI_MODULE_INIT macros. NAPI_EXTERN void NAPI_CDECL napi_module_register(napi_module* mod); NAPI_EXTERN NAPI_NO_RETURN void NAPI_CDECL napi_fatal_error(const char* location, size_t location_len, const char* message, size_t message_len); // Methods for custom handling of async operations NAPI_EXTERN napi_status NAPI_CDECL napi_async_init(napi_env env, napi_value async_resource, napi_value async_resource_name, napi_async_context* result); NAPI_EXTERN napi_status NAPI_CDECL napi_async_destroy(napi_env env, napi_async_context async_context); NAPI_EXTERN napi_status NAPI_CDECL napi_make_callback(napi_env env, napi_async_context async_context, napi_value recv, napi_value func, size_t argc, const napi_value* argv, napi_value* result); // Methods to provide node::Buffer functionality with napi types NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer(napi_env env, size_t length, void** data, napi_value* result); #ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED NAPI_EXTERN napi_status NAPI_CDECL napi_create_external_buffer(napi_env env, size_t length, void* data, node_api_basic_finalize finalize_cb, void* finalize_hint, napi_value* result); #endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED #if NAPI_VERSION >= 10 NAPI_EXTERN napi_status NAPI_CDECL node_api_create_buffer_from_arraybuffer(napi_env env, napi_value arraybuffer, size_t byte_offset, size_t byte_length, napi_value* result); #endif // NAPI_VERSION >= 10 NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer_copy(napi_env env, size_t length, const void* data, void** result_data, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_is_buffer(napi_env env, napi_value value, bool* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_buffer_info(napi_env env, napi_value value, void** data, size_t* length); // Methods to manage simple async operations NAPI_EXTERN napi_status NAPI_CDECL napi_create_async_work(napi_env env, napi_value async_resource, napi_value async_resource_name, napi_async_execute_callback execute, napi_async_complete_callback complete, void* data, napi_async_work* result); NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env, napi_async_work work); NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_basic_env env, napi_async_work work); NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(node_api_basic_env env, napi_async_work work); // version management NAPI_EXTERN napi_status NAPI_CDECL napi_get_node_version( node_api_basic_env env, const napi_node_version version); #if NAPI_VERSION >= 2 // Return the current libuv event loop for a given environment NAPI_EXTERN napi_status NAPI_CDECL napi_get_uv_event_loop(node_api_basic_env env, struct uv_loop_s loop); #endif // NAPI_VERSION >= 2 #if NAPI_VERSION >= 3 NAPI_EXTERN napi_status NAPI_CDECL napi_fatal_exception(napi_env env, napi_value err); NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook( node_api_basic_env env, napi_cleanup_hook fun, void* arg); NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook( node_api_basic_env env, napi_cleanup_hook fun, void* arg); NAPI_EXTERN napi_status NAPI_CDECL napi_open_callback_scope(napi_env env, napi_value resource_object, napi_async_context context, napi_callback_scope* result); NAPI_EXTERN napi_status NAPI_CDECL napi_close_callback_scope(napi_env env, napi_callback_scope scope); #endif // NAPI_VERSION >= 3 #if NAPI_VERSION >= 4 // Calling into JS from other threads NAPI_EXTERN napi_status NAPI_CDECL napi_create_threadsafe_function(napi_env env, napi_value func, napi_value async_resource, napi_value async_resource_name, size_t max_queue_size, size_t initial_thread_count, void* thread_finalize_data, napi_finalize thread_finalize_cb, void* context, napi_threadsafe_function_call_js call_js_cb, napi_threadsafe_function* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_threadsafe_function_context( napi_threadsafe_function func, void** result); NAPI_EXTERN napi_status NAPI_CDECL napi_call_threadsafe_function(napi_threadsafe_function func, void* data, napi_threadsafe_function_call_mode is_blocking); NAPI_EXTERN napi_status NAPI_CDECL napi_acquire_threadsafe_function(napi_threadsafe_function func); NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function( napi_threadsafe_function func, napi_threadsafe_function_release_mode mode); NAPI_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function( node_api_basic_env env, napi_threadsafe_function func); NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function( node_api_basic_env env, napi_threadsafe_function func); #endif // NAPI_VERSION >= 4 #if NAPI_VERSION >= 8 NAPI_EXTERN napi_status NAPI_CDECL napi_add_async_cleanup_hook(node_api_basic_env env, napi_async_cleanup_hook hook, void* arg, napi_async_cleanup_hook_handle* remove_handle); NAPI_EXTERN napi_status NAPI_CDECL napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle); #endif // NAPI_VERSION >= 8 #if NAPI_VERSION >= 9 NAPI_EXTERN napi_status NAPI_CDECL node_api_get_module_file_name(node_api_basic_env env, const char** result); #endif // NAPI_VERSION >= 9 EXTERN_C_END #endif // SRC_NODE_API_H_	10.34 KB	2025-03-03 12:36
📄 node_api_types.h #ifndef SRC_NODE_API_TYPES_H_ #define SRC_NODE_API_TYPES_H_ #include "js_native_api_types.h" typedef struct napi_callback_scope__* napi_callback_scope; typedef struct napi_async_context__* napi_async_context; typedef struct napi_async_work__* napi_async_work; #if NAPI_VERSION >= 3 typedef void(NAPI_CDECL* napi_cleanup_hook)(void* arg); #endif // NAPI_VERSION >= 3 #if NAPI_VERSION >= 4 typedef struct napi_threadsafe_function__* napi_threadsafe_function; #endif // NAPI_VERSION >= 4 #if NAPI_VERSION >= 4 typedef enum { napi_tsfn_release, napi_tsfn_abort } napi_threadsafe_function_release_mode; typedef enum { napi_tsfn_nonblocking, napi_tsfn_blocking } napi_threadsafe_function_call_mode; #endif // NAPI_VERSION >= 4 typedef void(NAPI_CDECL* napi_async_execute_callback)(napi_env env, void* data); typedef void(NAPI_CDECL* napi_async_complete_callback)(napi_env env, napi_status status, void* data); #if NAPI_VERSION >= 4 typedef void(NAPI_CDECL* napi_threadsafe_function_call_js)( napi_env env, napi_value js_callback, void* context, void* data); #endif // NAPI_VERSION >= 4 typedef struct { uint32_t major; uint32_t minor; uint32_t patch; const char* release; } napi_node_version; #if NAPI_VERSION >= 8 typedef struct napi_async_cleanup_hook_handle__* napi_async_cleanup_hook_handle; typedef void(NAPI_CDECL* napi_async_cleanup_hook)( napi_async_cleanup_hook_handle handle, void* data); #endif // NAPI_VERSION >= 8 #endif // SRC_NODE_API_TYPES_H_	1.57 KB	2025-03-03 12:36
📄 node_buffer.h // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. #ifndef SRC_NODE_BUFFER_H_ #define SRC_NODE_BUFFER_H_ #include "node.h" #include "v8.h" namespace node { namespace Buffer { static const size_t kMaxLength = v8::Uint8Array::kMaxLength; typedef void (FreeCallback)(char data, void* hint); NODE_EXTERN bool HasInstance(v8::Local<v8::Value> val); NODE_EXTERN bool HasInstance(v8::Local<v8::Object> val); NODE_EXTERN char* Data(v8::Local<v8::Value> val); NODE_EXTERN char* Data(v8::Local<v8::Object> val); NODE_EXTERN size_t Length(v8::Local<v8::Value> val); NODE_EXTERN size_t Length(v8::Local<v8::Object> val); // public constructor - data is copied NODE_EXTERN v8::MaybeLocal<v8::Object> Copy(v8::Isolate* isolate, const char* data, size_t len); // public constructor NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate, size_t length); // public constructor from string NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate, v8::Local<v8::String> string, enum encoding enc = UTF8); // public constructor - data is used, callback is passed data on object gc NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate, char* data, size_t length, FreeCallback callback, void* hint); // public constructor - data is used. NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate, char* data, size_t len); // Creates a Buffer instance over an existing ArrayBuffer. NODE_EXTERN v8::MaybeLocal<v8::Uint8Array> New(v8::Isolate* isolate, v8::Local<v8::ArrayBuffer> ab, size_t byte_offset, size_t length); // This is verbose to be explicit with inline commenting static inline bool IsWithinBounds(size_t off, size_t len, size_t max) { // Asking to seek too far into the buffer // check to avoid wrapping in subsequent subtraction if (off > max) return false; // Asking for more than is left over in the buffer if (max - off < len) return false; // Otherwise we're in bounds return true; } } // namespace Buffer } // namespace node #endif // SRC_NODE_BUFFER_H_	3.6 KB	2025-03-03 12:36
📄 node_object_wrap.h // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. #ifndef SRC_NODE_OBJECT_WRAP_H_ #define SRC_NODE_OBJECT_WRAP_H_ #include "v8.h" #include <cassert> namespace node { class ObjectWrap { public: ObjectWrap() { refs_ = 0; } virtual ~ObjectWrap() { if (persistent().IsEmpty()) return; persistent().ClearWeak(); persistent().Reset(); } template <class T> static inline T* Unwrap(v8::Local<v8::Object> handle) { assert(!handle.IsEmpty()); assert(handle->InternalFieldCount() > 0); // Cast to ObjectWrap before casting to T. A direct cast from void // to T won't work right when T has more than one base class. void* ptr = handle->GetAlignedPointerFromInternalField(0); ObjectWrap* wrap = static_cast<ObjectWrap>(ptr); return static_cast<T>(wrap); } inline v8::Local<v8::Object> handle() { return handle(v8::Isolate::GetCurrent()); } inline v8::Local<v8::Object> handle(v8::Isolate* isolate) { return v8::Local<v8::Object>::New(isolate, persistent()); } // NOLINTNEXTLINE(runtime/v8_persistent) inline v8::Persistent<v8::Object>& persistent() { return handle_; } protected: inline void Wrap(v8::Local<v8::Object> handle) { assert(persistent().IsEmpty()); assert(handle->InternalFieldCount() > 0); handle->SetAlignedPointerInInternalField(0, this); persistent().Reset(v8::Isolate::GetCurrent(), handle); MakeWeak(); } inline void MakeWeak() { persistent().SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter); } /* Ref() marks the object as being attached to an event loop. * Refed objects will not be garbage collected, even if * all references are lost. / virtual void Ref() { assert(!persistent().IsEmpty()); persistent().ClearWeak(); refs_++; } / Unref() marks an object as detached from the event loop. This is its * default state. When an object with a "weak" reference changes from * attached to detached state it will be freed. Be careful not to access * the object after making this call as it might be gone! * (A "weak reference" means an object that only has a * persistent handle.) * * DO NOT CALL THIS FROM DESTRUCTOR / virtual void Unref() { assert(!persistent().IsEmpty()); assert(!persistent().IsWeak()); assert(refs_ > 0); if (--refs_ == 0) MakeWeak(); } int refs_; // ro private: static void WeakCallback( const v8::WeakCallbackInfo<ObjectWrap>& data) { ObjectWrap wrap = data.GetParameter(); assert(wrap->refs_ == 0); wrap->handle_.Reset(); delete wrap; } // NOLINTNEXTLINE(runtime/v8_persistent) v8::Persistent<v8::Object> handle_; }; } // namespace node #endif // SRC_NODE_OBJECT_WRAP_H_	3.78 KB	2025-03-03 12:36
📄 node_version.h // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. #ifndef SRC_NODE_VERSION_H_ #define SRC_NODE_VERSION_H_ #define NODE_MAJOR_VERSION 22 #define NODE_MINOR_VERSION 14 #define NODE_PATCH_VERSION 0 #define NODE_VERSION_IS_LTS 1 #define NODE_VERSION_LTS_CODENAME "Jod" #define NODE_VERSION_IS_RELEASE 1 #ifndef NODE_STRINGIFY #define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n) #define NODE_STRINGIFY_HELPER(n) #n #endif #ifndef NODE_RELEASE #define NODE_RELEASE "node" #endif #ifndef NODE_TAG # if NODE_VERSION_IS_RELEASE # define NODE_TAG "" # else # define NODE_TAG "-pre" # endif #else // NODE_TAG is passed without quotes when rc.exe is run from msbuild # define NODE_EXE_VERSION NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \ NODE_STRINGIFY(NODE_MINOR_VERSION) "." \ NODE_STRINGIFY(NODE_PATCH_VERSION) \ NODE_STRINGIFY(NODE_TAG) #endif # define NODE_VERSION_STRING NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \ NODE_STRINGIFY(NODE_MINOR_VERSION) "." \ NODE_STRINGIFY(NODE_PATCH_VERSION) \ NODE_TAG #ifndef NODE_EXE_VERSION # define NODE_EXE_VERSION NODE_VERSION_STRING #endif #define NODE_VERSION "v" NODE_VERSION_STRING #define NODE_VERSION_AT_LEAST(major, minor, patch) \ (( (major) < NODE_MAJOR_VERSION) \ \|\| ((major) == NODE_MAJOR_VERSION && (minor) < NODE_MINOR_VERSION) \ \|\| ((major) == NODE_MAJOR_VERSION && \ (minor) == NODE_MINOR_VERSION && (patch) <= NODE_PATCH_VERSION)) /** * Node.js will refuse to load modules that weren't compiled against its own * module ABI number, exposed as the process.versions.modules property. * * Node.js will refuse to load modules with a non-matching ABI version. The * version number here should be changed whenever an ABI-incompatible API change * is made in the C++ side, including in V8 or other dependencies. * * Node.js will not change the module version during a Major release line * We will, at times update the version of V8 shipped in the release line * if it can be made ABI compatible with the previous version. * * Embedders building Node.js can define NODE_EMBEDDER_MODULE_VERSION to * override the default value of NODE_MODULE_VERSION. * * The registry of used NODE_MODULE_VERSION numbers is located at * https://github.com/nodejs/node/blob/HEAD/doc/abi_version_registry.json * Extenders, embedders and other consumers of Node.js that require ABI * version matching should open a pull request to reserve a number in this * registry. */ #if defined(NODE_EMBEDDER_MODULE_VERSION) #define NODE_MODULE_VERSION NODE_EMBEDDER_MODULE_VERSION #else #define NODE_MODULE_VERSION 127 #endif // The NAPI_VERSION supported by the runtime. This is the inclusive range of // versions which the Node.js binary being built supports. #define NODE_API_SUPPORTED_VERSION_MAX 10 #define NODE_API_SUPPORTED_VERSION_MIN 1 // Node API modules use NAPI_VERSION 8 by default if it is not explicitly // specified. It must be always 8. #define NODE_API_DEFAULT_MODULE_API_VERSION 8 #endif // SRC_NODE_VERSION_H_	4.14 KB	2025-03-03 12:36
📁 uv	-	2025-10-13 08:01
📄 uv.h /* Copyright Joyent, Inc. and other Node contributors. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. / / See https://github.com/libuv/libuv#documentation for documentation. / #ifndef UV_H #define UV_H #ifdef __cplusplus extern "C" { #endif #if defined(BUILDING_UV_SHARED) && defined(USING_UV_SHARED) #error "Define either BUILDING_UV_SHARED or USING_UV_SHARED, not both." #endif #ifndef UV_EXTERN #ifdef _WIN32 / Windows - set up dll import/export decorators. / # if defined(BUILDING_UV_SHARED) / Building shared library. / # define UV_EXTERN __declspec(dllexport) # elif defined(USING_UV_SHARED) / Using shared library. / # define UV_EXTERN __declspec(dllimport) # else / Building static library. / # define UV_EXTERN / nothing / # endif #elif __GNUC__ >= 4 # define UV_EXTERN __attribute__((visibility("default"))) #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550) / Sun Studio >= 8 / # define UV_EXTERN __global #else # define UV_EXTERN / nothing / #endif #endif / UV_EXTERN / #include "uv/errno.h" #include "uv/version.h" #include <stddef.h> #include <stdio.h> #include <stdint.h> / Internal type, do not use. / struct uv__queue { struct uv__queue next; struct uv__queue* prev; }; #if defined(_WIN32) # include "uv/win.h" #else # include "uv/unix.h" #endif /* Expand this list if necessary. / #define UV_ERRNO_MAP(XX) \ XX(E2BIG, "argument list too long") \ XX(EACCES, "permission denied") \ XX(EADDRINUSE, "address already in use") \ XX(EADDRNOTAVAIL, "address not available") \ XX(EAFNOSUPPORT, "address family not supported") \ XX(EAGAIN, "resource temporarily unavailable") \ XX(EAI_ADDRFAMILY, "address family not supported") \ XX(EAI_AGAIN, "temporary failure") \ XX(EAI_BADFLAGS, "bad ai_flags value") \ XX(EAI_BADHINTS, "invalid value for hints") \ XX(EAI_CANCELED, "request canceled") \ XX(EAI_FAIL, "permanent failure") \ XX(EAI_FAMILY, "ai_family not supported") \ XX(EAI_MEMORY, "out of memory") \ XX(EAI_NODATA, "no address") \ XX(EAI_NONAME, "unknown node or service") \ XX(EAI_OVERFLOW, "argument buffer overflow") \ XX(EAI_PROTOCOL, "resolved protocol is unknown") \ XX(EAI_SERVICE, "service not available for socket type") \ XX(EAI_SOCKTYPE, "socket type not supported") \ XX(EALREADY, "connection already in progress") \ XX(EBADF, "bad file descriptor") \ XX(EBUSY, "resource busy or locked") \ XX(ECANCELED, "operation canceled") \ XX(ECHARSET, "invalid Unicode character") \ XX(ECONNABORTED, "software caused connection abort") \ XX(ECONNREFUSED, "connection refused") \ XX(ECONNRESET, "connection reset by peer") \ XX(EDESTADDRREQ, "destination address required") \ XX(EEXIST, "file already exists") \ XX(EFAULT, "bad address in system call argument") \ XX(EFBIG, "file too large") \ XX(EHOSTUNREACH, "host is unreachable") \ XX(EINTR, "interrupted system call") \ XX(EINVAL, "invalid argument") \ XX(EIO, "i/o error") \ XX(EISCONN, "socket is already connected") \ XX(EISDIR, "illegal operation on a directory") \ XX(ELOOP, "too many symbolic links encountered") \ XX(EMFILE, "too many open files") \ XX(EMSGSIZE, "message too long") \ XX(ENAMETOOLONG, "name too long") \ XX(ENETDOWN, "network is down") \ XX(ENETUNREACH, "network is unreachable") \ XX(ENFILE, "file table overflow") \ XX(ENOBUFS, "no buffer space available") \ XX(ENODEV, "no such device") \ XX(ENOENT, "no such file or directory") \ XX(ENOMEM, "not enough memory") \ XX(ENONET, "machine is not on the network") \ XX(ENOPROTOOPT, "protocol not available") \ XX(ENOSPC, "no space left on device") \ XX(ENOSYS, "function not implemented") \ XX(ENOTCONN, "socket is not connected") \ XX(ENOTDIR, "not a directory") \ XX(ENOTEMPTY, "directory not empty") \ XX(ENOTSOCK, "socket operation on non-socket") \ XX(ENOTSUP, "operation not supported on socket") \ XX(EOVERFLOW, "value too large for defined data type") \ XX(EPERM, "operation not permitted") \ XX(EPIPE, "broken pipe") \ XX(EPROTO, "protocol error") \ XX(EPROTONOSUPPORT, "protocol not supported") \ XX(EPROTOTYPE, "protocol wrong type for socket") \ XX(ERANGE, "result too large") \ XX(EROFS, "read-only file system") \ XX(ESHUTDOWN, "cannot send after transport endpoint shutdown") \ XX(ESPIPE, "invalid seek") \ XX(ESRCH, "no such process") \ XX(ETIMEDOUT, "connection timed out") \ XX(ETXTBSY, "text file is busy") \ XX(EXDEV, "cross-device link not permitted") \ XX(UNKNOWN, "unknown error") \ XX(EOF, "end of file") \ XX(ENXIO, "no such device or address") \ XX(EMLINK, "too many links") \ XX(EHOSTDOWN, "host is down") \ XX(EREMOTEIO, "remote I/O error") \ XX(ENOTTY, "inappropriate ioctl for device") \ XX(EFTYPE, "inappropriate file type or format") \ XX(EILSEQ, "illegal byte sequence") \ XX(ESOCKTNOSUPPORT, "socket type not supported") \ XX(ENODATA, "no data available") \ XX(EUNATCH, "protocol driver not attached") \ #define UV_HANDLE_TYPE_MAP(XX) \ XX(ASYNC, async) \ XX(CHECK, check) \ XX(FS_EVENT, fs_event) \ XX(FS_POLL, fs_poll) \ XX(HANDLE, handle) \ XX(IDLE, idle) \ XX(NAMED_PIPE, pipe) \ XX(POLL, poll) \ XX(PREPARE, prepare) \ XX(PROCESS, process) \ XX(STREAM, stream) \ XX(TCP, tcp) \ XX(TIMER, timer) \ XX(TTY, tty) \ XX(UDP, udp) \ XX(SIGNAL, signal) \ #define UV_REQ_TYPE_MAP(XX) \ XX(REQ, req) \ XX(CONNECT, connect) \ XX(WRITE, write) \ XX(SHUTDOWN, shutdown) \ XX(UDP_SEND, udp_send) \ XX(FS, fs) \ XX(WORK, work) \ XX(GETADDRINFO, getaddrinfo) \ XX(GETNAMEINFO, getnameinfo) \ XX(RANDOM, random) \ typedef enum { #define XX(code, _) UV_ ## code = UV__ ## code, UV_ERRNO_MAP(XX) #undef XX UV_ERRNO_MAX = UV__EOF - 1 } uv_errno_t; typedef enum { UV_UNKNOWN_HANDLE = 0, #define XX(uc, lc) UV_##uc, UV_HANDLE_TYPE_MAP(XX) #undef XX UV_FILE, UV_HANDLE_TYPE_MAX } uv_handle_type; typedef enum { UV_UNKNOWN_REQ = 0, #define XX(uc, lc) UV_##uc, UV_REQ_TYPE_MAP(XX) #undef XX UV_REQ_TYPE_PRIVATE UV_REQ_TYPE_MAX } uv_req_type; / Handle types. / typedef struct uv_loop_s uv_loop_t; typedef struct uv_handle_s uv_handle_t; typedef struct uv_dir_s uv_dir_t; typedef struct uv_stream_s uv_stream_t; typedef struct uv_tcp_s uv_tcp_t; typedef struct uv_udp_s uv_udp_t; typedef struct uv_pipe_s uv_pipe_t; typedef struct uv_tty_s uv_tty_t; typedef struct uv_poll_s uv_poll_t; typedef struct uv_timer_s uv_timer_t; typedef struct uv_prepare_s uv_prepare_t; typedef struct uv_check_s uv_check_t; typedef struct uv_idle_s uv_idle_t; typedef struct uv_async_s uv_async_t; typedef struct uv_process_s uv_process_t; typedef struct uv_fs_event_s uv_fs_event_t; typedef struct uv_fs_poll_s uv_fs_poll_t; typedef struct uv_signal_s uv_signal_t; / Request types. / typedef struct uv_req_s uv_req_t; typedef struct uv_getaddrinfo_s uv_getaddrinfo_t; typedef struct uv_getnameinfo_s uv_getnameinfo_t; typedef struct uv_shutdown_s uv_shutdown_t; typedef struct uv_write_s uv_write_t; typedef struct uv_connect_s uv_connect_t; typedef struct uv_udp_send_s uv_udp_send_t; typedef struct uv_fs_s uv_fs_t; typedef struct uv_work_s uv_work_t; typedef struct uv_random_s uv_random_t; / None of the above. / typedef struct uv_env_item_s uv_env_item_t; typedef struct uv_cpu_info_s uv_cpu_info_t; typedef struct uv_interface_address_s uv_interface_address_t; typedef struct uv_dirent_s uv_dirent_t; typedef struct uv_passwd_s uv_passwd_t; typedef struct uv_group_s uv_group_t; typedef struct uv_utsname_s uv_utsname_t; typedef struct uv_statfs_s uv_statfs_t; typedef struct uv_metrics_s uv_metrics_t; typedef enum { UV_LOOP_BLOCK_SIGNAL = 0, UV_METRICS_IDLE_TIME, UV_LOOP_USE_IO_URING_SQPOLL #define UV_LOOP_USE_IO_URING_SQPOLL UV_LOOP_USE_IO_URING_SQPOLL } uv_loop_option; typedef enum { UV_RUN_DEFAULT = 0, UV_RUN_ONCE, UV_RUN_NOWAIT } uv_run_mode; UV_EXTERN unsigned int uv_version(void); UV_EXTERN const char uv_version_string(void); typedef void* (uv_malloc_func)(size_t size); typedef void (uv_realloc_func)(void ptr, size_t size); typedef void* (uv_calloc_func)(size_t count, size_t size); typedef void (uv_free_func)(void* ptr); UV_EXTERN void uv_library_shutdown(void); UV_EXTERN int uv_replace_allocator(uv_malloc_func malloc_func, uv_realloc_func realloc_func, uv_calloc_func calloc_func, uv_free_func free_func); UV_EXTERN uv_loop_t* uv_default_loop(void); UV_EXTERN int uv_loop_init(uv_loop_t* loop); UV_EXTERN int uv_loop_close(uv_loop_t* loop); /* * NOTE: * This function is DEPRECATED, users should * allocate the loop manually and use uv_loop_init instead. / UV_EXTERN uv_loop_t uv_loop_new(void); /* * NOTE: * This function is DEPRECATED. Users should use * uv_loop_close and free the memory manually instead. / UV_EXTERN void uv_loop_delete(uv_loop_t); UV_EXTERN size_t uv_loop_size(void); UV_EXTERN int uv_loop_alive(const uv_loop_t* loop); UV_EXTERN int uv_loop_configure(uv_loop_t* loop, uv_loop_option option, ...); UV_EXTERN int uv_loop_fork(uv_loop_t* loop); UV_EXTERN int uv_run(uv_loop_t, uv_run_mode mode); UV_EXTERN void uv_stop(uv_loop_t); UV_EXTERN void uv_ref(uv_handle_t); UV_EXTERN void uv_unref(uv_handle_t); UV_EXTERN int uv_has_ref(const uv_handle_t); UV_EXTERN void uv_update_time(uv_loop_t); UV_EXTERN uint64_t uv_now(const uv_loop_t); UV_EXTERN int uv_backend_fd(const uv_loop_t); UV_EXTERN int uv_backend_timeout(const uv_loop_t); typedef void (uv_alloc_cb)(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf); typedef void (uv_read_cb)(uv_stream_t stream, ssize_t nread, const uv_buf_t* buf); typedef void (uv_write_cb)(uv_write_t req, int status); typedef void (uv_connect_cb)(uv_connect_t req, int status); typedef void (uv_shutdown_cb)(uv_shutdown_t req, int status); typedef void (uv_connection_cb)(uv_stream_t server, int status); typedef void (uv_close_cb)(uv_handle_t handle); typedef void (uv_poll_cb)(uv_poll_t handle, int status, int events); typedef void (uv_timer_cb)(uv_timer_t handle); typedef void (uv_async_cb)(uv_async_t handle); typedef void (uv_prepare_cb)(uv_prepare_t handle); typedef void (uv_check_cb)(uv_check_t handle); typedef void (uv_idle_cb)(uv_idle_t handle); typedef void (uv_exit_cb)(uv_process_t, int64_t exit_status, int term_signal); typedef void (uv_walk_cb)(uv_handle_t handle, void* arg); typedef void (uv_fs_cb)(uv_fs_t req); typedef void (uv_work_cb)(uv_work_t req); typedef void (uv_after_work_cb)(uv_work_t req, int status); typedef void (uv_getaddrinfo_cb)(uv_getaddrinfo_t req, int status, struct addrinfo* res); typedef void (uv_getnameinfo_cb)(uv_getnameinfo_t req, int status, const char* hostname, const char* service); typedef void (uv_random_cb)(uv_random_t req, int status, void* buf, size_t buflen); typedef enum { UV_CLOCK_MONOTONIC, UV_CLOCK_REALTIME } uv_clock_id; /* XXX(bnoordhuis) not 2038-proof, https://github.com/libuv/libuv/issues/3864 / typedef struct { long tv_sec; long tv_nsec; } uv_timespec_t; typedef struct { int64_t tv_sec; int32_t tv_nsec; } uv_timespec64_t; / XXX(bnoordhuis) not 2038-proof, https://github.com/libuv/libuv/issues/3864 / typedef struct { long tv_sec; long tv_usec; } uv_timeval_t; typedef struct { int64_t tv_sec; int32_t tv_usec; } uv_timeval64_t; typedef struct { uint64_t st_dev; uint64_t st_mode; uint64_t st_nlink; uint64_t st_uid; uint64_t st_gid; uint64_t st_rdev; uint64_t st_ino; uint64_t st_size; uint64_t st_blksize; uint64_t st_blocks; uint64_t st_flags; uint64_t st_gen; uv_timespec_t st_atim; uv_timespec_t st_mtim; uv_timespec_t st_ctim; uv_timespec_t st_birthtim; } uv_stat_t; typedef void (uv_fs_event_cb)(uv_fs_event_t* handle, const char* filename, int events, int status); typedef void (uv_fs_poll_cb)(uv_fs_poll_t handle, int status, const uv_stat_t* prev, const uv_stat_t* curr); typedef void (uv_signal_cb)(uv_signal_t handle, int signum); typedef enum { UV_LEAVE_GROUP = 0, UV_JOIN_GROUP } uv_membership; UV_EXTERN int uv_translate_sys_error(int sys_errno); UV_EXTERN const char* uv_strerror(int err); UV_EXTERN char* uv_strerror_r(int err, char* buf, size_t buflen); UV_EXTERN const char* uv_err_name(int err); UV_EXTERN char* uv_err_name_r(int err, char* buf, size_t buflen); #define UV_REQ_FIELDS \ /* public / \ void data; \ /* read-only / \ uv_req_type type; \ / private / \ void reserved[6]; \ UV_REQ_PRIVATE_FIELDS \ /* Abstract base class of all requests. / struct uv_req_s { UV_REQ_FIELDS }; / Platform-specific request types. / UV_PRIVATE_REQ_TYPES UV_EXTERN int uv_shutdown(uv_shutdown_t req, uv_stream_t* handle, uv_shutdown_cb cb); struct uv_shutdown_s { UV_REQ_FIELDS uv_stream_t* handle; uv_shutdown_cb cb; UV_SHUTDOWN_PRIVATE_FIELDS }; #define UV_HANDLE_FIELDS \ /* public / \ void data; \ /* read-only / \ uv_loop_t loop; \ uv_handle_type type; \ /* private / \ uv_close_cb close_cb; \ struct uv__queue handle_queue; \ union { \ int fd; \ void reserved[4]; \ } u; \ UV_HANDLE_PRIVATE_FIELDS \ /* The abstract base class of all handles. / struct uv_handle_s { UV_HANDLE_FIELDS }; UV_EXTERN size_t uv_handle_size(uv_handle_type type); UV_EXTERN uv_handle_type uv_handle_get_type(const uv_handle_t handle); UV_EXTERN const char* uv_handle_type_name(uv_handle_type type); UV_EXTERN void* uv_handle_get_data(const uv_handle_t* handle); UV_EXTERN uv_loop_t* uv_handle_get_loop(const uv_handle_t* handle); UV_EXTERN void uv_handle_set_data(uv_handle_t* handle, void* data); UV_EXTERN size_t uv_req_size(uv_req_type type); UV_EXTERN void* uv_req_get_data(const uv_req_t* req); UV_EXTERN void uv_req_set_data(uv_req_t* req, void* data); UV_EXTERN uv_req_type uv_req_get_type(const uv_req_t* req); UV_EXTERN const char* uv_req_type_name(uv_req_type type); UV_EXTERN int uv_is_active(const uv_handle_t* handle); UV_EXTERN void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg); /* Helpers for ad hoc debugging, no API/ABI stability guaranteed. / UV_EXTERN void uv_print_all_handles(uv_loop_t loop, FILE* stream); UV_EXTERN void uv_print_active_handles(uv_loop_t* loop, FILE* stream); UV_EXTERN void uv_close(uv_handle_t* handle, uv_close_cb close_cb); UV_EXTERN int uv_send_buffer_size(uv_handle_t* handle, int* value); UV_EXTERN int uv_recv_buffer_size(uv_handle_t* handle, int* value); UV_EXTERN int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd); UV_EXTERN uv_buf_t uv_buf_init(char* base, unsigned int len); UV_EXTERN int uv_pipe(uv_file fds[2], int read_flags, int write_flags); UV_EXTERN int uv_socketpair(int type, int protocol, uv_os_sock_t socket_vector[2], int flags0, int flags1); #define UV_STREAM_FIELDS \ /* number of bytes queued for writing / \ size_t write_queue_size; \ uv_alloc_cb alloc_cb; \ uv_read_cb read_cb; \ / private / \ UV_STREAM_PRIVATE_FIELDS / * uv_stream_t is a subclass of uv_handle_t. * * uv_stream is an abstract class. * * uv_stream_t is the parent class of uv_tcp_t, uv_pipe_t and uv_tty_t. / struct uv_stream_s { UV_HANDLE_FIELDS UV_STREAM_FIELDS }; UV_EXTERN size_t uv_stream_get_write_queue_size(const uv_stream_t stream); UV_EXTERN int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb); UV_EXTERN int uv_accept(uv_stream_t* server, uv_stream_t* client); UV_EXTERN int uv_read_start(uv_stream_t, uv_alloc_cb alloc_cb, uv_read_cb read_cb); UV_EXTERN int uv_read_stop(uv_stream_t); UV_EXTERN int uv_write(uv_write_t* req, uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb); UV_EXTERN int uv_write2(uv_write_t* req, uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs, uv_stream_t* send_handle, uv_write_cb cb); UV_EXTERN int uv_try_write(uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs); UV_EXTERN int uv_try_write2(uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs, uv_stream_t* send_handle); /* uv_write_t is a subclass of uv_req_t. / struct uv_write_s { UV_REQ_FIELDS uv_write_cb cb; uv_stream_t send_handle; /* TODO: make private and unix-only in v2.x. / uv_stream_t handle; UV_WRITE_PRIVATE_FIELDS }; UV_EXTERN int uv_is_readable(const uv_stream_t* handle); UV_EXTERN int uv_is_writable(const uv_stream_t* handle); UV_EXTERN int uv_stream_set_blocking(uv_stream_t* handle, int blocking); UV_EXTERN int uv_is_closing(const uv_handle_t* handle); /* * uv_tcp_t is a subclass of uv_stream_t. * * Represents a TCP stream or TCP server. / struct uv_tcp_s { UV_HANDLE_FIELDS UV_STREAM_FIELDS UV_TCP_PRIVATE_FIELDS }; UV_EXTERN int uv_tcp_init(uv_loop_t, uv_tcp_t* handle); UV_EXTERN int uv_tcp_init_ex(uv_loop_t, uv_tcp_t handle, unsigned int flags); UV_EXTERN int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock); UV_EXTERN int uv_tcp_nodelay(uv_tcp_t* handle, int enable); UV_EXTERN int uv_tcp_keepalive(uv_tcp_t* handle, int enable, unsigned int delay); UV_EXTERN int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable); enum uv_tcp_flags { /* Used with uv_tcp_bind, when an IPv6 address is used. / UV_TCP_IPV6ONLY = 1, / Enable SO_REUSEPORT socket option when binding the handle. * This allows completely duplicate bindings by multiple processes * or threads if they all set SO_REUSEPORT before binding the port. * Incoming connections are distributed across the participating * listener sockets. * * This flag is available only on Linux 3.9+, DragonFlyBSD 3.6+, * FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ for now. / UV_TCP_REUSEPORT = 2, }; UV_EXTERN int uv_tcp_bind(uv_tcp_t handle, const struct sockaddr* addr, unsigned int flags); UV_EXTERN int uv_tcp_getsockname(const uv_tcp_t* handle, struct sockaddr* name, int* namelen); UV_EXTERN int uv_tcp_getpeername(const uv_tcp_t* handle, struct sockaddr* name, int* namelen); UV_EXTERN int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb); UV_EXTERN int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle, const struct sockaddr* addr, uv_connect_cb cb); /* uv_connect_t is a subclass of uv_req_t. / struct uv_connect_s { UV_REQ_FIELDS uv_connect_cb cb; uv_stream_t handle; UV_CONNECT_PRIVATE_FIELDS }; /* * UDP support. / enum uv_udp_flags { / Disables dual stack mode. / UV_UDP_IPV6ONLY = 1, / * Indicates message was truncated because read buffer was too small. The * remainder was discarded by the OS. Used in uv_udp_recv_cb. / UV_UDP_PARTIAL = 2, / * Indicates if SO_REUSEADDR will be set when binding the handle. * This sets the SO_REUSEPORT socket flag on the BSDs (except for * DragonFlyBSD), OS X, and other platforms where SO_REUSEPORTs don't * have the capability of load balancing, as the opposite of what * UV_UDP_REUSEPORT would do. On other Unix platforms, it sets the * SO_REUSEADDR flag. What that means is that multiple threads or * processes can bind to the same address without error (provided * they all set the flag) but only the last one to bind will receive * any traffic, in effect "stealing" the port from the previous listener. / UV_UDP_REUSEADDR = 4, / * Indicates that the message was received by recvmmsg, so the buffer provided * must not be freed by the recv_cb callback. / UV_UDP_MMSG_CHUNK = 8, / * Indicates that the buffer provided has been fully utilized by recvmmsg and * that it should now be freed by the recv_cb callback. When this flag is set * in uv_udp_recv_cb, nread will always be 0 and addr will always be NULL. / UV_UDP_MMSG_FREE = 16, / * Indicates if IP_RECVERR/IPV6_RECVERR will be set when binding the handle. * This sets IP_RECVERR for IPv4 and IPV6_RECVERR for IPv6 UDP sockets on * Linux. This stops the Linux kernel from suppressing some ICMP error * messages and enables full ICMP error reporting for faster failover. * This flag is no-op on platforms other than Linux. / UV_UDP_LINUX_RECVERR = 32, / * Indicates if SO_REUSEPORT will be set when binding the handle. * This sets the SO_REUSEPORT socket option on supported platforms. * Unlike UV_UDP_REUSEADDR, this flag will make multiple threads or * processes that are binding to the same address and port "share" * the port, which means incoming datagrams are distributed across * the receiving sockets among threads or processes. * * This flag is available only on Linux 3.9+, DragonFlyBSD 3.6+, * FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ for now. / UV_UDP_REUSEPORT = 64, / * Indicates that recvmmsg should be used, if available. / UV_UDP_RECVMMSG = 256 }; typedef void (uv_udp_send_cb)(uv_udp_send_t* req, int status); typedef void (uv_udp_recv_cb)(uv_udp_t handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned flags); /* uv_udp_t is a subclass of uv_handle_t. / struct uv_udp_s { UV_HANDLE_FIELDS / read-only / / * Number of bytes queued for sending. This field strictly shows how much * information is currently queued. / size_t send_queue_size; / * Number of send requests currently in the queue awaiting to be processed. / size_t send_queue_count; UV_UDP_PRIVATE_FIELDS }; / uv_udp_send_t is a subclass of uv_req_t. / struct uv_udp_send_s { UV_REQ_FIELDS uv_udp_t handle; uv_udp_send_cb cb; UV_UDP_SEND_PRIVATE_FIELDS }; UV_EXTERN int uv_udp_init(uv_loop_t, uv_udp_t handle); UV_EXTERN int uv_udp_init_ex(uv_loop_t, uv_udp_t handle, unsigned int flags); UV_EXTERN int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock); UV_EXTERN int uv_udp_bind(uv_udp_t* handle, const struct sockaddr* addr, unsigned int flags); UV_EXTERN int uv_udp_connect(uv_udp_t* handle, const struct sockaddr* addr); UV_EXTERN int uv_udp_getpeername(const uv_udp_t* handle, struct sockaddr* name, int* namelen); UV_EXTERN int uv_udp_getsockname(const uv_udp_t* handle, struct sockaddr* name, int* namelen); UV_EXTERN int uv_udp_set_membership(uv_udp_t* handle, const char* multicast_addr, const char* interface_addr, uv_membership membership); UV_EXTERN int uv_udp_set_source_membership(uv_udp_t* handle, const char* multicast_addr, const char* interface_addr, const char* source_addr, uv_membership membership); UV_EXTERN int uv_udp_set_multicast_loop(uv_udp_t* handle, int on); UV_EXTERN int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl); UV_EXTERN int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr); UV_EXTERN int uv_udp_set_broadcast(uv_udp_t* handle, int on); UV_EXTERN int uv_udp_set_ttl(uv_udp_t* handle, int ttl); UV_EXTERN int uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr* addr, uv_udp_send_cb send_cb); UV_EXTERN int uv_udp_try_send(uv_udp_t* handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr* addr); UV_EXTERN int uv_udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb, uv_udp_recv_cb recv_cb); UV_EXTERN int uv_udp_using_recvmmsg(const uv_udp_t* handle); UV_EXTERN int uv_udp_recv_stop(uv_udp_t* handle); UV_EXTERN size_t uv_udp_get_send_queue_size(const uv_udp_t* handle); UV_EXTERN size_t uv_udp_get_send_queue_count(const uv_udp_t* handle); /* * uv_tty_t is a subclass of uv_stream_t. * * Representing a stream for the console. / struct uv_tty_s { UV_HANDLE_FIELDS UV_STREAM_FIELDS UV_TTY_PRIVATE_FIELDS }; typedef enum { / Initial/normal terminal mode / UV_TTY_MODE_NORMAL, / Raw input mode (On Windows, ENABLE_WINDOW_INPUT is also enabled) / UV_TTY_MODE_RAW, / Binary-safe I/O mode for IPC (Unix-only) / UV_TTY_MODE_IO } uv_tty_mode_t; typedef enum { / * The console supports handling of virtual terminal sequences * (Windows10 new console, ConEmu) / UV_TTY_SUPPORTED, / The console cannot process the virtual terminal sequence. (Legacy * console) / UV_TTY_UNSUPPORTED } uv_tty_vtermstate_t; UV_EXTERN int uv_tty_init(uv_loop_t, uv_tty_t, uv_file fd, int readable); UV_EXTERN int uv_tty_set_mode(uv_tty_t, uv_tty_mode_t mode); UV_EXTERN int uv_tty_reset_mode(void); UV_EXTERN int uv_tty_get_winsize(uv_tty_t, int width, int* height); UV_EXTERN void uv_tty_set_vterm_state(uv_tty_vtermstate_t state); UV_EXTERN int uv_tty_get_vterm_state(uv_tty_vtermstate_t* state); #ifdef __cplusplus extern "C++" { inline int uv_tty_set_mode(uv_tty_t* handle, int mode) { return uv_tty_set_mode(handle, static_cast<uv_tty_mode_t>(mode)); } } #endif UV_EXTERN uv_handle_type uv_guess_handle(uv_file file); enum { UV_PIPE_NO_TRUNCATE = 1u << 0 }; /* * uv_pipe_t is a subclass of uv_stream_t. * * Representing a pipe stream or pipe server. On Windows this is a Named * Pipe. On Unix this is a Unix domain socket. / struct uv_pipe_s { UV_HANDLE_FIELDS UV_STREAM_FIELDS int ipc; / non-zero if this pipe is used for passing handles / UV_PIPE_PRIVATE_FIELDS }; UV_EXTERN int uv_pipe_init(uv_loop_t, uv_pipe_t* handle, int ipc); UV_EXTERN int uv_pipe_open(uv_pipe_t, uv_file file); UV_EXTERN int uv_pipe_bind(uv_pipe_t handle, const char* name); UV_EXTERN int uv_pipe_bind2(uv_pipe_t* handle, const char* name, size_t namelen, unsigned int flags); UV_EXTERN void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb); UV_EXTERN int uv_pipe_connect2(uv_connect_t* req, uv_pipe_t* handle, const char* name, size_t namelen, unsigned int flags, uv_connect_cb cb); UV_EXTERN int uv_pipe_getsockname(const uv_pipe_t* handle, char* buffer, size_t* size); UV_EXTERN int uv_pipe_getpeername(const uv_pipe_t* handle, char* buffer, size_t* size); UV_EXTERN void uv_pipe_pending_instances(uv_pipe_t* handle, int count); UV_EXTERN int uv_pipe_pending_count(uv_pipe_t* handle); UV_EXTERN uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle); UV_EXTERN int uv_pipe_chmod(uv_pipe_t* handle, int flags); struct uv_poll_s { UV_HANDLE_FIELDS uv_poll_cb poll_cb; UV_POLL_PRIVATE_FIELDS }; enum uv_poll_event { UV_READABLE = 1, UV_WRITABLE = 2, UV_DISCONNECT = 4, UV_PRIORITIZED = 8 }; UV_EXTERN int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd); UV_EXTERN int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle, uv_os_sock_t socket); UV_EXTERN int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb); UV_EXTERN int uv_poll_stop(uv_poll_t* handle); struct uv_prepare_s { UV_HANDLE_FIELDS UV_PREPARE_PRIVATE_FIELDS }; UV_EXTERN int uv_prepare_init(uv_loop_t, uv_prepare_t prepare); UV_EXTERN int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb); UV_EXTERN int uv_prepare_stop(uv_prepare_t* prepare); struct uv_check_s { UV_HANDLE_FIELDS UV_CHECK_PRIVATE_FIELDS }; UV_EXTERN int uv_check_init(uv_loop_t, uv_check_t check); UV_EXTERN int uv_check_start(uv_check_t* check, uv_check_cb cb); UV_EXTERN int uv_check_stop(uv_check_t* check); struct uv_idle_s { UV_HANDLE_FIELDS UV_IDLE_PRIVATE_FIELDS }; UV_EXTERN int uv_idle_init(uv_loop_t, uv_idle_t idle); UV_EXTERN int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb); UV_EXTERN int uv_idle_stop(uv_idle_t* idle); struct uv_async_s { UV_HANDLE_FIELDS UV_ASYNC_PRIVATE_FIELDS }; UV_EXTERN int uv_async_init(uv_loop_t, uv_async_t async, uv_async_cb async_cb); UV_EXTERN int uv_async_send(uv_async_t* async); /* * uv_timer_t is a subclass of uv_handle_t. * * Used to get woken up at a specified time in the future. / struct uv_timer_s { UV_HANDLE_FIELDS UV_TIMER_PRIVATE_FIELDS }; UV_EXTERN int uv_timer_init(uv_loop_t, uv_timer_t* handle); UV_EXTERN int uv_timer_start(uv_timer_t* handle, uv_timer_cb cb, uint64_t timeout, uint64_t repeat); UV_EXTERN int uv_timer_stop(uv_timer_t* handle); UV_EXTERN int uv_timer_again(uv_timer_t* handle); UV_EXTERN void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat); UV_EXTERN uint64_t uv_timer_get_repeat(const uv_timer_t* handle); UV_EXTERN uint64_t uv_timer_get_due_in(const uv_timer_t* handle); /* * uv_getaddrinfo_t is a subclass of uv_req_t. * * Request object for uv_getaddrinfo. / struct uv_getaddrinfo_s { UV_REQ_FIELDS / read-only / uv_loop_t loop; /* struct addrinfo* addrinfo is marked as private, but it really isn't. / UV_GETADDRINFO_PRIVATE_FIELDS }; UV_EXTERN int uv_getaddrinfo(uv_loop_t loop, uv_getaddrinfo_t* req, uv_getaddrinfo_cb getaddrinfo_cb, const char* node, const char* service, const struct addrinfo* hints); UV_EXTERN void uv_freeaddrinfo(struct addrinfo* ai); /* * uv_getnameinfo_t is a subclass of uv_req_t. * * Request object for uv_getnameinfo. / struct uv_getnameinfo_s { UV_REQ_FIELDS / read-only / uv_loop_t loop; /* host and service are marked as private, but they really aren't. / UV_GETNAMEINFO_PRIVATE_FIELDS }; UV_EXTERN int uv_getnameinfo(uv_loop_t loop, uv_getnameinfo_t* req, uv_getnameinfo_cb getnameinfo_cb, const struct sockaddr* addr, int flags); /* uv_spawn() options. / typedef enum { UV_IGNORE = 0x00, UV_CREATE_PIPE = 0x01, UV_INHERIT_FD = 0x02, UV_INHERIT_STREAM = 0x04, / * When UV_CREATE_PIPE is specified, UV_READABLE_PIPE and UV_WRITABLE_PIPE * determine the direction of flow, from the child process' perspective. Both * flags may be specified to create a duplex data stream. / UV_READABLE_PIPE = 0x10, UV_WRITABLE_PIPE = 0x20, / * When UV_CREATE_PIPE is specified, specifying UV_NONBLOCK_PIPE opens the * handle in non-blocking mode in the child. This may cause loss of data, * if the child is not designed to handle to encounter this mode, * but can also be significantly more efficient. / UV_NONBLOCK_PIPE = 0x40, UV_OVERLAPPED_PIPE = 0x40 / old name, for compatibility / } uv_stdio_flags; typedef struct uv_stdio_container_s { uv_stdio_flags flags; union { uv_stream_t stream; int fd; } data; } uv_stdio_container_t; typedef struct uv_process_options_s { uv_exit_cb exit_cb; /* Called after the process exits. / const char file; /* Path to program to execute. / / * Command line arguments. args[0] should be the path to the program. On * Windows this uses CreateProcess which concatenates the arguments into a * string this can cause some strange errors. See the note at * windows_verbatim_arguments. / char* args; /* * This will be set as the environ variable in the subprocess. If this is * NULL then the parents environ will be used. / char* env; /* * If non-null this represents a directory the subprocess should execute * in. Stands for current working directory. / const char cwd; /* * Various flags that control how uv_spawn() behaves. See the definition of * `enum uv_process_flags` below. / unsigned int flags; / * The `stdio` field points to an array of uv_stdio_container_t structs that * describe the file descriptors that will be made available to the child * process. The convention is that stdio[0] points to stdin, fd 1 is used for * stdout, and fd 2 is stderr. * * Note that on windows file descriptors greater than 2 are available to the * child process only if the child processes uses the MSVCRT runtime. / int stdio_count; uv_stdio_container_t stdio; /* * Libuv can change the child process' user/group id. This happens only when * the appropriate bits are set in the flags fields. This is not supported on * windows; uv_spawn() will fail and set the error to UV_ENOTSUP. / uv_uid_t uid; uv_gid_t gid; } uv_process_options_t; / * These are the flags that can be used for the uv_process_options.flags field. / enum uv_process_flags { / * Set the child process' user id. The user id is supplied in the `uid` field * of the options struct. This does not work on windows; setting this flag * will cause uv_spawn() to fail. / UV_PROCESS_SETUID = (1 << 0), / * Set the child process' group id. The user id is supplied in the `gid` * field of the options struct. This does not work on windows; setting this * flag will cause uv_spawn() to fail. / UV_PROCESS_SETGID = (1 << 1), / * Do not wrap any arguments in quotes, or perform any other escaping, when * converting the argument list into a command line string. This option is * only meaningful on Windows systems. On Unix it is silently ignored. / UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = (1 << 2), / * Spawn the child process in a detached state - this will make it a process * group leader, and will effectively enable the child to keep running after * the parent exits. Note that the child process will still keep the * parent's event loop alive unless the parent process calls uv_unref() on * the child's process handle. / UV_PROCESS_DETACHED = (1 << 3), / * Hide the subprocess window that would normally be created. This option is * only meaningful on Windows systems. On Unix it is silently ignored. / UV_PROCESS_WINDOWS_HIDE = (1 << 4), / * Hide the subprocess console window that would normally be created. This * option is only meaningful on Windows systems. On Unix it is silently * ignored. / UV_PROCESS_WINDOWS_HIDE_CONSOLE = (1 << 5), / * Hide the subprocess GUI window that would normally be created. This * option is only meaningful on Windows systems. On Unix it is silently * ignored. / UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6), / * On Windows, if the path to the program to execute, specified in * uv_process_options_t's file field, has a directory component, * search for the exact file name before trying variants with * extensions like '.exe' or '.cmd'. / UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME = (1 << 7) }; / * uv_process_t is a subclass of uv_handle_t. / struct uv_process_s { UV_HANDLE_FIELDS uv_exit_cb exit_cb; int pid; UV_PROCESS_PRIVATE_FIELDS }; UV_EXTERN int uv_spawn(uv_loop_t loop, uv_process_t* handle, const uv_process_options_t* options); UV_EXTERN int uv_process_kill(uv_process_t, int signum); UV_EXTERN int uv_kill(int pid, int signum); UV_EXTERN uv_pid_t uv_process_get_pid(const uv_process_t); /* * uv_work_t is a subclass of uv_req_t. / struct uv_work_s { UV_REQ_FIELDS uv_loop_t loop; uv_work_cb work_cb; uv_after_work_cb after_work_cb; UV_WORK_PRIVATE_FIELDS }; UV_EXTERN int uv_queue_work(uv_loop_t* loop, uv_work_t* req, uv_work_cb work_cb, uv_after_work_cb after_work_cb); UV_EXTERN int uv_cancel(uv_req_t* req); struct uv_cpu_times_s { uint64_t user; /* milliseconds / uint64_t nice; / milliseconds / uint64_t sys; / milliseconds / uint64_t idle; / milliseconds / uint64_t irq; / milliseconds / }; struct uv_cpu_info_s { char model; int speed; struct uv_cpu_times_s cpu_times; }; struct uv_interface_address_s { char* name; char phys_addr[6]; int is_internal; union { struct sockaddr_in address4; struct sockaddr_in6 address6; } address; union { struct sockaddr_in netmask4; struct sockaddr_in6 netmask6; } netmask; }; struct uv_passwd_s { char* username; unsigned long uid; unsigned long gid; char* shell; char* homedir; }; struct uv_group_s { char* groupname; unsigned long gid; char** members; }; struct uv_utsname_s { char sysname[256]; char release[256]; char version[256]; char machine[256]; /* This struct does not contain the nodename and domainname fields present in the utsname type. domainname is a GNU extension. Both fields are referred to as meaningless in the docs. / }; struct uv_statfs_s { uint64_t f_type; uint64_t f_bsize; uint64_t f_blocks; uint64_t f_bfree; uint64_t f_bavail; uint64_t f_files; uint64_t f_ffree; uint64_t f_spare[4]; }; typedef enum { UV_DIRENT_UNKNOWN, UV_DIRENT_FILE, UV_DIRENT_DIR, UV_DIRENT_LINK, UV_DIRENT_FIFO, UV_DIRENT_SOCKET, UV_DIRENT_CHAR, UV_DIRENT_BLOCK } uv_dirent_type_t; struct uv_dirent_s { const char name; uv_dirent_type_t type; }; UV_EXTERN char uv_setup_args(int argc, char argv); UV_EXTERN int uv_get_process_title(char* buffer, size_t size); UV_EXTERN int uv_set_process_title(const char* title); UV_EXTERN int uv_resident_set_memory(size_t* rss); UV_EXTERN int uv_uptime(double* uptime); UV_EXTERN uv_os_fd_t uv_get_osfhandle(int fd); UV_EXTERN int uv_open_osfhandle(uv_os_fd_t os_fd); typedef struct { uv_timeval_t ru_utime; /* user CPU time used / uv_timeval_t ru_stime; / system CPU time used / uint64_t ru_maxrss; / maximum resident set size / uint64_t ru_ixrss; / integral shared memory size / uint64_t ru_idrss; / integral unshared data size / uint64_t ru_isrss; / integral unshared stack size / uint64_t ru_minflt; / page reclaims (soft page faults) / uint64_t ru_majflt; / page faults (hard page faults) / uint64_t ru_nswap; / swaps / uint64_t ru_inblock; / block input operations / uint64_t ru_oublock; / block output operations / uint64_t ru_msgsnd; / IPC messages sent / uint64_t ru_msgrcv; / IPC messages received / uint64_t ru_nsignals; / signals received / uint64_t ru_nvcsw; / voluntary context switches / uint64_t ru_nivcsw; / involuntary context switches / } uv_rusage_t; UV_EXTERN int uv_getrusage(uv_rusage_t rusage); UV_EXTERN int uv_os_homedir(char* buffer, size_t* size); UV_EXTERN int uv_os_tmpdir(char* buffer, size_t* size); UV_EXTERN int uv_os_get_passwd(uv_passwd_t* pwd); UV_EXTERN void uv_os_free_passwd(uv_passwd_t* pwd); UV_EXTERN int uv_os_get_passwd2(uv_passwd_t* pwd, uv_uid_t uid); UV_EXTERN int uv_os_get_group(uv_group_t* grp, uv_uid_t gid); UV_EXTERN void uv_os_free_group(uv_group_t* grp); UV_EXTERN uv_pid_t uv_os_getpid(void); UV_EXTERN uv_pid_t uv_os_getppid(void); #if defined(__PASE__) /* On IBM i PASE, the highest process priority is -10 / # define UV_PRIORITY_LOW 39 / RUNPTY(99) / # define UV_PRIORITY_BELOW_NORMAL 15 / RUNPTY(50) / # define UV_PRIORITY_NORMAL 0 / RUNPTY(20) / # define UV_PRIORITY_ABOVE_NORMAL -4 / RUNTY(12) / # define UV_PRIORITY_HIGH -7 / RUNPTY(6) / # define UV_PRIORITY_HIGHEST -10 / RUNPTY(1) / #else # define UV_PRIORITY_LOW 19 # define UV_PRIORITY_BELOW_NORMAL 10 # define UV_PRIORITY_NORMAL 0 # define UV_PRIORITY_ABOVE_NORMAL -7 # define UV_PRIORITY_HIGH -14 # define UV_PRIORITY_HIGHEST -20 #endif UV_EXTERN int uv_os_getpriority(uv_pid_t pid, int priority); UV_EXTERN int uv_os_setpriority(uv_pid_t pid, int priority); enum { UV_THREAD_PRIORITY_HIGHEST = 2, UV_THREAD_PRIORITY_ABOVE_NORMAL = 1, UV_THREAD_PRIORITY_NORMAL = 0, UV_THREAD_PRIORITY_BELOW_NORMAL = -1, UV_THREAD_PRIORITY_LOWEST = -2, }; UV_EXTERN int uv_thread_getpriority(uv_thread_t tid, int* priority); UV_EXTERN int uv_thread_setpriority(uv_thread_t tid, int priority); UV_EXTERN unsigned int uv_available_parallelism(void); UV_EXTERN int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count); UV_EXTERN void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count); UV_EXTERN int uv_cpumask_size(void); UV_EXTERN int uv_interface_addresses(uv_interface_address_t** addresses, int* count); UV_EXTERN void uv_free_interface_addresses(uv_interface_address_t* addresses, int count); struct uv_env_item_s { char* name; char* value; }; UV_EXTERN int uv_os_environ(uv_env_item_t** envitems, int* count); UV_EXTERN void uv_os_free_environ(uv_env_item_t* envitems, int count); UV_EXTERN int uv_os_getenv(const char* name, char* buffer, size_t* size); UV_EXTERN int uv_os_setenv(const char* name, const char* value); UV_EXTERN int uv_os_unsetenv(const char* name); #ifdef MAXHOSTNAMELEN # define UV_MAXHOSTNAMESIZE (MAXHOSTNAMELEN + 1) #else /* Fallback for the maximum hostname size, including the null terminator. The Windows gethostname() documentation states that 256 bytes will always be large enough to hold the null-terminated hostname. / # define UV_MAXHOSTNAMESIZE 256 #endif UV_EXTERN int uv_os_gethostname(char buffer, size_t* size); UV_EXTERN int uv_os_uname(uv_utsname_t* buffer); struct uv_metrics_s { uint64_t loop_count; uint64_t events; uint64_t events_waiting; /* private / uint64_t reserved[13]; }; UV_EXTERN int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics); UV_EXTERN uint64_t uv_metrics_idle_time(uv_loop_t* loop); typedef enum { UV_FS_UNKNOWN = -1, UV_FS_CUSTOM, UV_FS_OPEN, UV_FS_CLOSE, UV_FS_READ, UV_FS_WRITE, UV_FS_SENDFILE, UV_FS_STAT, UV_FS_LSTAT, UV_FS_FSTAT, UV_FS_FTRUNCATE, UV_FS_UTIME, UV_FS_FUTIME, UV_FS_ACCESS, UV_FS_CHMOD, UV_FS_FCHMOD, UV_FS_FSYNC, UV_FS_FDATASYNC, UV_FS_UNLINK, UV_FS_RMDIR, UV_FS_MKDIR, UV_FS_MKDTEMP, UV_FS_RENAME, UV_FS_SCANDIR, UV_FS_LINK, UV_FS_SYMLINK, UV_FS_READLINK, UV_FS_CHOWN, UV_FS_FCHOWN, UV_FS_REALPATH, UV_FS_COPYFILE, UV_FS_LCHOWN, UV_FS_OPENDIR, UV_FS_READDIR, UV_FS_CLOSEDIR, UV_FS_STATFS, UV_FS_MKSTEMP, UV_FS_LUTIME } uv_fs_type; struct uv_dir_s { uv_dirent_t* dirents; size_t nentries; void* reserved[4]; UV_DIR_PRIVATE_FIELDS }; /* uv_fs_t is a subclass of uv_req_t. / struct uv_fs_s { UV_REQ_FIELDS uv_fs_type fs_type; uv_loop_t loop; uv_fs_cb cb; ssize_t result; void* ptr; const char* path; uv_stat_t statbuf; /* Stores the result of uv_fs_stat() and uv_fs_fstat(). / UV_FS_PRIVATE_FIELDS }; UV_EXTERN uv_fs_type uv_fs_get_type(const uv_fs_t); UV_EXTERN ssize_t uv_fs_get_result(const uv_fs_t); UV_EXTERN int uv_fs_get_system_error(const uv_fs_t); UV_EXTERN void* uv_fs_get_ptr(const uv_fs_t); UV_EXTERN const char uv_fs_get_path(const uv_fs_t); UV_EXTERN uv_stat_t uv_fs_get_statbuf(uv_fs_t); UV_EXTERN void uv_fs_req_cleanup(uv_fs_t req); UV_EXTERN int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb); UV_EXTERN int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int mode, uv_fs_cb cb); UV_EXTERN int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb); UV_EXTERN int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb); UV_EXTERN int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb); /* * This flag can be used with uv_fs_copyfile() to return an error if the * destination already exists. / #define UV_FS_COPYFILE_EXCL 0x0001 / * This flag can be used with uv_fs_copyfile() to attempt to create a reflink. * If copy-on-write is not supported, a fallback copy mechanism is used. / #define UV_FS_COPYFILE_FICLONE 0x0002 / * This flag can be used with uv_fs_copyfile() to attempt to create a reflink. * If copy-on-write is not supported, an error is returned. / #define UV_FS_COPYFILE_FICLONE_FORCE 0x0004 UV_EXTERN int uv_fs_copyfile(uv_loop_t loop, uv_fs_t* req, const char* path, const char* new_path, int flags, uv_fs_cb cb); UV_EXTERN int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb); UV_EXTERN int uv_fs_mkdtemp(uv_loop_t* loop, uv_fs_t* req, const char* tpl, uv_fs_cb cb); UV_EXTERN int uv_fs_mkstemp(uv_loop_t* loop, uv_fs_t* req, const char* tpl, uv_fs_cb cb); UV_EXTERN int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb); UV_EXTERN int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, uv_fs_cb cb); UV_EXTERN int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent); UV_EXTERN int uv_fs_opendir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb); UV_EXTERN int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, uv_dir_t* dir, uv_fs_cb cb); UV_EXTERN int uv_fs_closedir(uv_loop_t* loop, uv_fs_t* req, uv_dir_t* dir, uv_fs_cb cb); UV_EXTERN int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb); UV_EXTERN int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb); UV_EXTERN int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb); UV_EXTERN int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb); UV_EXTERN int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb); UV_EXTERN int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file, int64_t offset, uv_fs_cb cb); UV_EXTERN int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd, uv_file in_fd, int64_t in_offset, size_t length, uv_fs_cb cb); UV_EXTERN int uv_fs_access(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb); UV_EXTERN int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb); UV_EXTERN int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, double mtime, uv_fs_cb cb); UV_EXTERN int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file, double atime, double mtime, uv_fs_cb cb); UV_EXTERN int uv_fs_lutime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, double mtime, uv_fs_cb cb); UV_EXTERN int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb); UV_EXTERN int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb); /* * This flag can be used with uv_fs_symlink() on Windows to specify whether * path argument points to a directory. / #define UV_FS_SYMLINK_DIR 0x0001 / * This flag can be used with uv_fs_symlink() on Windows to specify whether * the symlink is to be created using junction points. / #define UV_FS_SYMLINK_JUNCTION 0x0002 UV_EXTERN int uv_fs_symlink(uv_loop_t loop, uv_fs_t* req, const char* path, const char* new_path, int flags, uv_fs_cb cb); UV_EXTERN int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb); UV_EXTERN int uv_fs_realpath(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb); UV_EXTERN int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode, uv_fs_cb cb); UV_EXTERN int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb); UV_EXTERN int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb); UV_EXTERN int uv_fs_lchown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb); UV_EXTERN int uv_fs_statfs(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb); enum uv_fs_event { UV_RENAME = 1, UV_CHANGE = 2 }; struct uv_fs_event_s { UV_HANDLE_FIELDS /* private / char path; UV_FS_EVENT_PRIVATE_FIELDS }; /* * uv_fs_stat() based polling file watcher. / struct uv_fs_poll_s { UV_HANDLE_FIELDS / Private, don't touch. / void poll_ctx; }; UV_EXTERN int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle); UV_EXTERN int uv_fs_poll_start(uv_fs_poll_t* handle, uv_fs_poll_cb poll_cb, const char* path, unsigned int interval); UV_EXTERN int uv_fs_poll_stop(uv_fs_poll_t* handle); UV_EXTERN int uv_fs_poll_getpath(uv_fs_poll_t* handle, char* buffer, size_t* size); struct uv_signal_s { UV_HANDLE_FIELDS uv_signal_cb signal_cb; int signum; UV_SIGNAL_PRIVATE_FIELDS }; UV_EXTERN int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle); UV_EXTERN int uv_signal_start(uv_signal_t* handle, uv_signal_cb signal_cb, int signum); UV_EXTERN int uv_signal_start_oneshot(uv_signal_t* handle, uv_signal_cb signal_cb, int signum); UV_EXTERN int uv_signal_stop(uv_signal_t* handle); UV_EXTERN void uv_loadavg(double avg[3]); /* * Flags to be passed to uv_fs_event_start(). / enum uv_fs_event_flags { / * By default, if the fs event watcher is given a directory name, we will * watch for all events in that directory. This flags overrides this behavior * and makes fs_event report only changes to the directory entry itself. This * flag does not affect individual files watched. * This flag is currently not implemented yet on any backend. / UV_FS_EVENT_WATCH_ENTRY = 1, / * By default uv_fs_event will try to use a kernel interface such as inotify * or kqueue to detect events. This may not work on remote filesystems such * as NFS mounts. This flag makes fs_event fall back to calling stat() on a * regular interval. * This flag is currently not implemented yet on any backend. / UV_FS_EVENT_STAT = 2, / * By default, event watcher, when watching directory, is not registering * (is ignoring) changes in it's subdirectories. * This flag will override this behaviour on platforms that support it. / UV_FS_EVENT_RECURSIVE = 4 }; UV_EXTERN int uv_fs_event_init(uv_loop_t loop, uv_fs_event_t* handle); UV_EXTERN int uv_fs_event_start(uv_fs_event_t* handle, uv_fs_event_cb cb, const char* path, unsigned int flags); UV_EXTERN int uv_fs_event_stop(uv_fs_event_t* handle); UV_EXTERN int uv_fs_event_getpath(uv_fs_event_t* handle, char* buffer, size_t* size); UV_EXTERN int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr); UV_EXTERN int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr); UV_EXTERN int uv_ip4_name(const struct sockaddr_in* src, char* dst, size_t size); UV_EXTERN int uv_ip6_name(const struct sockaddr_in6* src, char* dst, size_t size); UV_EXTERN int uv_ip_name(const struct sockaddr* src, char* dst, size_t size); UV_EXTERN int uv_inet_ntop(int af, const void* src, char* dst, size_t size); UV_EXTERN int uv_inet_pton(int af, const char* src, void* dst); struct uv_random_s { UV_REQ_FIELDS /* read-only / uv_loop_t loop; /* private / int status; void buf; size_t buflen; uv_random_cb cb; struct uv__work work_req; }; UV_EXTERN int uv_random(uv_loop_t* loop, uv_random_t* req, void buf, size_t buflen, unsigned flags, / For future extension; must be 0. / uv_random_cb cb); #if defined(IF_NAMESIZE) # define UV_IF_NAMESIZE (IF_NAMESIZE + 1) #elif defined(IFNAMSIZ) # define UV_IF_NAMESIZE (IFNAMSIZ + 1) #else # define UV_IF_NAMESIZE (16 + 1) #endif UV_EXTERN int uv_if_indextoname(unsigned int ifindex, char buffer, size_t* size); UV_EXTERN int uv_if_indextoiid(unsigned int ifindex, char* buffer, size_t* size); UV_EXTERN int uv_exepath(char* buffer, size_t* size); UV_EXTERN int uv_cwd(char* buffer, size_t* size); UV_EXTERN int uv_chdir(const char* dir); UV_EXTERN uint64_t uv_get_free_memory(void); UV_EXTERN uint64_t uv_get_total_memory(void); UV_EXTERN uint64_t uv_get_constrained_memory(void); UV_EXTERN uint64_t uv_get_available_memory(void); UV_EXTERN int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts); UV_EXTERN uint64_t uv_hrtime(void); UV_EXTERN void uv_sleep(unsigned int msec); UV_EXTERN void uv_disable_stdio_inheritance(void); UV_EXTERN int uv_dlopen(const char* filename, uv_lib_t* lib); UV_EXTERN void uv_dlclose(uv_lib_t* lib); UV_EXTERN int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr); UV_EXTERN const char* uv_dlerror(const uv_lib_t* lib); UV_EXTERN int uv_mutex_init(uv_mutex_t* handle); UV_EXTERN int uv_mutex_init_recursive(uv_mutex_t* handle); UV_EXTERN void uv_mutex_destroy(uv_mutex_t* handle); UV_EXTERN void uv_mutex_lock(uv_mutex_t* handle); UV_EXTERN int uv_mutex_trylock(uv_mutex_t* handle); UV_EXTERN void uv_mutex_unlock(uv_mutex_t* handle); UV_EXTERN int uv_rwlock_init(uv_rwlock_t* rwlock); UV_EXTERN void uv_rwlock_destroy(uv_rwlock_t* rwlock); UV_EXTERN void uv_rwlock_rdlock(uv_rwlock_t* rwlock); UV_EXTERN int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock); UV_EXTERN void uv_rwlock_rdunlock(uv_rwlock_t* rwlock); UV_EXTERN void uv_rwlock_wrlock(uv_rwlock_t* rwlock); UV_EXTERN int uv_rwlock_trywrlock(uv_rwlock_t* rwlock); UV_EXTERN void uv_rwlock_wrunlock(uv_rwlock_t* rwlock); UV_EXTERN int uv_sem_init(uv_sem_t* sem, unsigned int value); UV_EXTERN void uv_sem_destroy(uv_sem_t* sem); UV_EXTERN void uv_sem_post(uv_sem_t* sem); UV_EXTERN void uv_sem_wait(uv_sem_t* sem); UV_EXTERN int uv_sem_trywait(uv_sem_t* sem); UV_EXTERN int uv_cond_init(uv_cond_t* cond); UV_EXTERN void uv_cond_destroy(uv_cond_t* cond); UV_EXTERN void uv_cond_signal(uv_cond_t* cond); UV_EXTERN void uv_cond_broadcast(uv_cond_t* cond); UV_EXTERN int uv_barrier_init(uv_barrier_t* barrier, unsigned int count); UV_EXTERN void uv_barrier_destroy(uv_barrier_t* barrier); UV_EXTERN int uv_barrier_wait(uv_barrier_t* barrier); UV_EXTERN void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex); UV_EXTERN int uv_cond_timedwait(uv_cond_t* cond, uv_mutex_t* mutex, uint64_t timeout); UV_EXTERN void uv_once(uv_once_t* guard, void (callback)(void)); UV_EXTERN int uv_key_create(uv_key_t key); UV_EXTERN void uv_key_delete(uv_key_t* key); UV_EXTERN void* uv_key_get(uv_key_t* key); UV_EXTERN void uv_key_set(uv_key_t* key, void* value); UV_EXTERN int uv_gettimeofday(uv_timeval64_t* tv); typedef void (uv_thread_cb)(void arg); UV_EXTERN int uv_thread_create(uv_thread_t* tid, uv_thread_cb entry, void* arg); typedef enum { UV_THREAD_NO_FLAGS = 0x00, UV_THREAD_HAS_STACK_SIZE = 0x01 } uv_thread_create_flags; struct uv_thread_options_s { unsigned int flags; size_t stack_size; /* More fields may be added at any time. / }; typedef struct uv_thread_options_s uv_thread_options_t; UV_EXTERN int uv_thread_create_ex(uv_thread_t tid, const uv_thread_options_t* params, uv_thread_cb entry, void* arg); UV_EXTERN int uv_thread_setaffinity(uv_thread_t* tid, char* cpumask, char* oldmask, size_t mask_size); UV_EXTERN int uv_thread_getaffinity(uv_thread_t* tid, char* cpumask, size_t mask_size); UV_EXTERN int uv_thread_getcpu(void); UV_EXTERN uv_thread_t uv_thread_self(void); UV_EXTERN int uv_thread_join(uv_thread_t tid); UV_EXTERN int uv_thread_equal(const uv_thread_t t1, const uv_thread_t* t2); /* The presence of these unions force similar struct layout. / #define XX(_, name) uv_ ## name ## _t name; union uv_any_handle { UV_HANDLE_TYPE_MAP(XX) }; union uv_any_req { UV_REQ_TYPE_MAP(XX) }; #undef XX struct uv_loop_s { / User data - use this for whatever. / void data; /* Loop reference counting. / unsigned int active_handles; struct uv__queue handle_queue; union { void unused; unsigned int count; } active_reqs; /* Internal storage for future extensions. / void internal_fields; /* Internal flag to signal loop stop. / unsigned int stop_flag; UV_LOOP_PRIVATE_FIELDS }; UV_EXTERN void uv_loop_get_data(const uv_loop_t); UV_EXTERN void uv_loop_set_data(uv_loop_t, void* data); /* Unicode utilities needed for dealing with Windows. / UV_EXTERN size_t uv_utf16_length_as_wtf8(const uint16_t utf16, ssize_t utf16_len); UV_EXTERN int uv_utf16_to_wtf8(const uint16_t* utf16, ssize_t utf16_len, char** wtf8_ptr, size_t* wtf8_len_ptr); UV_EXTERN ssize_t uv_wtf8_length_as_utf16(const char* wtf8); UV_EXTERN void uv_wtf8_to_utf16(const char* wtf8, uint16_t* utf16, size_t utf16_len); /* Don't export the private CPP symbols. / #undef UV_HANDLE_TYPE_PRIVATE #undef UV_REQ_TYPE_PRIVATE #undef UV_REQ_PRIVATE_FIELDS #undef UV_STREAM_PRIVATE_FIELDS #undef UV_TCP_PRIVATE_FIELDS #undef UV_PREPARE_PRIVATE_FIELDS #undef UV_CHECK_PRIVATE_FIELDS #undef UV_IDLE_PRIVATE_FIELDS #undef UV_ASYNC_PRIVATE_FIELDS #undef UV_TIMER_PRIVATE_FIELDS #undef UV_GETADDRINFO_PRIVATE_FIELDS #undef UV_GETNAMEINFO_PRIVATE_FIELDS #undef UV_FS_REQ_PRIVATE_FIELDS #undef UV_WORK_PRIVATE_FIELDS #undef UV_FS_EVENT_PRIVATE_FIELDS #undef UV_SIGNAL_PRIVATE_FIELDS #undef UV_LOOP_PRIVATE_FIELDS #undef UV_LOOP_PRIVATE_PLATFORM_FIELDS #undef UV__ERR #ifdef __cplusplus } #endif #endif / UV_H */	70.2 KB	2025-03-03 12:36
📄 v8-array-buffer.h // Copyright 2021 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. #ifndef INCLUDE_V8_ARRAY_BUFFER_H_ #define INCLUDE_V8_ARRAY_BUFFER_H_ #include <stddef.h> #include <memory> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class SharedArrayBuffer; #ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT // The number of required internal fields can be defined by embedder. #define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2 #endif enum class ArrayBufferCreationMode { kInternalized, kExternalized }; /** * A wrapper around the backing store (i.e. the raw memory) of an array buffer. * See a document linked in http://crbug.com/v8/9908 for more information. * * The allocation and destruction of backing stores is generally managed by * V8. Clients should always use standard C++ memory ownership types (i.e. * std::unique_ptr and std::shared_ptr) to manage lifetimes of backing stores * properly, since V8 internal objects may alias backing stores. * * This object does not keep the underlying \|ArrayBuffer::Allocator\| alive by * default. Use Isolate::CreateParams::array_buffer_allocator_shared when * creating the Isolate to make it hold a reference to the allocator itself. / class V8_EXPORT BackingStore : public v8::internal::BackingStoreBase { public: ~BackingStore(); /* * Return a pointer to the beginning of the memory block for this backing * store. The pointer is only valid as long as this backing store object * lives. / void Data() const; /** * The length (in bytes) of this backing store. / size_t ByteLength() const; /* * The maximum length (in bytes) that this backing store may grow to. * * If this backing store was created for a resizable ArrayBuffer or a growable * SharedArrayBuffer, it is >= ByteLength(). Otherwise it is == * ByteLength(). / size_t MaxByteLength() const; /* * Indicates whether the backing store was created for an ArrayBuffer or * a SharedArrayBuffer. / bool IsShared() const; /* * Indicates whether the backing store was created for a resizable ArrayBuffer * or a growable SharedArrayBuffer, and thus may be resized by user JavaScript * code. / bool IsResizableByUserJavaScript() const; /* * Prevent implicit instantiation of operator delete with size_t argument. * The size_t argument would be incorrect because ptr points to the * internal BackingStore object. / void operator delete(void ptr) { ::operator delete(ptr); } /** * Wrapper around ArrayBuffer::Allocator::Reallocate that preserves IsShared. * Assumes that the backing_store was allocated by the ArrayBuffer allocator * of the given isolate. / static std::unique_ptr<BackingStore> Reallocate( v8::Isolate isolate, std::unique_ptr<BackingStore> backing_store, size_t byte_length); /** * This callback is used only if the memory block for a BackingStore cannot be * allocated with an ArrayBuffer::Allocator. In such cases the destructor of * the BackingStore invokes the callback to free the memory block. / using DeleterCallback = void ()(void* data, size_t length, void* deleter_data); /** * If the memory block of a BackingStore is static or is managed manually, * then this empty deleter along with nullptr deleter_data can be passed to * ArrayBuffer::NewBackingStore to indicate that. * * The manually managed case should be used with caution and only when it * is guaranteed that the memory block freeing happens after detaching its * ArrayBuffer. / static void EmptyDeleter(void data, size_t length, void* deleter_data); private: /** * See [Shared]ArrayBuffer::GetBackingStore and * [Shared]ArrayBuffer::NewBackingStore. / BackingStore(); }; #if !defined(V8_IMMINENT_DEPRECATION_WARNINGS) // Use v8::BackingStore::DeleterCallback instead. using BackingStoreDeleterCallback = void ()(void* data, size_t length, void* deleter_data); #endif /** * An instance of the built-in ArrayBuffer constructor (ES6 draft 15.13.5). / class V8_EXPORT ArrayBuffer : public Object { public: /* * A thread-safe allocator that V8 uses to allocate \|ArrayBuffer\|'s memory. * The allocator is a global V8 setting. It has to be set via * Isolate::CreateParams. * * Memory allocated through this allocator by V8 is accounted for as external * memory by V8. Note that V8 keeps track of the memory for all internalized * \|ArrayBuffer\|s. Responsibility for tracking external memory (using * Isolate::AdjustAmountOfExternalAllocatedMemory) is handed over to the * embedder upon externalization and taken over upon internalization (creating * an internalized buffer from an existing buffer). * * Note that it is unsafe to call back into V8 from any of the allocator * functions. / class V8_EXPORT Allocator { public: virtual ~Allocator() = default; /* * Allocate \|length\| bytes. Return nullptr if allocation is not successful. * Memory should be initialized to zeroes. / virtual void Allocate(size_t length) = 0; /** * Allocate \|length\| bytes. Return nullptr if allocation is not successful. * Memory does not have to be initialized. / virtual void AllocateUninitialized(size_t length) = 0; /** * Free the memory block of size \|length\|, pointed to by \|data\|. * That memory is guaranteed to be previously allocated by \|Allocate\|. / virtual void Free(void data, size_t length) = 0; /** * Reallocate the memory block of size \|old_length\| to a memory block of * size \|new_length\| by expanding, contracting, or copying the existing * memory block. If \|new_length\| > \|old_length\|, then the new part of * the memory must be initialized to zeros. Return nullptr if reallocation * is not successful. * * The caller guarantees that the memory block was previously allocated * using Allocate or AllocateUninitialized. * * The default implementation allocates a new block and copies data. / virtual void Reallocate(void* data, size_t old_length, size_t new_length); /** * ArrayBuffer allocation mode. kNormal is a malloc/free style allocation, * while kReservation is for larger allocations with the ability to set * access permissions. / enum class AllocationMode { kNormal, kReservation }; /* * Convenience allocator. * * When the sandbox is enabled, this allocator will allocate its backing * memory inside the sandbox. Otherwise, it will rely on malloc/free. * * Caller takes ownership, i.e. the returned object needs to be freed using * \|delete allocator\| once it is no longer in use. / static Allocator NewDefaultAllocator(); }; /** * Data length in bytes. / size_t ByteLength() const; /* * Maximum length in bytes. / size_t MaxByteLength() const; /* * Create a new ArrayBuffer. Allocate \|byte_length\| bytes. * Allocated memory will be owned by a created ArrayBuffer and * will be deallocated when it is garbage-collected, * unless the object is externalized. / static Local<ArrayBuffer> New(Isolate isolate, size_t byte_length); /** * Create a new ArrayBuffer with an existing backing store. * The created array keeps a reference to the backing store until the array * is garbage collected. Note that the IsExternal bit does not affect this * reference from the array to the backing store. * * In future IsExternal bit will be removed. Until then the bit is set as * follows. If the backing store does not own the underlying buffer, then * the array is created in externalized state. Otherwise, the array is created * in internalized state. In the latter case the array can be transitioned * to the externalized state using Externalize(backing_store). / static Local<ArrayBuffer> New(Isolate isolate, std::shared_ptr<BackingStore> backing_store); /** * Returns a new standalone BackingStore that is allocated using the array * buffer allocator of the isolate. The result can be later passed to * ArrayBuffer::New. * * If the allocator returns nullptr, then the function may cause GCs in the * given isolate and re-try the allocation. If GCs do not help, then the * function will crash with an out-of-memory error. / static std::unique_ptr<BackingStore> NewBackingStore(Isolate isolate, size_t byte_length); /** * Returns a new standalone BackingStore that takes over the ownership of * the given buffer. The destructor of the BackingStore invokes the given * deleter callback. * * The result can be later passed to ArrayBuffer::New. The raw pointer * to the buffer must not be passed again to any V8 API function. / static std::unique_ptr<BackingStore> NewBackingStore( void data, size_t byte_length, v8::BackingStore::DeleterCallback deleter, void* deleter_data); /** * Returns a new resizable standalone BackingStore that is allocated using the * array buffer allocator of the isolate. The result can be later passed to * ArrayBuffer::New. * * \|byte_length\| must be <= \|max_byte_length\|. * * This function is usable without an isolate. Unlike \|NewBackingStore\| calls * with an isolate, GCs cannot be triggered, and there are no * retries. Allocation failure will cause the function to crash with an * out-of-memory error. / static std::unique_ptr<BackingStore> NewResizableBackingStore( size_t byte_length, size_t max_byte_length); /* * Returns true if this ArrayBuffer may be detached. / bool IsDetachable() const; /* * Returns true if this ArrayBuffer has been detached. / bool WasDetached() const; /* * Detaches this ArrayBuffer and all its views (typed arrays). * Detaching sets the byte length of the buffer and all typed arrays to zero, * preventing JavaScript from ever accessing underlying backing store. * ArrayBuffer should have been externalized and must be detachable. / V8_DEPRECATE_SOON( "Use the version which takes a key parameter (passing a null handle is " "ok).") void Detach(); /* * Detaches this ArrayBuffer and all its views (typed arrays). * Detaching sets the byte length of the buffer and all typed arrays to zero, * preventing JavaScript from ever accessing underlying backing store. * ArrayBuffer should have been externalized and must be detachable. Returns * Nothing if the key didn't pass the [[ArrayBufferDetachKey]] check, * Just(true) otherwise. / V8_WARN_UNUSED_RESULT Maybe<bool> Detach(v8::Local<v8::Value> key); /* * Sets the ArrayBufferDetachKey. / void SetDetachKey(v8::Local<v8::Value> key); /* * Get a shared pointer to the backing store of this array buffer. This * pointer coordinates the lifetime management of the internal storage * with any live ArrayBuffers on the heap, even across isolates. The embedder * should not attempt to manage lifetime of the storage through other means. * * The returned shared pointer will not be empty, even if the ArrayBuffer has * been detached. Use \|WasDetached\| to tell if it has been detached instead. / std::shared_ptr<BackingStore> GetBackingStore(); /* * More efficient shortcut for * GetBackingStore()->IsResizableByUserJavaScript(). / bool IsResizableByUserJavaScript() const; /* * More efficient shortcut for GetBackingStore()->Data(). The returned pointer * is valid as long as the ArrayBuffer is alive. / void Data() const; V8_INLINE static ArrayBuffer* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<ArrayBuffer>(value); } static const int kInternalFieldCount = V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT; static const int kEmbedderFieldCount = V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT; private: ArrayBuffer(); static void CheckCast(Value obj); }; #ifndef V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT // The number of required internal fields can be defined by embedder. #define V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT 2 #endif /** * A base class for an instance of one of "views" over ArrayBuffer, * including TypedArrays and DataView (ES6 draft 15.13). / class V8_EXPORT ArrayBufferView : public Object { public: /* * Returns underlying ArrayBuffer. / Local<ArrayBuffer> Buffer(); /* * Byte offset in \|Buffer\|. / size_t ByteOffset(); /* * Size of a view in bytes. / size_t ByteLength(); /* * Copy the contents of the ArrayBufferView's buffer to an embedder defined * memory without additional overhead that calling ArrayBufferView::Buffer * might incur. * * Will write at most min(\|byte_length\|, ByteLength) bytes starting at * ByteOffset of the underlying buffer to the memory starting at \|dest\|. * Returns the number of bytes actually written. / size_t CopyContents(void dest, size_t byte_length); /** * Returns true if ArrayBufferView's backing ArrayBuffer has already been * allocated. / bool HasBuffer() const; V8_INLINE static ArrayBufferView Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<ArrayBufferView>(value); } static const int kInternalFieldCount = V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT; static const int kEmbedderFieldCount = V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT; private: ArrayBufferView(); static void CheckCast(Value obj); }; /** * An instance of DataView constructor (ES6 draft 15.13.7). / class V8_EXPORT DataView : public ArrayBufferView { public: static Local<DataView> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<DataView> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static DataView Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<DataView>(value); } private: DataView(); static void CheckCast(Value obj); }; /** * An instance of the built-in SharedArrayBuffer constructor. / class V8_EXPORT SharedArrayBuffer : public Object { public: /* * Data length in bytes. / size_t ByteLength() const; /* * Maximum length in bytes. / size_t MaxByteLength() const; /* * Create a new SharedArrayBuffer. Allocate \|byte_length\| bytes. * Allocated memory will be owned by a created SharedArrayBuffer and * will be deallocated when it is garbage-collected, * unless the object is externalized. / static Local<SharedArrayBuffer> New(Isolate isolate, size_t byte_length); /** * Create a new SharedArrayBuffer with an existing backing store. * The created array keeps a reference to the backing store until the array * is garbage collected. Note that the IsExternal bit does not affect this * reference from the array to the backing store. * * In future IsExternal bit will be removed. Until then the bit is set as * follows. If the backing store does not own the underlying buffer, then * the array is created in externalized state. Otherwise, the array is created * in internalized state. In the latter case the array can be transitioned * to the externalized state using Externalize(backing_store). / static Local<SharedArrayBuffer> New( Isolate isolate, std::shared_ptr<BackingStore> backing_store); /** * Returns a new standalone BackingStore that is allocated using the array * buffer allocator of the isolate. The result can be later passed to * SharedArrayBuffer::New. * * If the allocator returns nullptr, then the function may cause GCs in the * given isolate and re-try the allocation. If GCs do not help, then the * function will crash with an out-of-memory error. / static std::unique_ptr<BackingStore> NewBackingStore(Isolate isolate, size_t byte_length); /** * Returns a new standalone BackingStore that takes over the ownership of * the given buffer. The destructor of the BackingStore invokes the given * deleter callback. * * The result can be later passed to SharedArrayBuffer::New. The raw pointer * to the buffer must not be passed again to any V8 functions. / static std::unique_ptr<BackingStore> NewBackingStore( void data, size_t byte_length, v8::BackingStore::DeleterCallback deleter, void* deleter_data); /** * Get a shared pointer to the backing store of this array buffer. This * pointer coordinates the lifetime management of the internal storage * with any live ArrayBuffers on the heap, even across isolates. The embedder * should not attempt to manage lifetime of the storage through other means. / std::shared_ptr<BackingStore> GetBackingStore(); /* * More efficient shortcut for GetBackingStore()->Data(). The returned pointer * is valid as long as the ArrayBuffer is alive. / void Data() const; V8_INLINE static SharedArrayBuffer* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<SharedArrayBuffer>(value); } static const int kInternalFieldCount = V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT; private: SharedArrayBuffer(); static void CheckCast(Value obj); }; } // namespace v8 #endif // INCLUDE_V8_ARRAY_BUFFER_H_	17.6 KB	2025-03-03 12:36
📄 v8-callbacks.h // Copyright 2021 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. #ifndef INCLUDE_V8_ISOLATE_CALLBACKS_H_ #define INCLUDE_V8_ISOLATE_CALLBACKS_H_ #include <stddef.h> #include <functional> #include <string> #include "cppgc/common.h" #include "v8-data.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-promise.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) #if defined(V8_OS_WIN) struct _EXCEPTION_POINTERS; #endif namespace v8 { template <typename T> class FunctionCallbackInfo; class Isolate; class Message; class Module; class Object; class Promise; class ScriptOrModule; class String; class UnboundScript; class Value; /** * A JIT code event is issued each time code is added, moved or removed. * * \note removal events are not currently issued. / struct JitCodeEvent { enum EventType { CODE_ADDED, CODE_MOVED, CODE_REMOVED, CODE_ADD_LINE_POS_INFO, CODE_START_LINE_INFO_RECORDING, CODE_END_LINE_INFO_RECORDING }; // Definition of the code position type. The "POSITION" type means the place // in the source code which are of interest when making stack traces to // pin-point the source location of a stack frame as close as possible. // The "STATEMENT_POSITION" means the place at the beginning of each // statement, and is used to indicate possible break locations. enum PositionType { POSITION, STATEMENT_POSITION }; // There are three different kinds of CodeType, one for JIT code generated // by the optimizing compiler, one for byte code generated for the // interpreter, and one for code generated from Wasm. For JIT_CODE and // WASM_CODE, \|code_start\| points to the beginning of jitted assembly code, // while for BYTE_CODE events, \|code_start\| points to the first bytecode of // the interpreted function. enum CodeType { BYTE_CODE, JIT_CODE, WASM_CODE }; // Type of event. EventType type; CodeType code_type; // Start of the instructions. void code_start; // Size of the instructions. size_t code_len; // Script info for CODE_ADDED event. Local<UnboundScript> script; // User-defined data for _LINE_INFO_ event. It's used to hold the source // code line information which is returned from the // CODE_START_LINE_INFO_RECORDING event. And it's passed to subsequent // CODE_ADD_LINE_POS_INFO and CODE_END_LINE_INFO_RECORDING events. void* user_data; struct name_t { // Name of the object associated with the code, note that the string is not // zero-terminated. const char* str; // Number of chars in str. size_t len; }; struct line_info_t { // PC offset size_t offset; // Code position size_t pos; // The position type. PositionType position_type; }; struct wasm_source_info_t { // Source file name. const char* filename; // Length of filename. size_t filename_size; // Line number table, which maps offsets of JITted code to line numbers of // source file. const line_info_t* line_number_table; // Number of entries in the line number table. size_t line_number_table_size; }; wasm_source_info_t* wasm_source_info = nullptr; union { // Only valid for CODE_ADDED. struct name_t name; // Only valid for CODE_ADD_LINE_POS_INFO struct line_info_t line_info; // New location of instructions. Only valid for CODE_MOVED. void* new_code_start; }; Isolate* isolate; }; /** * Option flags passed to the SetJitCodeEventHandler function. / enum JitCodeEventOptions { kJitCodeEventDefault = 0, // Generate callbacks for already existent code. kJitCodeEventEnumExisting = 1 }; /* * Callback function passed to SetJitCodeEventHandler. * * \param event code add, move or removal event. / using JitCodeEventHandler = void ()(const JitCodeEvent* event); // --- Garbage Collection Callbacks --- /** * Applications can register callback functions which will be called before and * after certain garbage collection operations. Allocations are not allowed in * the callback functions, you therefore cannot manipulate objects (set or * delete properties for example) since it is possible such operations will * result in the allocation of objects. * TODO(v8:12612): Deprecate kGCTypeMinorMarkSweep after updating blink. / enum GCType { kGCTypeScavenge = 1 << 0, kGCTypeMinorMarkSweep = 1 << 1, kGCTypeMinorMarkCompact V8_DEPRECATE_SOON( "Use kGCTypeMinorMarkSweep instead of kGCTypeMinorMarkCompact.") = kGCTypeMinorMarkSweep, kGCTypeMarkSweepCompact = 1 << 2, kGCTypeIncrementalMarking = 1 << 3, kGCTypeProcessWeakCallbacks = 1 << 4, kGCTypeAll = kGCTypeScavenge \| kGCTypeMinorMarkSweep \| kGCTypeMarkSweepCompact \| kGCTypeIncrementalMarking \| kGCTypeProcessWeakCallbacks }; /* * GCCallbackFlags is used to notify additional information about the GC * callback. * - kGCCallbackFlagConstructRetainedObjectInfos: The GC callback is for * constructing retained object infos. * - kGCCallbackFlagForced: The GC callback is for a forced GC for testing. * - kGCCallbackFlagSynchronousPhantomCallbackProcessing: The GC callback * is called synchronously without getting posted to an idle task. * - kGCCallbackFlagCollectAllAvailableGarbage: The GC callback is called * in a phase where V8 is trying to collect all available garbage * (e.g., handling a low memory notification). * - kGCCallbackScheduleIdleGarbageCollection: The GC callback is called to * trigger an idle garbage collection. / enum GCCallbackFlags { kNoGCCallbackFlags = 0, kGCCallbackFlagConstructRetainedObjectInfos = 1 << 1, kGCCallbackFlagForced = 1 << 2, kGCCallbackFlagSynchronousPhantomCallbackProcessing = 1 << 3, kGCCallbackFlagCollectAllAvailableGarbage = 1 << 4, kGCCallbackFlagCollectAllExternalMemory = 1 << 5, kGCCallbackScheduleIdleGarbageCollection = 1 << 6, }; using GCCallback = void ()(GCType type, GCCallbackFlags flags); using InterruptCallback = void ()(Isolate isolate, void* data); /** * This callback is invoked when the heap size is close to the heap limit and * V8 is likely to abort with out-of-memory error. * The callback can extend the heap limit by returning a value that is greater * than the current_heap_limit. The initial heap limit is the limit that was * set after heap setup. / using NearHeapLimitCallback = size_t ()(void* data, size_t current_heap_limit, size_t initial_heap_limit); /** * Callback function passed to SetUnhandledExceptionCallback. / #if defined(V8_OS_WIN) using UnhandledExceptionCallback = int ()(_EXCEPTION_POINTERS* exception_pointers); #endif // --- Counters Callbacks --- using CounterLookupCallback = int* ()(const char name); using CreateHistogramCallback = void* ()(const char name, int min, int max, size_t buckets); using AddHistogramSampleCallback = void ()(void histogram, int sample); // --- Exceptions --- using FatalErrorCallback = void ()(const char location, const char* message); struct OOMDetails { bool is_heap_oom = false; const char* detail = nullptr; }; using OOMErrorCallback = void ()(const char location, const OOMDetails& details); using MessageCallback = void ()(Local<Message> message, Local<Value> data); // --- Tracing --- enum LogEventStatus : int { kStart = 0, kEnd = 1, kStamp = 2 }; using LogEventCallback = void ()(const char* name, int /* LogEventStatus / status); // --- Crashkeys Callback --- enum class CrashKeyId { kIsolateAddress, kReadonlySpaceFirstPageAddress, kMapSpaceFirstPageAddress V8_ENUM_DEPRECATE_SOON("Map space got removed"), kOldSpaceFirstPageAddress, kCodeRangeBaseAddress, kCodeSpaceFirstPageAddress, kDumpType, kSnapshotChecksumCalculated, kSnapshotChecksumExpected, }; using AddCrashKeyCallback = void ()(CrashKeyId id, const std::string& value); // --- Enter/Leave Script Callback --- using BeforeCallEnteredCallback = void ()(Isolate); using CallCompletedCallback = void ()(Isolate); // --- AllowCodeGenerationFromStrings callbacks --- /** * Callback to check if code generation from strings is allowed. See * Context::AllowCodeGenerationFromStrings. / using AllowCodeGenerationFromStringsCallback = bool ()(Local<Context> context, Local<String> source); struct ModifyCodeGenerationFromStringsResult { // If true, proceed with the codegen algorithm. Otherwise, block it. bool codegen_allowed = false; // Overwrite the original source with this string, if present. // Use the original source if empty. // This field is considered only if codegen_allowed is true. MaybeLocal<String> modified_source; }; /** * Access type specification. / enum AccessType { ACCESS_GET, ACCESS_SET, ACCESS_HAS, ACCESS_DELETE, ACCESS_KEYS }; // --- Failed Access Check Callback --- using FailedAccessCheckCallback = void ()(Local<Object> target, AccessType type, Local<Value> data); /** * Callback to check if codegen is allowed from a source object, and convert * the source to string if necessary. See: ModifyCodeGenerationFromStrings. / using ModifyCodeGenerationFromStringsCallback = ModifyCodeGenerationFromStringsResult ()(Local<Context> context, Local<Value> source); using ModifyCodeGenerationFromStringsCallback2 = ModifyCodeGenerationFromStringsResult ()(Local<Context> context, Local<Value> source, bool is_code_like); // --- WebAssembly compilation callbacks --- using ExtensionCallback = bool ()(const FunctionCallbackInfo<Value>&); using AllowWasmCodeGenerationCallback = bool ()(Local<Context> context, Local<String> source); // --- Callback for APIs defined on v8-supported objects, but implemented // by the embedder. Example: WebAssembly.{compile\|instantiate}Streaming --- using ApiImplementationCallback = void ()(const FunctionCallbackInfo<Value>&); // --- Callback for WebAssembly.compileStreaming --- using WasmStreamingCallback = void ()(const FunctionCallbackInfo<Value>&); enum class WasmAsyncSuccess { kSuccess, kFail }; // --- Callback called when async WebAssembly operations finish --- using WasmAsyncResolvePromiseCallback = void ()( Isolate* isolate, Local<Context> context, Local<Promise::Resolver> resolver, Local<Value> result, WasmAsyncSuccess success); // --- Callback for loading source map file for Wasm profiling support using WasmLoadSourceMapCallback = Local<String> ()(Isolate isolate, const char* name); // --- Callback for checking if WebAssembly imported strings are enabled --- using WasmImportedStringsEnabledCallback = bool ()(Local<Context> context); // --- Callback for checking if the SharedArrayBuffer constructor is enabled --- using SharedArrayBufferConstructorEnabledCallback = bool ()(Local<Context> context); // --- Callback for checking if the compile hints magic comments are enabled --- using JavaScriptCompileHintsMagicEnabledCallback = bool ()(Local<Context> context); // --- Callback for checking if WebAssembly JSPI is enabled --- using WasmJSPIEnabledCallback = bool ()(Local<Context> context); /** * HostImportModuleDynamicallyCallback is called when we * require the embedder to load a module. This is used as part of the dynamic * import syntax. * * The referrer contains metadata about the script/module that calls * import. * * The specifier is the name of the module that should be imported. * * The import_attributes are import attributes for this request in the form: * [key1, value1, key2, value2, ...] where the keys and values are of type * v8::String. Note, unlike the FixedArray passed to ResolveModuleCallback and * returned from ModuleRequest::GetImportAssertions(), this array does not * contain the source Locations of the attributes. * * The embedder must compile, instantiate, evaluate the Module, and * obtain its namespace object. * * The Promise returned from this function is forwarded to userland * JavaScript. The embedder must resolve this promise with the module * namespace object. In case of an exception, the embedder must reject * this promise with the exception. If the promise creation itself * fails (e.g. due to stack overflow), the embedder must propagate * that exception by returning an empty MaybeLocal. / using HostImportModuleDynamicallyCallback = MaybeLocal<Promise> ()( Local<Context> context, Local<Data> host_defined_options, Local<Value> resource_name, Local<String> specifier, Local<FixedArray> import_attributes); /** * Callback for requesting a compile hint for a function from the embedder. The * first parameter is the position of the function in source code and the second * parameter is embedder data to be passed back. / using CompileHintCallback = bool ()(int, void); /* * HostInitializeImportMetaObjectCallback is called the first time import.meta * is accessed for a module. Subsequent access will reuse the same value. * * The method combines two implementation-defined abstract operations into one: * HostGetImportMetaProperties and HostFinalizeImportMeta. * * The embedder should use v8::Object::CreateDataProperty to add properties on * the meta object. / using HostInitializeImportMetaObjectCallback = void ()(Local<Context> context, Local<Module> module, Local<Object> meta); /** * HostCreateShadowRealmContextCallback is called each time a ShadowRealm is * being constructed in the initiator_context. * * The method combines Context creation and implementation defined abstract * operation HostInitializeShadowRealm into one. * * The embedder should use v8::Context::New or v8::Context:NewFromSnapshot to * create a new context. If the creation fails, the embedder must propagate * that exception by returning an empty MaybeLocal. / using HostCreateShadowRealmContextCallback = MaybeLocal<Context> ()(Local<Context> initiator_context); /** * PrepareStackTraceCallback is called when the stack property of an error is * first accessed. The return value will be used as the stack value. If this * callback is registed, the \|Error.prepareStackTrace\| API will be disabled. * \|sites\| is an array of call sites, specified in * https://v8.dev/docs/stack-trace-api / using PrepareStackTraceCallback = MaybeLocal<Value> ()(Local<Context> context, Local<Value> error, Local<Array> sites); #if defined(V8_OS_WIN) /** * Callback to selectively enable ETW tracing based on the document URL. * Implemented by the embedder, it should never call back into V8. * * Windows allows passing additional data to the ETW EnableCallback: * https://learn.microsoft.com/en-us/windows/win32/api/evntprov/nc-evntprov-penablecallback * * This data can be configured in a WPR (Windows Performance Recorder) * profile, adding a CustomFilter to an EventProvider like the following: * * <EventProvider Id=".." Name="57277741-3638-4A4B-BDBA-0AC6E45DA56C" Level="5"> * <CustomFilter Type="0x80000000" Value="AQABAAAAAAA..." /> * </EventProvider> * * Where: * - Name="57277741-3638-4A4B-BDBA-0AC6E45DA56C" is the GUID of the V8 * ETW provider, (see src/libplatform/etw/etw-provider-win.h), * - Type="0x80000000" is EVENT_FILTER_TYPE_SCHEMATIZED, * - Value="AQABAAAAAA..." is a base64-encoded byte array that is * base64-decoded by Windows and passed to the ETW enable callback in * the 'PEVENT_FILTER_DESCRIPTOR FilterData' argument; see: * https://learn.microsoft.com/en-us/windows/win32/api/evntprov/ns-evntprov-event_filter_descriptor. * * This array contains a struct EVENT_FILTER_HEADER followed by a * variable length payload, and as payload we pass a string in JSON format, * with a list of regular expressions that should match the document URL * in order to enable ETW tracing: * { * "version": "1.0", * "filtered_urls": [ * "https:\/\/.\.chromium\.org\/.", "https://v8.dev/";, "..." * ] * } / using FilterETWSessionByURLCallback = bool ()(Local<Context> context, const std::string& etw_filter_payload); #endif // V8_OS_WIN } // namespace v8 #endif // INCLUDE_V8_ISOLATE_CALLBACKS_H_	16.59 KB	2025-03-03 12:36
📄 v8-container.h // Copyright 2021 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. #ifndef INCLUDE_V8_CONTAINER_H_ #define INCLUDE_V8_CONTAINER_H_ #include <stddef.h> #include <stdint.h> #include <functional> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; class Isolate; /** * An instance of the built-in array constructor (ECMA-262, 15.4.2). / class V8_EXPORT Array : public Object { public: uint32_t Length() const; /* * Creates a JavaScript array with the given length. If the length * is negative the returned array will have length 0. / static Local<Array> New(Isolate isolate, int length = 0); /** * Creates a JavaScript array out of a Local<Value> array in C++ * with a known length. / static Local<Array> New(Isolate isolate, Local<Value>* elements, size_t length); V8_INLINE static Array* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Array>(value); } /* * Creates a JavaScript array from a provided callback. * * \param context The v8::Context to create the array in. * \param length The length of the array to be created. * \param next_value_callback The callback that is invoked to retrieve * elements for the array. The embedder can signal that the array * initialization should be aborted by throwing an exception and returning * an empty MaybeLocal. * \returns The v8::Array if all elements were constructed successfully and an * empty MaybeLocal otherwise. / static MaybeLocal<Array> New( Local<Context> context, size_t length, std::function<MaybeLocal<v8::Value>()> next_value_callback); enum class CallbackResult { kException, kBreak, kContinue, }; using IterationCallback = CallbackResult ()(uint32_t index, Local<Value> element, void* data); /** * Calls {callback} for every element of this array, passing {callback_data} * as its {data} parameter. * This function will typically be faster than calling {Get()} repeatedly. * As a consequence of being optimized for low overhead, the provided * callback must adhere to the following restrictions: * - It must not allocate any V8 objects and continue iterating; it may * allocate (e.g. an error message/object) and then immediately terminate * the iteration. * - It must not modify the array being iterated. * - It must not call back into V8 (unless it can guarantee that such a * call does not violate the above restrictions, which is difficult). * - The {Local<Value> element} must not "escape", i.e. must not be assigned * to any other {Local}. Creating a {Global} from it, or updating a * v8::TypecheckWitness with it, is safe. * These restrictions may be lifted in the future if use cases arise that * justify a slower but more robust implementation. * * Returns {Nothing} on exception; use a {TryCatch} to catch and handle this * exception. * When the {callback} returns {kException}, iteration is terminated * immediately, returning {Nothing}. By returning {kBreak}, the callback * can request non-exceptional early termination of the iteration. / Maybe<void> Iterate(Local<Context> context, IterationCallback callback, void callback_data); private: Array(); static void CheckCast(Value* obj); }; /** * An instance of the built-in Map constructor (ECMA-262, 6th Edition, 23.1.1). / class V8_EXPORT Map : public Object { public: size_t Size() const; void Clear(); V8_WARN_UNUSED_RESULT MaybeLocal<Value> Get(Local<Context> context, Local<Value> key); V8_WARN_UNUSED_RESULT MaybeLocal<Map> Set(Local<Context> context, Local<Value> key, Local<Value> value); V8_WARN_UNUSED_RESULT Maybe<bool> Has(Local<Context> context, Local<Value> key); V8_WARN_UNUSED_RESULT Maybe<bool> Delete(Local<Context> context, Local<Value> key); /* * Returns an array of length Size() * 2, where index N is the Nth key and * index N + 1 is the Nth value. / Local<Array> AsArray() const; /* * Creates a new empty Map. / static Local<Map> New(Isolate isolate); V8_INLINE static Map* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Map>(value); } private: Map(); static void CheckCast(Value obj); }; /** * An instance of the built-in Set constructor (ECMA-262, 6th Edition, 23.2.1). / class V8_EXPORT Set : public Object { public: size_t Size() const; void Clear(); V8_WARN_UNUSED_RESULT MaybeLocal<Set> Add(Local<Context> context, Local<Value> key); V8_WARN_UNUSED_RESULT Maybe<bool> Has(Local<Context> context, Local<Value> key); V8_WARN_UNUSED_RESULT Maybe<bool> Delete(Local<Context> context, Local<Value> key); /* * Returns an array of the keys in this Set. / Local<Array> AsArray() const; /* * Creates a new empty Set. / static Local<Set> New(Isolate isolate); V8_INLINE static Set* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Set>(value); } private: Set(); static void CheckCast(Value obj); }; } // namespace v8 #endif // INCLUDE_V8_CONTAINER_H_	5.82 KB	2025-03-03 12:36
📄 v8-context.h // Copyright 2021 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. #ifndef INCLUDE_V8_CONTEXT_H_ #define INCLUDE_V8_CONTEXT_H_ #include <stdint.h> #include <vector> #include "v8-data.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-maybe.h" // NOLINT(build/include_directory) #include "v8-snapshot.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Function; class MicrotaskQueue; class Object; class ObjectTemplate; class Value; class String; /** * A container for extension names. / class V8_EXPORT ExtensionConfiguration { public: ExtensionConfiguration() : name_count_(0), names_(nullptr) {} ExtensionConfiguration(int name_count, const char names[]) : name_count_(name_count), names_(names) {} const char begin() const { return &names_[0]; } const char end() const { return &names_[name_count_]; } private: const int name_count_; const char names_; }; / * A sandboxed execution context with its own set of built-in objects * and functions. / class V8_EXPORT Context : public Data { public: /* * Returns the global proxy object. * * Global proxy object is a thin wrapper whose prototype points to actual * context's global object with the properties like Object, etc. This is done * that way for security reasons (for more details see * https://wiki.mozilla.org/Gecko:SplitWindow). * * Please note that changes to global proxy object prototype most probably * would break VM---v8 expects only global object as a prototype of global * proxy object. / Local<Object> Global(); /* * Detaches the global object from its context before * the global object can be reused to create a new context. / void DetachGlobal(); /* * Creates a new context and returns a handle to the newly allocated * context. * * \param isolate The isolate in which to create the context. * * \param extensions An optional extension configuration containing * the extensions to be installed in the newly created context. * * \param global_template An optional object template from which the * global object for the newly created context will be created. * * \param global_object An optional global object to be reused for * the newly created context. This global object must have been * created by a previous call to Context::New with the same global * template. The state of the global object will be completely reset * and only object identify will remain. * * \param internal_fields_deserializer An optional callback used * to deserialize fields set by * v8::Object::SetAlignedPointerInInternalField() in wrapper objects * from the default context snapshot. It should match the * SerializeInternalFieldsCallback() used by * v8::SnapshotCreator::SetDefaultContext() when the default context * snapshot is created. It does not need to be configured if the default * context snapshot contains no wrapper objects with pointer internal * fields, or if no custom startup snapshot is configured * in the v8::CreateParams used to create the isolate. * * \param microtask_queue An optional microtask queue used to manage * the microtasks created in this context. If not set the per-isolate * default microtask queue would be used. * * \param context_data_deserializer An optional callback used * to deserialize embedder data set by * v8::Context::SetAlignedPointerInEmbedderData() in the default * context from the default context snapshot. It does not need to be * configured if the default context snapshot contains no pointer embedder * data, or if no custom startup snapshot is configured in the * v8::CreateParams used to create the isolate. / static Local<Context> New( Isolate isolate, ExtensionConfiguration* extensions = nullptr, MaybeLocal<ObjectTemplate> global_template = MaybeLocal<ObjectTemplate>(), MaybeLocal<Value> global_object = MaybeLocal<Value>(), DeserializeInternalFieldsCallback internal_fields_deserializer = DeserializeInternalFieldsCallback(), MicrotaskQueue* microtask_queue = nullptr, DeserializeContextDataCallback context_data_deserializer = DeserializeContextDataCallback()); /** * Create a new context from a (non-default) context snapshot. There * is no way to provide a global object template since we do not create * a new global object from template, but we can reuse a global object. * * \param isolate See v8::Context::New. * * \param context_snapshot_index The index of the context snapshot to * deserialize from. Use v8::Context::New for the default snapshot. * * \param internal_fields_deserializer An optional callback used * to deserialize fields set by * v8::Object::SetAlignedPointerInInternalField() in wrapper objects * from the default context snapshot. It does not need to be * configured if there are no wrapper objects with no internal * pointer fields in the default context snapshot or if no startup * snapshot is configured when the isolate is created. * * \param extensions See v8::Context::New. * * \param global_object See v8::Context::New. * * \param internal_fields_deserializer Similar to * internal_fields_deserializer in v8::Context::New but applies to * the context specified by the context_snapshot_index. * * \param microtask_queue See v8::Context::New. * * \param context_data_deserializer Similar to * context_data_deserializer in v8::Context::New but applies to * the context specified by the context_snapshot_index. / static MaybeLocal<Context> FromSnapshot( Isolate isolate, size_t context_snapshot_index, DeserializeInternalFieldsCallback internal_fields_deserializer = DeserializeInternalFieldsCallback(), ExtensionConfiguration* extensions = nullptr, MaybeLocal<Value> global_object = MaybeLocal<Value>(), MicrotaskQueue* microtask_queue = nullptr, DeserializeContextDataCallback context_data_deserializer = DeserializeContextDataCallback()); /** * Returns an global object that isn't backed by an actual context. * * The global template needs to have access checks with handlers installed. * If an existing global object is passed in, the global object is detached * from its context. * * Note that this is different from a detached context where all accesses to * the global proxy will fail. Instead, the access check handlers are invoked. * * It is also not possible to detach an object returned by this method. * Instead, the access check handlers need to return nothing to achieve the * same effect. * * It is possible, however, to create a new context from the global object * returned by this method. / static MaybeLocal<Object> NewRemoteContext( Isolate isolate, Local<ObjectTemplate> global_template, MaybeLocal<Value> global_object = MaybeLocal<Value>()); /** * Sets the security token for the context. To access an object in * another context, the security tokens must match. / void SetSecurityToken(Local<Value> token); /* Restores the security token to the default value. / void UseDefaultSecurityToken(); /* Returns the security token of this context./ Local<Value> GetSecurityToken(); /* * Enter this context. After entering a context, all code compiled * and run is compiled and run in this context. If another context * is already entered, this old context is saved so it can be * restored when the new context is exited. / void Enter(); /* * Exit this context. Exiting the current context restores the * context that was in place when entering the current context. / void Exit(); /* * Delegate to help with Deep freezing embedder-specific objects (such as * JSApiObjects) that can not be frozen natively. / class DeepFreezeDelegate { public: /* * Performs embedder-specific operations to freeze the provided embedder * object. The provided object will be frozen by DeepFreeze after this * function returns, so only embedder-specific objects need to be frozen. * This function may not create new JS objects or perform JS allocations. * Any v8 objects reachable from the provided embedder object that should * also be considered for freezing should be added to the children_out * parameter. Returns true if the operation completed successfully. / virtual bool FreezeEmbedderObjectAndGetChildren( Local<Object> obj, LocalVector<Object>& children_out) = 0; }; /* * Attempts to recursively freeze all objects reachable from this context. * Some objects (generators, iterators, non-const closures) can not be frozen * and will cause this method to throw an error. An optional delegate can be * provided to help freeze embedder-specific objects. * * Freezing occurs in two steps: * 1. "Marking" where we iterate through all objects reachable by this * context, accumulating a list of objects that need to be frozen and * looking for objects that can't be frozen. This step is separated because * it is more efficient when we can assume there is no garbage collection. * 2. "Freezing" where we go through the list of objects and freezing them. * This effectively requires copying them so it may trigger garbage * collection. / Maybe<void> DeepFreeze(DeepFreezeDelegate delegate = nullptr); /** Returns the isolate associated with a current context. / Isolate GetIsolate(); /** Returns the microtask queue associated with a current context. / MicrotaskQueue GetMicrotaskQueue(); /** Sets the microtask queue associated with the current context. / void SetMicrotaskQueue(MicrotaskQueue queue); /** * The field at kDebugIdIndex used to be reserved for the inspector. * It now serves no purpose. / enum EmbedderDataFields { kDebugIdIndex = 0 }; /* * Return the number of fields allocated for embedder data. / uint32_t GetNumberOfEmbedderDataFields(); /* * Gets the embedder data with the given index, which must have been set by a * previous call to SetEmbedderData with the same index. / V8_INLINE Local<Value> GetEmbedderData(int index); /* * Gets the binding object used by V8 extras. Extra natives get a reference * to this object and can use it to "export" functionality by adding * properties. Extra natives can also "import" functionality by accessing * properties added by the embedder using the V8 API. / Local<Object> GetExtrasBindingObject(); /* * Sets the embedder data with the given index, growing the data as * needed. Note that index 0 currently has a special meaning for Chrome's * debugger. / void SetEmbedderData(int index, Local<Value> value); /* * Gets a 2-byte-aligned native pointer from the embedder data with the given * index, which must have been set by a previous call to * SetAlignedPointerInEmbedderData with the same index. Note that index 0 * currently has a special meaning for Chrome's debugger. / V8_INLINE void GetAlignedPointerFromEmbedderData(int index); /** * Sets a 2-byte-aligned native pointer in the embedder data with the given * index, growing the data as needed. Note that index 0 currently has a * special meaning for Chrome's debugger. / void SetAlignedPointerInEmbedderData(int index, void value); /** * Control whether code generation from strings is allowed. Calling * this method with false will disable 'eval' and the 'Function' * constructor for code running in this context. If 'eval' or the * 'Function' constructor are used an exception will be thrown. * * If code generation from strings is not allowed the * V8::AllowCodeGenerationFromStrings callback will be invoked if * set before blocking the call to 'eval' or the 'Function' * constructor. If that callback returns true, the call will be * allowed, otherwise an exception will be thrown. If no callback is * set an exception will be thrown. / void AllowCodeGenerationFromStrings(bool allow); /* * Returns true if code generation from strings is allowed for the context. * For more details see AllowCodeGenerationFromStrings(bool) documentation. / bool IsCodeGenerationFromStringsAllowed() const; /* * Sets the error description for the exception that is thrown when * code generation from strings is not allowed and 'eval' or the 'Function' * constructor are called. / void SetErrorMessageForCodeGenerationFromStrings(Local<String> message); /* * Sets the error description for the exception that is thrown when * wasm code generation is not allowed. / void SetErrorMessageForWasmCodeGeneration(Local<String> message); /* * Return data that was previously attached to the context snapshot via * SnapshotCreator, and removes the reference to it. * Repeated call with the same index returns an empty MaybeLocal. / template <class T> V8_INLINE MaybeLocal<T> GetDataFromSnapshotOnce(size_t index); /* * If callback is set, abort any attempt to execute JavaScript in this * context, call the specified callback, and throw an exception. * To unset abort, pass nullptr as callback. / using AbortScriptExecutionCallback = void ()(Isolate* isolate, Local<Context> context); void SetAbortScriptExecution(AbortScriptExecutionCallback callback); /** * Set or clear hooks to be invoked for promise lifecycle operations. * To clear a hook, set it to an empty v8::Function. Each function will * receive the observed promise as the first argument. If a chaining * operation is used on a promise, the init will additionally receive * the parent promise as the second argument. / void SetPromiseHooks(Local<Function> init_hook, Local<Function> before_hook, Local<Function> after_hook, Local<Function> resolve_hook); bool HasTemplateLiteralObject(Local<Value> object); /* * Stack-allocated class which sets the execution context for all * operations executed within a local scope. / class V8_NODISCARD Scope { public: explicit V8_INLINE Scope(Local<Context> context) : context_(context) { context_->Enter(); } V8_INLINE ~Scope() { context_->Exit(); } private: Local<Context> context_; }; /* * Stack-allocated class to support the backup incumbent settings object * stack. * https://html.spec.whatwg.org/multipage/webappapis.html#backup-incumbent-settings-object-stack / class V8_EXPORT V8_NODISCARD BackupIncumbentScope final { public: /* * \|backup_incumbent_context\| is pushed onto the backup incumbent settings * object stack. / explicit BackupIncumbentScope(Local<Context> backup_incumbent_context); ~BackupIncumbentScope(); private: friend class internal::Isolate; uintptr_t JSStackComparableAddressPrivate() const { return js_stack_comparable_address_; } Local<Context> backup_incumbent_context_; uintptr_t js_stack_comparable_address_ = 0; const BackupIncumbentScope prev_ = nullptr; }; V8_INLINE static Context* Cast(Data* data); private: friend class Value; friend class Script; friend class Object; friend class Function; static void CheckCast(Data* obj); internal::Address* GetDataFromSnapshotOnce(size_t index); Local<Value> SlowGetEmbedderData(int index); void* SlowGetAlignedPointerFromEmbedderData(int index); }; // --- Implementation --- Local<Value> Context::GetEmbedderData(int index) { #ifndef V8_ENABLE_CHECKS using A = internal::Address; using I = internal::Internals; A ctx = internal::ValueHelper::ValueAsAddress(this); A embedder_data = I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset); int value_offset = I::kEmbedderDataArrayHeaderSize + (I::kEmbedderDataSlotSize * index); A value = I::ReadRawField<A>(embedder_data, value_offset); #ifdef V8_COMPRESS_POINTERS // We read the full pointer value and then decompress it in order to avoid // dealing with potential endiannes issues. value = I::DecompressTaggedField(embedder_data, static_cast<uint32_t>(value)); #endif auto isolate = reinterpret_cast<v8::Isolate>( internal::IsolateFromNeverReadOnlySpaceObject(ctx)); return Local<Value>::New(isolate, value); #else return SlowGetEmbedderData(index); #endif } void Context::GetAlignedPointerFromEmbedderData(int index) { #if !defined(V8_ENABLE_CHECKS) using A = internal::Address; using I = internal::Internals; A ctx = internal::ValueHelper::ValueAsAddress(this); A embedder_data = I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset); int value_offset = I::kEmbedderDataArrayHeaderSize + (I::kEmbedderDataSlotSize * index) + I::kEmbedderDataSlotExternalPointerOffset; Isolate* isolate = I::GetIsolateForSandbox(ctx); return reinterpret_cast<void>( I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>( isolate, embedder_data, value_offset)); #else return SlowGetAlignedPointerFromEmbedderData(index); #endif } template <class T> MaybeLocal<T> Context::GetDataFromSnapshotOnce(size_t index) { if (auto slot = GetDataFromSnapshotOnce(index); slot) { internal::PerformCastCheck( internal::ValueHelper::SlotAsValue<T, false>(slot)); return Local<T>::FromSlot(slot); } return {}; } Context Context::Cast(v8::Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<Context*>(data); } } // namespace v8 #endif // INCLUDE_V8_CONTEXT_H_	17.76 KB	2025-03-03 12:36
📄 v8-cppgc.h // Copyright 2020 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. #ifndef INCLUDE_V8_CPPGC_H_ #define INCLUDE_V8_CPPGC_H_ #include <cstdint> #include <memory> #include <vector> #include "cppgc/common.h" #include "cppgc/custom-space.h" #include "cppgc/heap-statistics.h" #include "cppgc/visitor.h" #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-platform.h" // NOLINT(build/include_directory) #include "v8-traced-handle.h" // NOLINT(build/include_directory) namespace cppgc { class AllocationHandle; class HeapHandle; } // namespace cppgc namespace v8 { class Object; namespace internal { class CppHeap; } // namespace internal class CustomSpaceStatisticsReceiver; /** * Describes how V8 wrapper objects maintain references to garbage-collected C++ * objects. / struct WrapperDescriptor final { /* * The index used on `v8::Ojbect::SetAlignedPointerFromInternalField()` and * related APIs to add additional data to an object which is used to identify * JS->C++ references. / using InternalFieldIndex = int; /* * Unknown embedder id. The value is reserved for internal usages and must not * be used with `CppHeap`. / static constexpr uint16_t kUnknownEmbedderId = UINT16_MAX; constexpr WrapperDescriptor(InternalFieldIndex wrappable_type_index, InternalFieldIndex wrappable_instance_index, uint16_t embedder_id_for_garbage_collected) : wrappable_type_index(wrappable_type_index), wrappable_instance_index(wrappable_instance_index), embedder_id_for_garbage_collected(embedder_id_for_garbage_collected) {} /* * Index of the wrappable type. / InternalFieldIndex wrappable_type_index; /* * Index of the wrappable instance. / InternalFieldIndex wrappable_instance_index; /* * Embedder id identifying instances of garbage-collected objects. It is * expected that the first field of the wrappable type is a uint16_t holding * the id. Only references to instances of wrappables types with an id of * `embedder_id_for_garbage_collected` will be considered by CppHeap. / uint16_t embedder_id_for_garbage_collected; }; struct V8_EXPORT CppHeapCreateParams { CppHeapCreateParams( std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces, WrapperDescriptor wrapper_descriptor) : custom_spaces(std::move(custom_spaces)), wrapper_descriptor(wrapper_descriptor) {} CppHeapCreateParams(const CppHeapCreateParams&) = delete; CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete; std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces; WrapperDescriptor wrapper_descriptor; /* * Specifies which kind of marking are supported by the heap. The type may be * further reduced via runtime flags when attaching the heap to an Isolate. / cppgc::Heap::MarkingType marking_support = cppgc::Heap::MarkingType::kIncrementalAndConcurrent; /* * Specifies which kind of sweeping is supported by the heap. The type may be * further reduced via runtime flags when attaching the heap to an Isolate. / cppgc::Heap::SweepingType sweeping_support = cppgc::Heap::SweepingType::kIncrementalAndConcurrent; }; /* * A heap for allocating managed C++ objects. * * Similar to v8::Isolate, the heap may only be accessed from one thread at a * time. The heap may be used from different threads using the * v8::Locker/v8::Unlocker APIs which is different from generic Oilpan. / class V8_EXPORT CppHeap { public: static std::unique_ptr<CppHeap> Create(v8::Platform platform, const CppHeapCreateParams& params); virtual ~CppHeap() = default; /** * \returns the opaque handle for allocating objects using * `MakeGarbageCollected()`. / cppgc::AllocationHandle& GetAllocationHandle(); /* * \returns the opaque heap handle which may be used to refer to this heap in * other APIs. Valid as long as the underlying `CppHeap` is alive. / cppgc::HeapHandle& GetHeapHandle(); /* * Terminate clears all roots and performs multiple garbage collections to * reclaim potentially newly created objects in destructors. * * After this call, object allocation is prohibited. / void Terminate(); /* * \param detail_level specifies whether should return detailed * statistics or only brief summary statistics. * \returns current CppHeap statistics regarding memory consumption * and utilization. / cppgc::HeapStatistics CollectStatistics( cppgc::HeapStatistics::DetailLevel detail_level); /* * Collects statistics for the given spaces and reports them to the receiver. * * \param custom_spaces a collection of custom space indicies. * \param receiver an object that gets the results. / void CollectCustomSpaceStatisticsAtLastGC( std::vector<cppgc::CustomSpaceIndex> custom_spaces, std::unique_ptr<CustomSpaceStatisticsReceiver> receiver); /* * Enables a detached mode that allows testing garbage collection using * `cppgc::testing` APIs. Once used, the heap cannot be attached to an * `Isolate` anymore. / void EnableDetachedGarbageCollectionsForTesting(); /* * Performs a stop-the-world garbage collection for testing purposes. * * \param stack_state The stack state to assume for the garbage collection. / void CollectGarbageForTesting(cppgc::EmbedderStackState stack_state); /* * Performs a stop-the-world minor garbage collection for testing purposes. * * \param stack_state The stack state to assume for the garbage collection. / void CollectGarbageInYoungGenerationForTesting( cppgc::EmbedderStackState stack_state); /* * \returns the wrapper descriptor of this CppHeap. / v8::WrapperDescriptor wrapper_descriptor() const; private: CppHeap() = default; friend class internal::CppHeap; }; class JSVisitor : public cppgc::Visitor { public: explicit JSVisitor(cppgc::Visitor::Key key) : cppgc::Visitor(key) {} ~JSVisitor() override = default; void Trace(const TracedReferenceBase& ref) { if (ref.IsEmptyThreadSafe()) return; Visit(ref); } protected: using cppgc::Visitor::Visit; virtual void Visit(const TracedReferenceBase& ref) {} }; /* * Provided as input to `CppHeap::CollectCustomSpaceStatisticsAtLastGC()`. * * Its method is invoked with the results of the statistic collection. / class CustomSpaceStatisticsReceiver { public: virtual ~CustomSpaceStatisticsReceiver() = default; /* * Reports the size of a space at the last GC. It is called for each space * that was requested in `CollectCustomSpaceStatisticsAtLastGC()`. * * \param space_index The index of the space. * \param bytes The total size of live objects in the space at the last GC. * It is zero if there was no GC yet. / virtual void AllocatedBytes(cppgc::CustomSpaceIndex space_index, size_t bytes) = 0; }; } // namespace v8 namespace cppgc { template <typename T> struct TraceTrait<v8::TracedReference<T>> { static cppgc::TraceDescriptor GetTraceDescriptor(const void self) { return {nullptr, Trace}; } static void Trace(Visitor* visitor, const void* self) { static_cast<v8::JSVisitor>(visitor)->Trace( static_cast<const v8::TracedReference<T>*>(self)); } }; } // namespace cppgc #endif // INCLUDE_V8_CPPGC_H_	7.46 KB	2025-03-03 12:36
📄 v8-data.h // Copyright 2021 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. #ifndef INCLUDE_V8_DATA_H_ #define INCLUDE_V8_DATA_H_ #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; /** * The superclass of objects that can reside on V8's heap. / class V8_EXPORT Data { public: /* * Returns true if this data is a \|v8::Value\|. / bool IsValue() const; /* * Returns true if this data is a \|v8::Module\|. / bool IsModule() const; /* * Returns tru if this data is a \|v8::FixedArray\| / bool IsFixedArray() const; /* * Returns true if this data is a \|v8::Private\|. / bool IsPrivate() const; /* * Returns true if this data is a \|v8::ObjectTemplate\|. / bool IsObjectTemplate() const; /* * Returns true if this data is a \|v8::FunctionTemplate\|. / bool IsFunctionTemplate() const; /* * Returns true if this data is a \|v8::Context\|. / bool IsContext() const; private: Data() = delete; }; /* * A fixed-sized array with elements of type Data. / class V8_EXPORT FixedArray : public Data { public: int Length() const; Local<Data> Get(Local<Context> context, int i) const; V8_INLINE static FixedArray Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return reinterpret_cast<FixedArray>(data); } private: static void CheckCast(Data obj); }; } // namespace v8 #endif // INCLUDE_V8_DATA_H_	1.58 KB	2025-03-03 12:36
📄 v8-date.h // Copyright 2021 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. #ifndef INCLUDE_V8_DATE_H_ #define INCLUDE_V8_DATE_H_ #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; /** * An instance of the built-in Date constructor (ECMA-262, 15.9). / class V8_EXPORT Date : public Object { public: static V8_WARN_UNUSED_RESULT MaybeLocal<Value> New(Local<Context> context, double time); /* * A specialization of Value::NumberValue that is more efficient * because we know the structure of this object. / double ValueOf() const; /* * Generates ISO string representation. / v8::Local<v8::String> ToISOString() const; V8_INLINE static Date Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Date>(value); } private: static void CheckCast(Value obj); }; } // namespace v8 #endif // INCLUDE_V8_DATE_H_	1.19 KB	2025-03-03 12:36
📄 v8-debug.h // Copyright 2021 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. #ifndef INCLUDE_V8_DEBUG_H_ #define INCLUDE_V8_DEBUG_H_ #include <stdint.h> #include "v8-script.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Isolate; class String; /** * A single JavaScript stack frame. / class V8_EXPORT StackFrame { public: /* * Returns the source location, 0-based, for the associated function call. / Location GetLocation() const; /* * Returns the number, 1-based, of the line for the associate function call. * This method will return Message::kNoLineNumberInfo if it is unable to * retrieve the line number, or if kLineNumber was not passed as an option * when capturing the StackTrace. / int GetLineNumber() const { return GetLocation().GetLineNumber() + 1; } /* * Returns the 1-based column offset on the line for the associated function * call. * This method will return Message::kNoColumnInfo if it is unable to retrieve * the column number, or if kColumnOffset was not passed as an option when * capturing the StackTrace. / int GetColumn() const { return GetLocation().GetColumnNumber() + 1; } /* * Returns the id of the script for the function for this StackFrame. * This method will return Message::kNoScriptIdInfo if it is unable to * retrieve the script id, or if kScriptId was not passed as an option when * capturing the StackTrace. / int GetScriptId() const; /* * Returns the name of the resource that contains the script for the * function for this StackFrame. / Local<String> GetScriptName() const; /* * Returns the name of the resource that contains the script for the * function for this StackFrame or sourceURL value if the script name * is undefined and its source ends with //# sourceURL=... string or * deprecated //@ sourceURL=... string. / Local<String> GetScriptNameOrSourceURL() const; /* * Returns the source of the script for the function for this StackFrame. / Local<String> GetScriptSource() const; /* * Returns the source mapping URL (if one is present) of the script for * the function for this StackFrame. / Local<String> GetScriptSourceMappingURL() const; /* * Returns the name of the function associated with this stack frame. / Local<String> GetFunctionName() const; /* * Returns whether or not the associated function is compiled via a call to * eval(). / bool IsEval() const; /* * Returns whether or not the associated function is called as a * constructor via "new". / bool IsConstructor() const; /* * Returns whether or not the associated functions is defined in wasm. / bool IsWasm() const; /* * Returns whether or not the associated function is defined by the user. / bool IsUserJavaScript() const; }; /* * Representation of a JavaScript stack trace. The information collected is a * snapshot of the execution stack and the information remains valid after * execution continues. / class V8_EXPORT StackTrace { public: /* * Flags that determine what information is placed captured for each * StackFrame when grabbing the current stack trace. * Note: these options are deprecated and we always collect all available * information (kDetailed). / enum StackTraceOptions { kLineNumber = 1, kColumnOffset = 1 << 1 \| kLineNumber, kScriptName = 1 << 2, kFunctionName = 1 << 3, kIsEval = 1 << 4, kIsConstructor = 1 << 5, kScriptNameOrSourceURL = 1 << 6, kScriptId = 1 << 7, kExposeFramesAcrossSecurityOrigins = 1 << 8, kOverview = kLineNumber \| kColumnOffset \| kScriptName \| kFunctionName, kDetailed = kOverview \| kIsEval \| kIsConstructor \| kScriptNameOrSourceURL }; /* * Returns a StackFrame at a particular index. / Local<StackFrame> GetFrame(Isolate isolate, uint32_t index) const; /** * Returns the number of StackFrames. / int GetFrameCount() const; /* * Grab a snapshot of the current JavaScript execution stack. * * \param frame_limit The maximum number of stack frames we want to capture. * \param options Enumerates the set of things we will capture for each * StackFrame. / static Local<StackTrace> CurrentStackTrace( Isolate isolate, int frame_limit, StackTraceOptions options = kDetailed); /** * Returns the first valid script name or source URL starting at the top of * the JS stack. The returned string is either an empty handle if no script * name/url was found or a non-zero-length string. * * This method is equivalent to calling StackTrace::CurrentStackTrace and * walking the resulting frames from the beginning until a non-empty script * name/url is found. The difference is that this method won't allocate * a stack trace. / static Local<String> CurrentScriptNameOrSourceURL(Isolate isolate); }; } // namespace v8 #endif // INCLUDE_V8_DEBUG_H_	5.04 KB	2025-03-03 12:36
📄 v8-embedder-heap.h // Copyright 2021 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. #ifndef INCLUDE_V8_EMBEDDER_HEAP_H_ #define INCLUDE_V8_EMBEDDER_HEAP_H_ #include "v8-traced-handle.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { namespace internal { class TracedHandles; } // namespace internal class Isolate; class Value; /** * Handler for embedder roots on non-unified heap garbage collections. / class V8_EXPORT EmbedderRootsHandler { public: enum class RootHandling { kQueryEmbedderForNonDroppableReferences, kDontQueryEmbedderForAnyReference, }; virtual ~EmbedderRootsHandler() = default; EmbedderRootsHandler() = default; explicit EmbedderRootsHandler(RootHandling default_traced_reference_handling) : default_traced_reference_handling_(default_traced_reference_handling) {} /* * Returns true if the \|TracedReference\| handle should be considered as root * for the currently running non-tracing garbage collection and false * otherwise. The default implementation will keep all \|TracedReference\| * references as roots. * * If this returns false, then V8 may decide that the object referred to by * such a handle is reclaimed. In that case, V8 calls \|ResetRoot()\| for the * \|TracedReference\|. * * Note that the `handle` is different from the handle that the embedder holds * for retaining the object. * * The concrete implementations must be thread-safe. / virtual bool IsRoot(const v8::TracedReference<v8::Value>& handle) = 0; /* * Used in combination with \|IsRoot\|. Called by V8 when an * object that is backed by a handle is reclaimed by a non-tracing garbage * collection. It is up to the embedder to reset the original handle. * * Note that the \|handle\| is different from the handle that the embedder holds * for retaining the object. It is up to the embedder to find the original * handle via the object or class id. / virtual void ResetRoot(const v8::TracedReference<v8::Value>& handle) = 0; /* * Similar to \|ResetRoot()\|, but opportunistic. The function is called in * parallel for different handles and as such must be thread-safe. In case, * \|false\| is returned, \|ResetRoot()\| will be recalled for the same handle. */ virtual bool TryResetRoot(const v8::TracedReference<v8::Value>& handle) { ResetRoot(handle); return true; } private: const RootHandling default_traced_reference_handling_ = RootHandling::kQueryEmbedderForNonDroppableReferences; friend class internal::TracedHandles; }; } // namespace v8 #endif // INCLUDE_V8_EMBEDDER_HEAP_H_	2.71 KB	2025-03-03 12:36
📄 v8-embedder-state-scope.h // Copyright 2021 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. #ifndef INCLUDE_V8_EMBEDDER_STATE_SCOPE_H_ #define INCLUDE_V8_EMBEDDER_STATE_SCOPE_H_ #include <memory> #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) namespace v8 { class Context; namespace internal { class EmbedderState; } // namespace internal // A StateTag represents a possible state of the embedder. enum class EmbedderStateTag : uint8_t { // reserved EMPTY = 0, OTHER = 1, // embedder can define any state after }; // A stack-allocated class that manages an embedder state on the isolate. // After an EmbedderState scope has been created, a new embedder state will be // pushed on the isolate stack. class V8_EXPORT EmbedderStateScope { public: EmbedderStateScope(Isolate* isolate, Local<v8::Context> context, EmbedderStateTag tag); ~EmbedderStateScope(); private: // Declaring operator new and delete as deleted is not spec compliant. // Therefore declare them private instead to disable dynamic alloc void* operator new(size_t size); void* operator new[](size_t size); void operator delete(void, size_t); void operator delete[](void, size_t); std::unique_ptr<internal::EmbedderState> embedder_state_; }; } // namespace v8 #endif // INCLUDE_V8_EMBEDDER_STATE_SCOPE_H_	1.46 KB	2025-03-03 12:36
📄 v8-exception.h // Copyright 2021 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. #ifndef INCLUDE_V8_EXCEPTION_H_ #define INCLUDE_V8_EXCEPTION_H_ #include <stddef.h> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; class Isolate; class Message; class StackTrace; class String; class Value; namespace internal { class Isolate; class ThreadLocalTop; } // namespace internal /** * Create new error objects by calling the corresponding error object * constructor with the message. / class V8_EXPORT Exception { public: static Local<Value> RangeError(Local<String> message, Local<Value> options = {}); static Local<Value> ReferenceError(Local<String> message, Local<Value> options = {}); static Local<Value> SyntaxError(Local<String> message, Local<Value> options = {}); static Local<Value> TypeError(Local<String> message, Local<Value> options = {}); static Local<Value> WasmCompileError(Local<String> message, Local<Value> options = {}); static Local<Value> WasmLinkError(Local<String> message, Local<Value> options = {}); static Local<Value> WasmRuntimeError(Local<String> message, Local<Value> options = {}); static Local<Value> Error(Local<String> message, Local<Value> options = {}); /* * Creates an error message for the given exception. * Will try to reconstruct the original stack trace from the exception value, * or capture the current stack trace if not available. / static Local<Message> CreateMessage(Isolate isolate, Local<Value> exception); /** * Returns the original stack trace that was captured at the creation time * of a given exception, or an empty handle if not available. / static Local<StackTrace> GetStackTrace(Local<Value> exception); }; /* * An external exception handler. / class V8_EXPORT TryCatch { public: /* * Creates a new try/catch block and registers it with v8. Note that * all TryCatch blocks should be stack allocated because the memory * location itself is compared against JavaScript try/catch blocks. / explicit TryCatch(Isolate isolate); /** * Unregisters and deletes this try/catch block. / ~TryCatch(); /* * Returns true if an exception has been caught by this try/catch block. / bool HasCaught() const; /* * For certain types of exceptions, it makes no sense to continue execution. * * If CanContinue returns false, the correct action is to perform any C++ * cleanup needed and then return. If CanContinue returns false and * HasTerminated returns true, it is possible to call * CancelTerminateExecution in order to continue calling into the engine. / bool CanContinue() const; /* * Returns true if an exception has been caught due to script execution * being terminated. * * There is no JavaScript representation of an execution termination * exception. Such exceptions are thrown when the TerminateExecution * methods are called to terminate a long-running script. * * If such an exception has been thrown, HasTerminated will return true, * indicating that it is possible to call CancelTerminateExecution in order * to continue calling into the engine. / bool HasTerminated() const; /* * Throws the exception caught by this TryCatch in a way that avoids * it being caught again by this same TryCatch. As with ThrowException * it is illegal to execute any JavaScript operations after calling * ReThrow; the caller must return immediately to where the exception * is caught. / Local<Value> ReThrow(); /* * Returns the exception caught by this try/catch block. If no exception has * been caught an empty handle is returned. / Local<Value> Exception() const; /* * Returns the .stack property of an object. If no .stack * property is present an empty handle is returned. / V8_WARN_UNUSED_RESULT static MaybeLocal<Value> StackTrace( Local<Context> context, Local<Value> exception); /* * Returns the .stack property of the thrown object. If no .stack property is * present or if this try/catch block has not caught an exception, an empty * handle is returned. / V8_WARN_UNUSED_RESULT MaybeLocal<Value> StackTrace( Local<Context> context) const; /* * Returns the message associated with this exception. If there is * no message associated an empty handle is returned. / Local<v8::Message> Message() const; /* * Clears any exceptions that may have been caught by this try/catch block. * After this method has been called, HasCaught() will return false. Cancels * the scheduled exception if it is caught and ReThrow() is not called before. * * It is not necessary to clear a try/catch block before using it again; if * another exception is thrown the previously caught exception will just be * overwritten. However, it is often a good idea since it makes it easier * to determine which operation threw a given exception. / void Reset(); /* * Set verbosity of the external exception handler. * * By default, exceptions that are caught by an external exception * handler are not reported. Call SetVerbose with true on an * external exception handler to have exceptions caught by the * handler reported as if they were not caught. / void SetVerbose(bool value); /* * Returns true if verbosity is enabled. / bool IsVerbose() const; /* * Set whether or not this TryCatch should capture a Message object * which holds source information about where the exception * occurred. True by default. / void SetCaptureMessage(bool value); TryCatch(const TryCatch&) = delete; void operator=(const TryCatch&) = delete; private: // Declaring operator new and delete as deleted is not spec compliant. // Therefore declare them private instead to disable dynamic alloc void operator new(size_t size); void* operator new[](size_t size); void operator delete(void, size_t); void operator delete[](void, size_t); /** * There are cases when the raw address of C++ TryCatch object cannot be * used for comparisons with addresses into the JS stack. The cases are: * 1) ARM, ARM64 and MIPS simulators which have separate JS stack. * 2) Address sanitizer allocates local C++ object in the heap when * UseAfterReturn mode is enabled. * This method returns address that can be used for comparisons with * addresses into the JS stack. When neither simulator nor ASAN's * UseAfterReturn is enabled, then the address returned will be the address * of the C++ try catch handler itself. / internal::Address JSStackComparableAddressPrivate() { return js_stack_comparable_address_; } void ResetInternal(); internal::Isolate i_isolate_; TryCatch* next_; void* exception_; void* message_obj_; internal::Address js_stack_comparable_address_; bool is_verbose_ : 1; bool can_continue_ : 1; bool capture_message_ : 1; bool rethrow_ : 1; friend class internal::Isolate; friend class internal::ThreadLocalTop; }; } // namespace v8 #endif // INCLUDE_V8_EXCEPTION_H_	7.41 KB	2025-03-03 12:36
📄 v8-extension.h // Copyright 2021 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. #ifndef INCLUDE_V8_EXTENSION_H_ #define INCLUDE_V8_EXTENSION_H_ #include <memory> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-primitive.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class FunctionTemplate; // --- Extensions --- /** * Ignore / class V8_EXPORT Extension { public: // Note that the strings passed into this constructor must live as long // as the Extension itself. Extension(const char name, const char* source = nullptr, int dep_count = 0, const char** deps = nullptr, int source_length = -1); virtual ~Extension() { delete source_; } virtual Local<FunctionTemplate> GetNativeFunctionTemplate( Isolate* isolate, Local<String> name) { return Local<FunctionTemplate>(); } const char* name() const { return name_; } size_t source_length() const { return source_length_; } const String::ExternalOneByteStringResource* source() const { return source_; } int dependency_count() const { return dep_count_; } const char** dependencies() const { return deps_; } void set_auto_enable(bool value) { auto_enable_ = value; } bool auto_enable() { return auto_enable_; } // Disallow copying and assigning. Extension(const Extension&) = delete; void operator=(const Extension&) = delete; private: const char* name_; size_t source_length_; // expected to initialize before source_ String::ExternalOneByteStringResource* source_; int dep_count_; const char** deps_; bool auto_enable_; }; void V8_EXPORT RegisterExtension(std::unique_ptr<Extension>); } // namespace v8 #endif // INCLUDE_V8_EXTENSION_H_	1.83 KB	2025-03-03 12:36
📄 v8-external.h // Copyright 2021 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. #ifndef INCLUDE_V8_EXTERNAL_H_ #define INCLUDE_V8_EXTERNAL_H_ #include "v8-value.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Isolate; /** * A JavaScript value that wraps a C++ void. This type of value is mainly used to associate C++ data structures with JavaScript objects. / class V8_EXPORT External : public Value { public: static Local<External> New(Isolate isolate, void* value); V8_INLINE static External* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<External>(value); } void Value() const; private: static void CheckCast(v8::Value* obj); }; } // namespace v8 #endif // INCLUDE_V8_EXTERNAL_H_	924 B	2025-03-03 12:36
📄 v8-forward.h // Copyright 2021 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. #ifndef INCLUDE_V8_FORWARD_H_ #define INCLUDE_V8_FORWARD_H_ // This header is intended to be used by headers that pass around V8 types, // either by pointer or using Local<Type>. The full definitions can be included // either via v8.h or the more fine-grained headers. #include "v8-local-handle.h" // NOLINT(build/include_directory) namespace v8 { class AccessorSignature; class Array; class ArrayBuffer; class ArrayBufferView; class BigInt; class BigInt64Array; class BigIntObject; class BigUint64Array; class Boolean; class BooleanObject; class Context; class DataView; class Data; class Date; class DictionaryTemplate; class Extension; class External; class FixedArray; class Float32Array; class Float64Array; class Function; template <class F> class FunctionCallbackInfo; class FunctionTemplate; class Int16Array; class Int32; class Int32Array; class Int8Array; class Integer; class Isolate; class Map; class Module; class Name; class Number; class NumberObject; class Object; class ObjectTemplate; class Platform; class Primitive; class Private; class Promise; class Proxy; class RegExp; class Script; class Set; class SharedArrayBuffer; class Signature; class String; class StringObject; class Symbol; class SymbolObject; class Template; class TryCatch; class TypedArray; class Uint16Array; class Uint32; class Uint32Array; class Uint8Array; class Uint8ClampedArray; class UnboundModuleScript; class Value; class WasmMemoryObject; class WasmModuleObject; } // namespace v8 #endif // INCLUDE_V8_FORWARD_H_	1.65 KB	2025-03-03 12:36
📄 v8-function-callback.h // Copyright 2021 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. #ifndef INCLUDE_V8_FUNCTION_CALLBACK_H_ #define INCLUDE_V8_FUNCTION_CALLBACK_H_ #include <cstdint> #include <limits> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-primitive.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { template <typename T> class BasicTracedReference; template <typename T> class Global; class Object; class Value; namespace internal { class FunctionCallbackArguments; class PropertyCallbackArguments; class Builtins; } // namespace internal namespace debug { class ConsoleCallArguments; } // namespace debug template <typename T> class ReturnValue { public: template <class S> V8_INLINE ReturnValue(const ReturnValue<S>& that) : value_(that.value_) { static_assert(std::is_base_of<T, S>::value, "type check"); } // Local setters template <typename S> V8_INLINE void Set(const Global<S>& handle); template <typename S> V8_INLINE void SetNonEmpty(const Global<S>& handle); template <typename S> V8_INLINE void Set(const BasicTracedReference<S>& handle); template <typename S> V8_INLINE void SetNonEmpty(const BasicTracedReference<S>& handle); template <typename S> V8_INLINE void Set(const Local<S> handle); template <typename S> V8_INLINE void SetNonEmpty(const Local<S> handle); // Fast primitive setters V8_INLINE void Set(bool value); V8_INLINE void Set(double i); V8_INLINE void Set(int32_t i); V8_INLINE void Set(uint32_t i); V8_INLINE void Set(uint16_t); // Fast JS primitive setters V8_INLINE void SetNull(); V8_INLINE void SetUndefined(); V8_INLINE void SetEmptyString(); // Convenience getter for Isolate V8_INLINE Isolate* GetIsolate() const; // Pointer setter: Uncompilable to prevent inadvertent misuse. template <typename S> V8_INLINE void Set(S* whatever); // Getter. Creates a new Local<> so it comes with a certain performance // hit. If the ReturnValue was not yet set, this will return the undefined // value. V8_INLINE Local<Value> Get() const; private: template <class F> friend class ReturnValue; template <class F> friend class FunctionCallbackInfo; template <class F> friend class PropertyCallbackInfo; template <class F, class G, class H> friend class PersistentValueMapBase; V8_INLINE void SetInternal(internal::Address value); // Setting the hole value has different meanings depending on the usage: // - for function template callbacks it means that the callback returns // the undefined value, // - for property getter callbacks is means that the callback returns // the undefined value (for property setter callbacks the value returned // is ignored), // - for interceptor callbacks it means that the request was not handled. V8_INLINE void SetTheHole(); V8_INLINE explicit ReturnValue(internal::Address* slot); // See FunctionCallbackInfo. static constexpr int kIsolateValueIndex = -2; internal::Address* value_; }; /** * The argument information given to function call callbacks. This * class provides access to information about the context of the call, * including the receiver, the number and values of arguments, and * the holder of the function. / template <typename T> class FunctionCallbackInfo { public: /* The number of available arguments. / V8_INLINE int Length() const; /* * Accessor for the available arguments. Returns `undefined` if the index * is out of bounds. / V8_INLINE Local<Value> operator[](int i) const; /* Returns the receiver. This corresponds to the "this" value. / V8_INLINE Local<Object> This() const; /* * If the callback was created without a Signature, this is the same * value as This(). If there is a signature, and the signature didn't match * This() but one of its hidden prototypes, this will be the respective * hidden prototype. * * Note that this is not the prototype of This() on which the accessor * referencing this callback was found (which in V8 internally is often * referred to as holder [sic]). / V8_INLINE Local<Object> Holder() const; /* For construct calls, this returns the "new.target" value. / V8_INLINE Local<Value> NewTarget() const; /* Indicates whether this is a regular call or a construct call. / V8_INLINE bool IsConstructCall() const; /* The data argument specified when creating the callback. / V8_INLINE Local<Value> Data() const; /* The current Isolate. / V8_INLINE Isolate GetIsolate() const; /** The ReturnValue for the call. / V8_INLINE ReturnValue<T> GetReturnValue() const; private: friend class internal::FunctionCallbackArguments; friend class internal::CustomArguments<FunctionCallbackInfo>; friend class debug::ConsoleCallArguments; static constexpr int kHolderIndex = 0; static constexpr int kIsolateIndex = 1; static constexpr int kUnusedIndex = 2; static constexpr int kReturnValueIndex = 3; static constexpr int kDataIndex = 4; static constexpr int kNewTargetIndex = 5; static constexpr int kArgsLength = 6; static constexpr int kArgsLengthWithReceiver = kArgsLength + 1; // Codegen constants: static constexpr int kSize = 3 internal::kApiSystemPointerSize; static constexpr int kImplicitArgsOffset = 0; static constexpr int kValuesOffset = kImplicitArgsOffset + internal::kApiSystemPointerSize; static constexpr int kLengthOffset = kValuesOffset + internal::kApiSystemPointerSize; static constexpr int kThisValuesIndex = -1; static_assert(ReturnValue<Value>::kIsolateValueIndex == kIsolateIndex - kReturnValueIndex); V8_INLINE FunctionCallbackInfo(internal::Address* implicit_args, internal::Address* values, int length); internal::Address* implicit_args_; internal::Address* values_; int length_; }; /** * The information passed to a property callback about the context * of the property access. / template <typename T> class PropertyCallbackInfo { public: /* * \return The isolate of the property access. / V8_INLINE Isolate GetIsolate() const; /** * \return The data set in the configuration, i.e., in * `NamedPropertyHandlerConfiguration` or * `IndexedPropertyHandlerConfiguration.` / V8_INLINE Local<Value> Data() const; /* * \return The receiver. In many cases, this is the object on which the * property access was intercepted. When using * `Reflect.get`, `Function.prototype.call`, or similar functions, it is the * object passed in as receiver or thisArg. * * \code * void GetterCallback(Local<Name> name, * const v8::PropertyCallbackInfo<v8::Value>& info) { * auto context = info.GetIsolate()->GetCurrentContext(); * * v8::Local<v8::Value> a_this = * info.This() * ->GetRealNamedProperty(context, v8_str("a")) * .ToLocalChecked(); * v8::Local<v8::Value> a_holder = * info.Holder() * ->GetRealNamedProperty(context, v8_str("a")) * .ToLocalChecked(); * * CHECK(v8_str("r")->Equals(context, a_this).FromJust()); * CHECK(v8_str("obj")->Equals(context, a_holder).FromJust()); * * info.GetReturnValue().Set(name); * } * * v8::Local<v8::FunctionTemplate> templ = * v8::FunctionTemplate::New(isolate); * templ->InstanceTemplate()->SetHandler( * v8::NamedPropertyHandlerConfiguration(GetterCallback)); * LocalContext env; * env->Global() * ->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local()) * .ToLocalChecked() * ->NewInstance(env.local()) * .ToLocalChecked()) * .FromJust(); * * CompileRun("obj.a = 'obj'; var r = {a: 'r'}; Reflect.get(obj, 'x', r)"); * \endcode / V8_INLINE Local<Object> This() const; /* * \return The object in the prototype chain of the receiver that has the * interceptor. Suppose you have `x` and its prototype is `y`, and `y` * has an interceptor. Then `info.This()` is `x` and `info.Holder()` is `y`. * The Holder() could be a hidden object (the global object, rather * than the global proxy). * * \note For security reasons, do not pass the object back into the runtime. / V8_INLINE Local<Object> Holder() const; /* * \return The return value of the callback. * Can be changed by calling Set(). * \code * info.GetReturnValue().Set(...) * \endcode * / V8_INLINE ReturnValue<T> GetReturnValue() const; /* * \return True if the intercepted function should throw if an error occurs. * Usually, `true` corresponds to `'use strict'`. * * \note Always `false` when intercepting `Reflect.set()` * independent of the language mode. / V8_INLINE bool ShouldThrowOnError() const; private: friend class MacroAssembler; friend class internal::PropertyCallbackArguments; friend class internal::CustomArguments<PropertyCallbackInfo>; static constexpr int kShouldThrowOnErrorIndex = 0; static constexpr int kHolderIndex = 1; static constexpr int kIsolateIndex = 2; static constexpr int kUnusedIndex = 3; static constexpr int kReturnValueIndex = 4; static constexpr int kDataIndex = 5; static constexpr int kThisIndex = 6; static constexpr int kArgsLength = 7; static constexpr int kSize = 1 internal::kApiSystemPointerSize; V8_INLINE explicit PropertyCallbackInfo(internal::Address* args) : args_(args) {} internal::Address* args_; }; using FunctionCallback = void ()(const FunctionCallbackInfo<Value>& info); // --- Implementation --- template <typename T> ReturnValue<T>::ReturnValue(internal::Address slot) : value_(slot) {} template <typename T> void ReturnValue<T>::SetInternal(internal::Address value) { #if V8_STATIC_ROOTS_BOOL using I = internal::Internals; // Ensure that the upper 32-bits are not modified. Compiler should be // able to optimize this to a store of a lower 32-bits of the value. // This is fine since the callback can return only JavaScript values which // are either Smis or heap objects allocated in the main cage. value_ = I::DecompressTaggedField(value_, I::CompressTagged(value)); #else value_ = value; #endif // V8_STATIC_ROOTS_BOOL } template <typename T> template <typename S> void ReturnValue<T>::Set(const Global<S>& handle) { static_assert(std::is_base_of<T, S>::value, "type check"); if (V8_UNLIKELY(handle.IsEmpty())) { SetTheHole(); } else { SetInternal(handle.ptr()); } } template <typename T> template <typename S> void ReturnValue<T>::SetNonEmpty(const Global<S>& handle) { static_assert(std::is_base_of<T, S>::value, "type check"); #ifdef V8_ENABLE_CHECKS internal::VerifyHandleIsNonEmpty(handle.IsEmpty()); #endif // V8_ENABLE_CHECKS SetInternal(handle.ptr()); } template <typename T> template <typename S> void ReturnValue<T>::Set(const BasicTracedReference<S>& handle) { static_assert(std::is_base_of<T, S>::value, "type check"); if (V8_UNLIKELY(handle.IsEmpty())) { SetTheHole(); } else { SetInternal(handle.ptr()); } } template <typename T> template <typename S> void ReturnValue<T>::SetNonEmpty(const BasicTracedReference<S>& handle) { static_assert(std::is_base_of<T, S>::value, "type check"); #ifdef V8_ENABLE_CHECKS internal::VerifyHandleIsNonEmpty(handle.IsEmpty()); #endif // V8_ENABLE_CHECKS SetInternal(handle.ptr()); } template <typename T> template <typename S> void ReturnValue<T>::Set(const Local<S> handle) { static_assert(std::is_void<T>::value \|\| std::is_base_of<T, S>::value, "type check"); if (V8_UNLIKELY(handle.IsEmpty())) { SetTheHole(); } else { SetInternal(handle.ptr()); } } template <typename T> template <typename S> void ReturnValue<T>::SetNonEmpty(const Local<S> handle) { static_assert(std::is_void<T>::value \|\| std::is_base_of<T, S>::value, "type check"); #ifdef V8_ENABLE_CHECKS internal::VerifyHandleIsNonEmpty(handle.IsEmpty()); #endif // V8_ENABLE_CHECKS SetInternal(handle.ptr()); } template <typename T> void ReturnValue<T>::Set(double i) { static_assert(std::is_base_of<T, Number>::value, "type check"); SetNonEmpty(Number::New(GetIsolate(), i)); } template <typename T> void ReturnValue<T>::Set(int32_t i) { static_assert(std::is_base_of<T, Integer>::value, "type check"); using I = internal::Internals; if (V8_LIKELY(I::IsValidSmi(i))) { SetInternal(I::IntToSmi(i)); return; } SetNonEmpty(Integer::New(GetIsolate(), i)); } template <typename T> void ReturnValue<T>::Set(uint32_t i) { static_assert(std::is_base_of<T, Integer>::value, "type check"); // Can't simply use INT32_MAX here for whatever reason. bool fits_into_int32_t = (i & (1U << 31)) == 0; if (V8_LIKELY(fits_into_int32_t)) { Set(static_cast<int32_t>(i)); return; } SetNonEmpty(Integer::NewFromUnsigned(GetIsolate(), i)); } template <typename T> void ReturnValue<T>::Set(uint16_t i) { static_assert(std::is_base_of<T, Integer>::value, "type check"); using I = internal::Internals; static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::min())); static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::max())); SetInternal(I::IntToSmi(i)); } template <typename T> void ReturnValue<T>::Set(bool value) { static_assert(std::is_base_of<T, Boolean>::value, "type check"); using I = internal::Internals; #if V8_STATIC_ROOTS_BOOL #ifdef V8_ENABLE_CHECKS internal::PerformCastCheck( internal::ValueHelper::SlotAsValue<Value, true>(value_)); #endif // V8_ENABLE_CHECKS SetInternal(value ? I::StaticReadOnlyRoot::kTrueValue : I::StaticReadOnlyRoot::kFalseValue); #else int root_index; if (value) { root_index = I::kTrueValueRootIndex; } else { root_index = I::kFalseValueRootIndex; } value_ = I::GetRoot(GetIsolate(), root_index); #endif // V8_STATIC_ROOTS_BOOL } template <typename T> void ReturnValue<T>::SetTheHole() { using I = internal::Internals; #if V8_STATIC_ROOTS_BOOL SetInternal(I::StaticReadOnlyRoot::kTheHoleValue); #else value_ = I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex); #endif // V8_STATIC_ROOTS_BOOL } template <typename T> void ReturnValue<T>::SetNull() { static_assert(std::is_base_of<T, Primitive>::value, "type check"); using I = internal::Internals; #if V8_STATIC_ROOTS_BOOL #ifdef V8_ENABLE_CHECKS internal::PerformCastCheck( internal::ValueHelper::SlotAsValue<Value, true>(value_)); #endif // V8_ENABLE_CHECKS SetInternal(I::StaticReadOnlyRoot::kNullValue); #else value_ = I::GetRoot(GetIsolate(), I::kNullValueRootIndex); #endif // V8_STATIC_ROOTS_BOOL } template <typename T> void ReturnValue<T>::SetUndefined() { static_assert(std::is_base_of<T, Primitive>::value, "type check"); using I = internal::Internals; #if V8_STATIC_ROOTS_BOOL #ifdef V8_ENABLE_CHECKS internal::PerformCastCheck( internal::ValueHelper::SlotAsValue<Value, true>(value_)); #endif // V8_ENABLE_CHECKS SetInternal(I::StaticReadOnlyRoot::kUndefinedValue); #else value_ = I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex); #endif // V8_STATIC_ROOTS_BOOL } template <typename T> void ReturnValue<T>::SetEmptyString() { static_assert(std::is_base_of<T, String>::value, "type check"); using I = internal::Internals; #if V8_STATIC_ROOTS_BOOL #ifdef V8_ENABLE_CHECKS internal::PerformCastCheck( internal::ValueHelper::SlotAsValue<Value, true>(value_)); #endif // V8_ENABLE_CHECKS SetInternal(I::StaticReadOnlyRoot::kEmptyString); #else value_ = I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex); #endif // V8_STATIC_ROOTS_BOOL } template <typename T> Isolate* ReturnValue<T>::GetIsolate() const { return reinterpret_cast<Isolate>(&value_[kIsolateValueIndex]); } template <typename T> Local<Value> ReturnValue<T>::Get() const { using I = internal::Internals; #if V8_STATIC_ROOTS_BOOL if (I::is_identical(value_, I::StaticReadOnlyRoot::kTheHoleValue)) { #else if (value_ == I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex)) { #endif // V8_STATIC_ROOTS_BOOL return Undefined(GetIsolate()); } return Local<Value>::New(GetIsolate(), internal::ValueHelper::SlotAsValue<Value>(value_)); } template <typename T> template <typename S> void ReturnValue<T>::Set(S whatever) { static_assert(sizeof(S) < 0, "incompilable to prevent inadvertent misuse"); } template <typename T> FunctionCallbackInfo<T>::FunctionCallbackInfo(internal::Address* implicit_args, internal::Address* values, int length) : implicit_args_(implicit_args), values_(values), length_(length) {} template <typename T> Local<Value> FunctionCallbackInfo<T>::operator[](int i) const { // values_ points to the first argument (not the receiver). if (i < 0 \|\| length_ <= i) return Undefined(GetIsolate()); return Local<Value>::FromSlot(values_ + i); } template <typename T> Local<Object> FunctionCallbackInfo<T>::This() const { // values_ points to the first argument (not the receiver). return Local<Object>::FromSlot(values_ + kThisValuesIndex); } template <typename T> Local<Object> FunctionCallbackInfo<T>::Holder() const { return Local<Object>::FromSlot(&implicit_args_[kHolderIndex]); } template <typename T> Local<Value> FunctionCallbackInfo<T>::NewTarget() const { return Local<Value>::FromSlot(&implicit_args_[kNewTargetIndex]); } template <typename T> Local<Value> FunctionCallbackInfo<T>::Data() const { return Local<Value>::FromSlot(&implicit_args_[kDataIndex]); } template <typename T> Isolate* FunctionCallbackInfo<T>::GetIsolate() const { return reinterpret_cast<Isolate>(&implicit_args_[kIsolateIndex]); } template <typename T> ReturnValue<T> FunctionCallbackInfo<T>::GetReturnValue() const { return ReturnValue<T>(&implicit_args_[kReturnValueIndex]); } template <typename T> bool FunctionCallbackInfo<T>::IsConstructCall() const { return !NewTarget()->IsUndefined(); } template <typename T> int FunctionCallbackInfo<T>::Length() const { return length_; } template <typename T> Isolate PropertyCallbackInfo<T>::GetIsolate() const { return reinterpret_cast<Isolate>(&args_[kIsolateIndex]); } template <typename T> Local<Value> PropertyCallbackInfo<T>::Data() const { return Local<Value>::FromSlot(&args_[kDataIndex]); } template <typename T> Local<Object> PropertyCallbackInfo<T>::This() const { return Local<Object>::FromSlot(&args_[kThisIndex]); } template <typename T> Local<Object> PropertyCallbackInfo<T>::Holder() const { return Local<Object>::FromSlot(&args_[kHolderIndex]); } template <typename T> ReturnValue<T> PropertyCallbackInfo<T>::GetReturnValue() const { return ReturnValue<T>(&args_[kReturnValueIndex]); } template <typename T> bool PropertyCallbackInfo<T>::ShouldThrowOnError() const { using I = internal::Internals; if (args_[kShouldThrowOnErrorIndex] != I::IntToSmi(I::kInferShouldThrowMode)) { return args_[kShouldThrowOnErrorIndex] != I::IntToSmi(I::kDontThrow); } return v8::internal::ShouldThrowOnError( reinterpret_cast<v8::internal::Isolate>(GetIsolate())); } } // namespace v8 #endif // INCLUDE_V8_FUNCTION_CALLBACK_H_	19.19 KB	2025-03-03 12:36
📄 v8-function.h // Copyright 2021 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. #ifndef INCLUDE_V8_FUNCTION_H_ #define INCLUDE_V8_FUNCTION_H_ #include <stddef.h> #include <stdint.h> #include "v8-function-callback.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-message.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8-template.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; class UnboundScript; /** * A JavaScript function object (ECMA-262, 15.3). / class V8_EXPORT Function : public Object { public: /* * Create a function in the current execution context * for a given FunctionCallback. / static MaybeLocal<Function> New( Local<Context> context, FunctionCallback callback, Local<Value> data = Local<Value>(), int length = 0, ConstructorBehavior behavior = ConstructorBehavior::kAllow, SideEffectType side_effect_type = SideEffectType::kHasSideEffect); V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstance( Local<Context> context, int argc, Local<Value> argv[]) const; V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstance( Local<Context> context) const { return NewInstance(context, 0, nullptr); } /* * When side effect checks are enabled, passing kHasNoSideEffect allows the * constructor to be invoked without throwing. Calls made within the * constructor are still checked. / V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstanceWithSideEffectType( Local<Context> context, int argc, Local<Value> argv[], SideEffectType side_effect_type = SideEffectType::kHasSideEffect) const; V8_WARN_UNUSED_RESULT MaybeLocal<Value> Call(Local<Context> context, Local<Value> recv, int argc, Local<Value> argv[]); void SetName(Local<String> name); Local<Value> GetName() const; V8_DEPRECATED("No direct replacement") MaybeLocal<UnboundScript> GetUnboundScript() const; /* * Name inferred from variable or property assignment of this function. * Used to facilitate debugging and profiling of JavaScript code written * in an OO style, where many functions are anonymous but are assigned * to object properties. / Local<Value> GetInferredName() const; /* * displayName if it is set, otherwise name if it is configured, otherwise * function name, otherwise inferred name. / Local<Value> GetDebugName() const; /* * Returns zero based line number of function body and * kLineOffsetNotFound if no information available. / int GetScriptLineNumber() const; /* * Returns zero based column number of function body and * kLineOffsetNotFound if no information available. / int GetScriptColumnNumber() const; /* * Returns zero based start position (character offset) of function body and * kLineOffsetNotFound if no information available. / int GetScriptStartPosition() const; /* * Returns scriptId. / int ScriptId() const; /* * Returns the original function if this function is bound, else returns * v8::Undefined. / Local<Value> GetBoundFunction() const; /* * Calls builtin Function.prototype.toString on this function. * This is different from Value::ToString() that may call a user-defined * toString() function, and different than Object::ObjectProtoToString() which * always serializes "[object Function]". / V8_WARN_UNUSED_RESULT MaybeLocal<String> FunctionProtoToString( Local<Context> context); /* * Returns true if the function does nothing. * The function returns false on error. * Note that this function is experimental. Embedders should not rely on * this existing. We may remove this function in the future. / V8_WARN_UNUSED_RESULT bool Experimental_IsNopFunction() const; ScriptOrigin GetScriptOrigin() const; V8_INLINE static Function Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Function>(value); } static const int kLineOffsetNotFound; private: Function(); static void CheckCast(Value obj); }; } // namespace v8 #endif // INCLUDE_V8_FUNCTION_H_	4.42 KB	2025-03-03 12:36
📄 v8-handle-base.h // Copyright 2023 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. #ifndef INCLUDE_V8_HANDLE_BASE_H_ #define INCLUDE_V8_HANDLE_BASE_H_ #include "v8-internal.h" // NOLINT(build/include_directory) namespace v8::api_internal { template <bool check_statically_enabled> class StackAllocated { public: V8_INLINE StackAllocated() = default; protected: struct no_checking_tag {}; static constexpr no_checking_tag do_not_check{}; V8_INLINE explicit StackAllocated(no_checking_tag) {} V8_INLINE explicit StackAllocated(const StackAllocated& other, no_checking_tag) {} V8_INLINE void VerifyOnStack() const {} }; template <> class V8_TRIVIAL_ABI StackAllocated<true> : public StackAllocated<false> { public: V8_INLINE StackAllocated() { VerifyOnStack(); } #if V8_HAS_ATTRIBUTE_TRIVIAL_ABI // In this case, StackAllocated becomes not trivially copyable. V8_INLINE StackAllocated(const StackAllocated& other) { VerifyOnStack(); } StackAllocated& operator=(const StackAllocated&) = default; #endif protected: V8_INLINE explicit StackAllocated(no_checking_tag tag) : StackAllocated<false>(tag) {} V8_INLINE explicit StackAllocated(const StackAllocated& other, no_checking_tag tag) : StackAllocated<false>(other, tag) {} V8_EXPORT void VerifyOnStack() const; }; /** * A base class for abstract handles containing indirect pointers. * These are useful regardless of whether direct local support is enabled. / class IndirectHandleBase { public: // Returns true if the handle is empty. V8_INLINE bool IsEmpty() const { return location_ == nullptr; } // Sets the handle to be empty. IsEmpty() will then return true. V8_INLINE void Clear() { location_ = nullptr; } protected: friend class internal::ValueHelper; friend class internal::HandleHelper; V8_INLINE IndirectHandleBase() = default; V8_INLINE IndirectHandleBase(const IndirectHandleBase& other) = default; V8_INLINE IndirectHandleBase& operator=(const IndirectHandleBase& that) = default; V8_INLINE explicit IndirectHandleBase(internal::Address location) : location_(location) {} // Returns the address of the actual heap object (tagged). // This method must be called only if the handle is not empty, otherwise it // will crash. V8_INLINE internal::Address ptr() const { return location_; } // Returns a reference to the slot (indirect pointer). V8_INLINE internal::Address const& slot() const { return location_; } V8_INLINE internal::Address& slot() { return location_; } // Returns the handler's "value" (direct or indirect pointer, depending on // whether direct local support is enabled). template <typename T, bool check_null = false> V8_INLINE T value() const { return internal::ValueHelper::SlotAsValue<T, check_null>(slot()); } private: internal::Address* location_ = nullptr; }; #ifdef V8_ENABLE_DIRECT_LOCAL /** * A base class for abstract handles containing direct pointers. * These are only possible when conservative stack scanning is enabled. / class DirectHandleBase { public: // Returns true if the handle is empty. V8_INLINE bool IsEmpty() const { return ptr_ == internal::ValueHelper::kEmpty; } // Sets the handle to be empty. IsEmpty() will then return true. V8_INLINE void Clear() { ptr_ = internal::ValueHelper::kEmpty; } protected: friend class internal::ValueHelper; friend class internal::HandleHelper; V8_INLINE DirectHandleBase() = default; V8_INLINE DirectHandleBase(const DirectHandleBase& other) = default; V8_INLINE DirectHandleBase& operator=(const DirectHandleBase& that) = default; V8_INLINE explicit DirectHandleBase(internal::Address ptr) : ptr_(ptr) {} // Returns the address of the referenced object. V8_INLINE internal::Address ptr() const { return ptr_; } // Returns the handler's "value" (direct pointer, as direct local support // is guaranteed to be enabled here). template <typename T, bool check_null = false> V8_INLINE T value() const { return reinterpret_cast<T*>(ptr_); } private: internal::Address ptr_ = internal::ValueHelper::kEmpty; }; #endif // V8_ENABLE_DIRECT_LOCAL } // namespace v8::api_internal #endif // INCLUDE_V8_HANDLE_BASE_H_	4.3 KB	2025-03-03 12:36
📄 v8-initialization.h // Copyright 2021 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. #ifndef INCLUDE_V8_INITIALIZATION_H_ #define INCLUDE_V8_INITIALIZATION_H_ #include <stddef.h> #include <stdint.h> #include "v8-callbacks.h" // NOLINT(build/include_directory) #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-isolate.h" // NOLINT(build/include_directory) #include "v8-platform.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) // We reserve the V8_* prefix for macros defined in V8 public API and // assume there are no name conflicts with the embedder's code. /** * The v8 JavaScript engine. / namespace v8 { class PageAllocator; class Platform; template <class K, class V, class T> class PersistentValueMapBase; /* * EntropySource is used as a callback function when v8 needs a source * of entropy. / using EntropySource = bool ()(unsigned char* buffer, size_t length); /** * ReturnAddressLocationResolver is used as a callback function when v8 is * resolving the location of a return address on the stack. Profilers that * change the return address on the stack can use this to resolve the stack * location to wherever the profiler stashed the original return address. * * \param return_addr_location A location on stack where a machine * return address resides. * \returns Either return_addr_location, or else a pointer to the profiler's * copy of the original return address. * * \note The resolver function must not cause garbage collection. / using ReturnAddressLocationResolver = uintptr_t ()(uintptr_t return_addr_location); using DcheckErrorCallback = void ()(const char file, int line, const char* message); /** * Container class for static utility functions. / class V8_EXPORT V8 { public: /* * Hand startup data to V8, in case the embedder has chosen to build * V8 with external startup data. * * Note: * - By default the startup data is linked into the V8 library, in which * case this function is not meaningful. * - If this needs to be called, it needs to be called before V8 * tries to make use of its built-ins. * - To avoid unnecessary copies of data, V8 will point directly into the * given data blob, so pretty please keep it around until V8 exit. * - Compression of the startup blob might be useful, but needs to * handled entirely on the embedders' side. * - The call will abort if the data is invalid. / static void SetSnapshotDataBlob(StartupData startup_blob); /** Set the callback to invoke in case of Dcheck failures. / static void SetDcheckErrorHandler(DcheckErrorCallback that); /* * Sets V8 flags from a string. / static void SetFlagsFromString(const char str); static void SetFlagsFromString(const char* str, size_t length); /** * Sets V8 flags from the command line. / static void SetFlagsFromCommandLine(int argc, char argv, bool remove_flags); / Get the version string. / static const char GetVersion(); /** * Initializes V8. This function needs to be called before the first Isolate * is created. It always returns true. / V8_INLINE static bool Initialize() { const int kBuildConfiguration = (internal::PointerCompressionIsEnabled() ? kPointerCompression : 0) \| (internal::SmiValuesAre31Bits() ? k31BitSmis : 0) \| (internal::SandboxIsEnabled() ? kSandbox : 0); return Initialize(kBuildConfiguration); } /* * Allows the host application to provide a callback which can be used * as a source of entropy for random number generators. / static void SetEntropySource(EntropySource source); /* * Allows the host application to provide a callback that allows v8 to * cooperate with a profiler that rewrites return addresses on stack. / static void SetReturnAddressLocationResolver( ReturnAddressLocationResolver return_address_resolver); /* * Releases any resources used by v8 and stops any utility threads * that may be running. Note that disposing v8 is permanent, it * cannot be reinitialized. * * It should generally not be necessary to dispose v8 before exiting * a process, this should happen automatically. It is only necessary * to use if the process needs the resources taken up by v8. / static bool Dispose(); /* * Initialize the ICU library bundled with V8. The embedder should only * invoke this method when using the bundled ICU. Returns true on success. * * If V8 was compiled with the ICU data in an external file, the location * of the data file has to be provided. / static bool InitializeICU(const char icu_data_file = nullptr); /** * Initialize the ICU library bundled with V8. The embedder should only * invoke this method when using the bundled ICU. If V8 was compiled with * the ICU data in an external file and when the default location of that * file should be used, a path to the executable must be provided. * Returns true on success. * * The default is a file called icudtl.dat side-by-side with the executable. * * Optionally, the location of the data file can be provided to override the * default. / static bool InitializeICUDefaultLocation(const char exec_path, const char* icu_data_file = nullptr); /** * Initialize the external startup data. The embedder only needs to * invoke this method when external startup data was enabled in a build. * * If V8 was compiled with the startup data in an external file, then * V8 needs to be given those external files during startup. There are * three ways to do this: * - InitializeExternalStartupData(const char) This will look in the given directory for the file "snapshot_blob.bin". * - InitializeExternalStartupDataFromFile(const char) As above, but will directly use the given file name. * - Call SetSnapshotDataBlob. * This will read the blobs from the given data structure and will * not perform any file IO. / static void InitializeExternalStartupData(const char directory_path); static void InitializeExternalStartupDataFromFile(const char* snapshot_blob); /** * Sets the v8::Platform to use. This should be invoked before V8 is * initialized. / static void InitializePlatform(Platform platform); /** * Clears all references to the v8::Platform. This should be invoked after * V8 was disposed. / static void DisposePlatform(); #if defined(V8_ENABLE_SANDBOX) /* * Returns true if the sandbox is configured securely. * * If V8 cannot create a regular sandbox during initialization, for example * because not enough virtual address space can be reserved, it will instead * create a fallback sandbox that still allows it to function normally but * does not have the same security properties as a regular sandbox. This API * can be used to determine if such a fallback sandbox is being used, in * which case it will return false. / static bool IsSandboxConfiguredSecurely(); /* * Provides access to the virtual address subspace backing the sandbox. * * This can be used to allocate pages inside the sandbox, for example to * obtain virtual memory for ArrayBuffer backing stores, which must be * located inside the sandbox. * * It should be assumed that an attacker can corrupt data inside the sandbox, * and so in particular the contents of pages allocagted in this virtual * address space, arbitrarily and concurrently. Due to this, it is * recommended to to only place pure data buffers in them. / static VirtualAddressSpace GetSandboxAddressSpace(); /** * Returns the size of the sandbox in bytes. * * This represents the size of the address space that V8 can directly address * and in which it allocates its objects. / static size_t GetSandboxSizeInBytes(); /* * Returns the size of the address space reservation backing the sandbox. * * This may be larger than the sandbox (i.e. \|GetSandboxSizeInBytes()\|) due * to surrounding guard regions, or may be smaller than the sandbox in case a * fallback sandbox is being used, which will use a smaller virtual address * space reservation. In the latter case this will also be different from * \|GetSandboxAddressSpace()->size()\| as that will cover a larger part of the * address space than what has actually been reserved. / static size_t GetSandboxReservationSizeInBytes(); #endif // V8_ENABLE_SANDBOX /* * Activate trap-based bounds checking for WebAssembly. * * \param use_v8_signal_handler Whether V8 should install its own signal * handler or rely on the embedder's. / static bool EnableWebAssemblyTrapHandler(bool use_v8_signal_handler); #if defined(V8_OS_WIN) /* * On Win64, by default V8 does not emit unwinding data for jitted code, * which means the OS cannot walk the stack frames and the system Structured * Exception Handling (SEH) cannot unwind through V8-generated code: * https://code.google.com/p/v8/issues/detail?id=3598. * * This function allows embedders to register a custom exception handler for * exceptions in V8-generated code. / static void SetUnhandledExceptionCallback( UnhandledExceptionCallback callback); #endif /* * Allows the host application to provide a callback that will be called when * v8 has encountered a fatal failure to allocate memory and is about to * terminate. / static void SetFatalMemoryErrorCallback(OOMErrorCallback callback); /* * Get statistics about the shared memory usage. / static void GetSharedMemoryStatistics(SharedMemoryStatistics statistics); private: V8(); enum BuildConfigurationFeatures { kPointerCompression = 1 << 0, k31BitSmis = 1 << 1, kSandbox = 1 << 2, }; /** * Checks that the embedder build configuration is compatible with * the V8 binary and if so initializes V8. */ static bool Initialize(int build_config); friend class Context; template <class K, class V, class T> friend class PersistentValueMapBase; }; } // namespace v8 #endif // INCLUDE_V8_INITIALIZATION_H_	10.23 KB	2025-03-03 12:36
📄 v8-internal.h // Copyright 2018 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef INCLUDE_V8_INTERNAL_H_ #define INCLUDE_V8_INTERNAL_H_ #include <stddef.h> #include <stdint.h> #include <string.h> #include <atomic> #include <iterator> #include <memory> #include <type_traits> #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Array; class Context; class Data; class Isolate; namespace internal { class Heap; class Isolate; typedef uintptr_t Address; static constexpr Address kNullAddress = 0; constexpr int KB = 1024; constexpr int MB = KB * 1024; constexpr int GB = MB * 1024; #ifdef V8_TARGET_ARCH_X64 constexpr size_t TB = size_t{GB} * 1024; #endif /** * Configuration of tagging scheme. / const int kApiSystemPointerSize = sizeof(void); const int kApiDoubleSize = sizeof(double); const int kApiInt32Size = sizeof(int32_t); const int kApiInt64Size = sizeof(int64_t); const int kApiSizetSize = sizeof(size_t); // Tag information for HeapObject. const int kHeapObjectTag = 1; const int kWeakHeapObjectTag = 3; const int kHeapObjectTagSize = 2; const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1; const intptr_t kHeapObjectReferenceTagMask = 1 << (kHeapObjectTagSize - 1); // Tag information for fowarding pointers stored in object headers. // 0b00 at the lowest 2 bits in the header indicates that the map word is a // forwarding pointer. const int kForwardingTag = 0; const int kForwardingTagSize = 2; const intptr_t kForwardingTagMask = (1 << kForwardingTagSize) - 1; // Tag information for Smi. const int kSmiTag = 0; const int kSmiTagSize = 1; const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1; template <size_t tagged_ptr_size> struct SmiTagging; constexpr intptr_t kIntptrAllBitsSet = intptr_t{-1}; constexpr uintptr_t kUintptrAllBitsSet = static_cast<uintptr_t>(kIntptrAllBitsSet); // Smi constants for systems where tagged pointer is a 32-bit value. template <> struct SmiTagging<4> { enum { kSmiShiftSize = 0, kSmiValueSize = 31 }; static constexpr intptr_t kSmiMinValue = static_cast<intptr_t>(kUintptrAllBitsSet << (kSmiValueSize - 1)); static constexpr intptr_t kSmiMaxValue = -(kSmiMinValue + 1); V8_INLINE static constexpr int SmiToInt(Address value) { int shift_bits = kSmiTagSize + kSmiShiftSize; // Truncate and shift down (requires >> to be sign extending). return static_cast<int32_t>(static_cast<uint32_t>(value)) >> shift_bits; } V8_INLINE static constexpr bool IsValidSmi(intptr_t value) { // Is value in range [kSmiMinValue, kSmiMaxValue]. // Use unsigned operations in order to avoid undefined behaviour in case of // signed integer overflow. return (static_cast<uintptr_t>(value) - static_cast<uintptr_t>(kSmiMinValue)) <= (static_cast<uintptr_t>(kSmiMaxValue) - static_cast<uintptr_t>(kSmiMinValue)); } }; // Smi constants for systems where tagged pointer is a 64-bit value. template <> struct SmiTagging<8> { enum { kSmiShiftSize = 31, kSmiValueSize = 32 }; static constexpr intptr_t kSmiMinValue = static_cast<intptr_t>(kUintptrAllBitsSet << (kSmiValueSize - 1)); static constexpr intptr_t kSmiMaxValue = -(kSmiMinValue + 1); V8_INLINE static constexpr int SmiToInt(Address value) { int shift_bits = kSmiTagSize + kSmiShiftSize; // Shift down and throw away top 32 bits. return static_cast<int>(static_cast<intptr_t>(value) >> shift_bits); } V8_INLINE static constexpr bool IsValidSmi(intptr_t value) { // To be representable as a long smi, the value must be a 32-bit integer. return (value == static_cast<int32_t>(value)); } }; #ifdef V8_COMPRESS_POINTERS // See v8:7703 or src/common/ptr-compr-inl.h for details about pointer // compression. constexpr size_t kPtrComprCageReservationSize = size_t{1} << 32; constexpr size_t kPtrComprCageBaseAlignment = size_t{1} << 32; static_assert( kApiSystemPointerSize == kApiInt64Size, "Pointer compression can be enabled only for 64-bit architectures"); const int kApiTaggedSize = kApiInt32Size; #else const int kApiTaggedSize = kApiSystemPointerSize; #endif constexpr bool PointerCompressionIsEnabled() { return kApiTaggedSize != kApiSystemPointerSize; } #ifdef V8_31BIT_SMIS_ON_64BIT_ARCH using PlatformSmiTagging = SmiTagging<kApiInt32Size>; #else using PlatformSmiTagging = SmiTagging<kApiTaggedSize>; #endif // TODO(ishell): Consinder adding kSmiShiftBits = kSmiShiftSize + kSmiTagSize // since it's used much more often than the inividual constants. const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize; const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize; const int kSmiMinValue = static_cast<int>(PlatformSmiTagging::kSmiMinValue); const int kSmiMaxValue = static_cast<int>(PlatformSmiTagging::kSmiMaxValue); constexpr bool SmiValuesAre31Bits() { return kSmiValueSize == 31; } constexpr bool SmiValuesAre32Bits() { return kSmiValueSize == 32; } constexpr bool Is64() { return kApiSystemPointerSize == sizeof(int64_t); } V8_INLINE static constexpr Address IntToSmi(int value) { return (static_cast<Address>(value) << (kSmiTagSize + kSmiShiftSize)) \| kSmiTag; } /* * Sandbox related types, constants, and functions. / constexpr bool SandboxIsEnabled() { #ifdef V8_ENABLE_SANDBOX return true; #else return false; #endif } // SandboxedPointers are guaranteed to point into the sandbox. This is achieved // for example by storing them as offset rather than as raw pointers. using SandboxedPointer_t = Address; #ifdef V8_ENABLE_SANDBOX // Size of the sandbox, excluding the guard regions surrounding it. #if defined(V8_TARGET_OS_ANDROID) // On Android, most 64-bit devices seem to be configured with only 39 bits of // virtual address space for userspace. As such, limit the sandbox to 128GB (a // quarter of the total available address space). constexpr size_t kSandboxSizeLog2 = 37; // 128 GB #elif defined(V8_TARGET_ARCH_LOONG64) // Some Linux distros on LoongArch64 configured with only 40 bits of virtual // address space for userspace. Limit the sandbox to 256GB here. constexpr size_t kSandboxSizeLog2 = 38; // 256 GB #else // Everywhere else use a 1TB sandbox. constexpr size_t kSandboxSizeLog2 = 40; // 1 TB #endif // V8_TARGET_OS_ANDROID constexpr size_t kSandboxSize = 1ULL << kSandboxSizeLog2; // Required alignment of the sandbox. For simplicity, we require the // size of the guard regions to be a multiple of this, so that this specifies // the alignment of the sandbox including and excluding surrounding guard // regions. The alignment requirement is due to the pointer compression cage // being located at the start of the sandbox. constexpr size_t kSandboxAlignment = kPtrComprCageBaseAlignment; // Sandboxed pointers are stored inside the heap as offset from the sandbox // base shifted to the left. This way, it is guaranteed that the offset is // smaller than the sandbox size after shifting it to the right again. This // constant specifies the shift amount. constexpr uint64_t kSandboxedPointerShift = 64 - kSandboxSizeLog2; // Size of the guard regions surrounding the sandbox. This assumes a worst-case // scenario of a 32-bit unsigned index used to access an array of 64-bit // values. constexpr size_t kSandboxGuardRegionSize = 32ULL GB; static_assert((kSandboxGuardRegionSize % kSandboxAlignment) == 0, "The size of the guard regions around the sandbox must be a " "multiple of its required alignment."); // On OSes where reserving virtual memory is too expensive to reserve the // entire address space backing the sandbox, notably Windows pre 8.1, we create // a partially reserved sandbox that doesn't actually reserve most of the // memory, and so doesn't have the desired security properties as unrelated // memory allocations could end up inside of it, but which still ensures that // objects that should be located inside the sandbox are allocated within // kSandboxSize bytes from the start of the sandbox. The minimum size of the // region that is actually reserved for such a sandbox is specified by this // constant and should be big enough to contain the pointer compression cage as // well as the ArrayBuffer partition. constexpr size_t kSandboxMinimumReservationSize = 8ULL * GB; static_assert(kSandboxMinimumReservationSize > kPtrComprCageReservationSize, "The minimum reservation size for a sandbox must be larger than " "the pointer compression cage contained within it."); // The maximum buffer size allowed inside the sandbox. This is mostly dependent // on the size of the guard regions around the sandbox: an attacker must not be // able to construct a buffer that appears larger than the guard regions and // thereby "reach out of" the sandbox. constexpr size_t kMaxSafeBufferSizeForSandbox = 32ULL * GB - 1; static_assert(kMaxSafeBufferSizeForSandbox <= kSandboxGuardRegionSize, "The maximum allowed buffer size must not be larger than the " "sandbox's guard regions"); constexpr size_t kBoundedSizeShift = 29; static_assert(1ULL << (64 - kBoundedSizeShift) == kMaxSafeBufferSizeForSandbox + 1, "The maximum size of a BoundedSize must be synchronized with the " "kMaxSafeBufferSizeForSandbox"); #endif // V8_ENABLE_SANDBOX #ifdef V8_COMPRESS_POINTERS #ifdef V8_TARGET_OS_ANDROID // The size of the virtual memory reservation for an external pointer table. // This determines the maximum number of entries in a table. Using a maximum // size allows omitting bounds checks on table accesses if the indices are // guaranteed (e.g. through shifting) to be below the maximum index. This // value must be a power of two. constexpr size_t kExternalPointerTableReservationSize = 512 * MB; // The external pointer table indices stored in HeapObjects as external // pointers are shifted to the left by this amount to guarantee that they are // smaller than the maximum table size. constexpr uint32_t kExternalPointerIndexShift = 6; #else constexpr size_t kExternalPointerTableReservationSize = 1024 * MB; constexpr uint32_t kExternalPointerIndexShift = 5; #endif // V8_TARGET_OS_ANDROID // The maximum number of entries in an external pointer table. constexpr int kExternalPointerTableEntrySize = 8; constexpr int kExternalPointerTableEntrySizeLog2 = 3; constexpr size_t kMaxExternalPointers = kExternalPointerTableReservationSize / kExternalPointerTableEntrySize; static_assert((1 << (32 - kExternalPointerIndexShift)) == kMaxExternalPointers, "kExternalPointerTableReservationSize and " "kExternalPointerIndexShift don't match"); #else // !V8_COMPRESS_POINTERS // Needed for the V8.SandboxedExternalPointersCount histogram. constexpr size_t kMaxExternalPointers = 0; #endif // V8_COMPRESS_POINTERS // A ExternalPointerHandle represents a (opaque) reference to an external // pointer that can be stored inside the sandbox. A ExternalPointerHandle has // meaning only in combination with an (active) Isolate as it references an // external pointer stored in the currently active Isolate's // ExternalPointerTable. Internally, an ExternalPointerHandles is simply an // index into an ExternalPointerTable that is shifted to the left to guarantee // that it is smaller than the size of the table. using ExternalPointerHandle = uint32_t; // ExternalPointers point to objects located outside the sandbox. When the V8 // sandbox is enabled, these are stored on heap as ExternalPointerHandles, // otherwise they are simply raw pointers. #ifdef V8_ENABLE_SANDBOX using ExternalPointer_t = ExternalPointerHandle; #else using ExternalPointer_t = Address; #endif constexpr ExternalPointer_t kNullExternalPointer = 0; constexpr ExternalPointerHandle kNullExternalPointerHandle = 0; // // External Pointers. // // When the sandbox is enabled, external pointers are stored in an external // pointer table and are referenced from HeapObjects through an index (a // "handle"). When stored in the table, the pointers are tagged with per-type // tags to prevent type confusion attacks between different external objects. // Besides type information bits, these tags also contain the GC marking bit // which indicates whether the pointer table entry is currently alive. When a // pointer is written into the table, the tag is ORed into the top bits. When // that pointer is later loaded from the table, it is ANDed with the inverse of // the expected tag. If the expected and actual type differ, this will leave // some of the top bits of the pointer set, rendering the pointer inaccessible. // The AND operation also removes the GC marking bit from the pointer. // // The tags are constructed such that UNTAG(TAG(0, T1), T2) != 0 for any two // (distinct) tags T1 and T2. In practice, this is achieved by generating tags // that all have the same number of zeroes and ones but different bit patterns. // With N type tag bits, this allows for (N choose N/2) possible type tags. // Besides the type tag bits, the tags also have the GC marking bit set so that // the marking bit is automatically set when a pointer is written into the // external pointer table (in which case it is clearly alive) and is cleared // when the pointer is loaded. The exception to this is the free entry tag, // which doesn't have the mark bit set, as the entry is not alive. This // construction allows performing the type check and removing GC marking bits // from the pointer in one efficient operation (bitwise AND). The number of // available bits is limited in the following way: on x64, bits [47, 64) are // generally available for tagging (userspace has 47 address bits available). // On Arm64, userspace typically has a 40 or 48 bit address space. However, due // to top-byte ignore (TBI) and memory tagging (MTE), the top byte is unusable // for type checks as type-check failures would go unnoticed or collide with // MTE bits. Some bits of the top byte can, however, still be used for the GC // marking bit. The bits available for the type tags are therefore limited to // [48, 56), i.e. (8 choose 4) = 70 different types. // The following options exist to increase the number of possible types: // - Using multiple ExternalPointerTables since tags can safely be reused // across different tables // - Using "extended" type checks, where additional type information is stored // either in an adjacent pointer table entry or at the pointed-to location // - Using a different tagging scheme, for example based on XOR which would // allow for 2*8 different tags but require a separate operation to remove // the marking bit // // The external pointer sandboxing mechanism ensures that every access to an // external pointer field will result in a valid pointer of the expected type // even in the presence of an attacker able to corrupt memory inside the // sandbox. However, if any data related to the external object is stored // inside the sandbox it may still be corrupted and so must be validated before // use or moved into the external object. Further, an attacker will always be // able to substitute different external pointers of the same type for each // other. Therefore, code using external pointers must be written in a // "substitution-safe" way, i.e. it must always be possible to substitute // external pointers of the same type without causing memory corruption outside // of the sandbox. Generally this is achieved by referencing any group of // related external objects through a single external pointer. // // Currently we use bit 62 for the marking bit which should always be unused as // it's part of the non-canonical address range. When Arm's top-byte ignore // (TBI) is enabled, this bit will be part of the ignored byte, and we assume // that the Embedder is not using this byte (really only this one bit) for any // other purpose. This bit also does not collide with the memory tagging // extension (MTE) which would use bits [56, 60). // // External pointer tables are also available even when the sandbox is off but // pointer compression is on. In that case, the mechanism can be used to easy // alignment requirements as it turns unaligned 64-bit raw pointers into // aligned 32-bit indices. To "opt-in" to the external pointer table mechanism // for this purpose, instead of using the ExternalPointer accessors one needs to // use ExternalPointerHandles directly and use them to access the pointers in an // ExternalPointerTable. constexpr uint64_t kExternalPointerMarkBit = 1ULL << 62; constexpr uint64_t kExternalPointerTagMask = 0x40ff000000000000; constexpr uint64_t kExternalPointerTagMaskWithoutMarkBit = 0xff000000000000; constexpr uint64_t kExternalPointerTagShift = 48; // All possible 8-bit type tags. // These are sorted so that tags can be grouped together and it can efficiently // be checked if a tag belongs to a given group. See for example the // IsSharedExternalPointerType routine. constexpr uint64_t kAllExternalPointerTypeTags[] = { 0b00001111, 0b00010111, 0b00011011, 0b00011101, 0b00011110, 0b00100111, 0b00101011, 0b00101101, 0b00101110, 0b00110011, 0b00110101, 0b00110110, 0b00111001, 0b00111010, 0b00111100, 0b01000111, 0b01001011, 0b01001101, 0b01001110, 0b01010011, 0b01010101, 0b01010110, 0b01011001, 0b01011010, 0b01011100, 0b01100011, 0b01100101, 0b01100110, 0b01101001, 0b01101010, 0b01101100, 0b01110001, 0b01110010, 0b01110100, 0b01111000, 0b10000111, 0b10001011, 0b10001101, 0b10001110, 0b10010011, 0b10010101, 0b10010110, 0b10011001, 0b10011010, 0b10011100, 0b10100011, 0b10100101, 0b10100110, 0b10101001, 0b10101010, 0b10101100, 0b10110001, 0b10110010, 0b10110100, 0b10111000, 0b11000011, 0b11000101, 0b11000110, 0b11001001, 0b11001010, 0b11001100, 0b11010001, 0b11010010, 0b11010100, 0b11011000, 0b11100001, 0b11100010, 0b11100100, 0b11101000, 0b11110000}; #define TAG(i) \ ((kAllExternalPointerTypeTags[i] << kExternalPointerTagShift) \| \ kExternalPointerMarkBit) // clang-format off // When adding new tags, please ensure that the code using these tags is // "substitution-safe", i.e. still operate safely if external pointers of the // same type are swapped by an attacker. See comment above for more details. // Shared external pointers are owned by the shared Isolate and stored in the // shared external pointer table associated with that Isolate, where they can // be accessed from multiple threads at the same time. The objects referenced // in this way must therefore always be thread-safe. #define SHARED_EXTERNAL_POINTER_TAGS(V) \ V(kFirstSharedTag, TAG(0)) \ V(kWaiterQueueNodeTag, TAG(0)) \ V(kExternalStringResourceTag, TAG(1)) \ V(kExternalStringResourceDataTag, TAG(2)) \ V(kLastSharedTag, TAG(2)) // External pointers using these tags are kept in a per-Isolate external // pointer table and can only be accessed when this Isolate is active. #define PER_ISOLATE_EXTERNAL_POINTER_TAGS(V) \ V(kForeignForeignAddressTag, TAG(10)) \ V(kNativeContextMicrotaskQueueTag, TAG(11)) \ V(kEmbedderDataSlotPayloadTag, TAG(12)) \ / This tag essentially stands for a `void` pointer in the V8 API, and / \ /* it is the Embedder's responsibility to ensure type safety (against / \ / substitution) and lifetime validity of these objects. / \ V(kExternalObjectValueTag, TAG(13)) \ V(kFunctionTemplateInfoCallbackTag, TAG(14)) \ V(kAccessorInfoGetterTag, TAG(15)) \ V(kAccessorInfoSetterTag, TAG(16)) \ V(kWasmInternalFunctionCallTargetTag, TAG(17)) \ V(kWasmTypeInfoNativeTypeTag, TAG(18)) \ V(kWasmExportedFunctionDataSignatureTag, TAG(19)) \ V(kWasmContinuationJmpbufTag, TAG(20)) \ V(kWasmIndirectFunctionTargetTag, TAG(21)) \ V(kArrayBufferExtensionTag, TAG(22)) // All external pointer tags. #define ALL_EXTERNAL_POINTER_TAGS(V) \ SHARED_EXTERNAL_POINTER_TAGS(V) \ PER_ISOLATE_EXTERNAL_POINTER_TAGS(V) #define EXTERNAL_POINTER_TAG_ENUM(Name, Tag) Name = Tag, #define MAKE_TAG(HasMarkBit, TypeTag) \ ((static_cast<uint64_t>(TypeTag) << kExternalPointerTagShift) \| \ (HasMarkBit ? kExternalPointerMarkBit : 0)) enum ExternalPointerTag : uint64_t { // Empty tag value. Mostly used as placeholder. kExternalPointerNullTag = MAKE_TAG(1, 0b00000000), // External pointer tag that will match any external pointer. Use with care! kAnyExternalPointerTag = MAKE_TAG(1, 0b11111111), // The free entry tag has all type bits set so every type check with a // different type fails. It also doesn't have the mark bit set as free // entries are (by definition) not alive. kExternalPointerFreeEntryTag = MAKE_TAG(0, 0b11111111), // Evacuation entries are used during external pointer table compaction. kExternalPointerEvacuationEntryTag = MAKE_TAG(1, 0b11100111), ALL_EXTERNAL_POINTER_TAGS(EXTERNAL_POINTER_TAG_ENUM) }; #undef MAKE_TAG #undef TAG #undef EXTERNAL_POINTER_TAG_ENUM // clang-format on // True if the external pointer must be accessed from the shared isolate's // external pointer table. V8_INLINE static constexpr bool IsSharedExternalPointerType( ExternalPointerTag tag) { return tag >= kFirstSharedTag && tag <= kLastSharedTag; } // True if the external pointer may live in a read-only object, in which case // the table entry will be in the shared read-only segment of the external // pointer table. V8_INLINE static constexpr bool IsMaybeReadOnlyExternalPointerType( ExternalPointerTag tag) { return tag == kAccessorInfoGetterTag \|\| tag == kAccessorInfoSetterTag \|\| tag == kFunctionTemplateInfoCallbackTag; } // Sanity checks. #define CHECK_SHARED_EXTERNAL_POINTER_TAGS(Tag, ...) \ static_assert(IsSharedExternalPointerType(Tag)); #define CHECK_NON_SHARED_EXTERNAL_POINTER_TAGS(Tag, ...) \ static_assert(!IsSharedExternalPointerType(Tag)); SHARED_EXTERNAL_POINTER_TAGS(CHECK_SHARED_EXTERNAL_POINTER_TAGS) PER_ISOLATE_EXTERNAL_POINTER_TAGS(CHECK_NON_SHARED_EXTERNAL_POINTER_TAGS) #undef CHECK_NON_SHARED_EXTERNAL_POINTER_TAGS #undef CHECK_SHARED_EXTERNAL_POINTER_TAGS #undef SHARED_EXTERNAL_POINTER_TAGS #undef EXTERNAL_POINTER_TAGS // // Indirect Pointers. // // When the sandbox is enabled, indirect pointers are used to reference // HeapObjects that live outside of the sandbox (but are still managed by V8's // garbage collector). When object A references an object B through an indirect // pointer, object A will contain a IndirectPointerHandle, i.e. a shifted // 32-bit index, which identifies an entry in a pointer table (either the // trusted pointer table for TrustedObjects, or the code pointer table if it is // a Code object). This table entry then contains the actual pointer to object // B. Further, object B owns this pointer table entry, and it is responsible // for updating the "self-pointer" in the entry when it is relocated in memory. // This way, in contrast to "normal" pointers, indirect pointers never need to // be tracked by the GC (i.e. there is no remembered set for them). // These pointers do not exist when the sandbox is disabled. // An IndirectPointerHandle represents a 32-bit index into a pointer table. using IndirectPointerHandle = uint32_t; // A null handle always references an entry that contains nullptr. constexpr IndirectPointerHandle kNullIndirectPointerHandle = 0; // When the sandbox is enabled, indirect pointers are used to implement: // - TrustedPointers: an indirect pointer using the trusted pointer table (TPT) // and referencing a TrustedObject in one of the trusted heap spaces. // - CodePointers, an indirect pointer using the code pointer table (CPT) and // referencing a Code object together with its instruction stream. // // Trusted Pointers. // // A pointer to a TrustedObject. // When the sandbox is enabled, these are indirect pointers using the trusted // pointer table (TPT). They are used to reference trusted objects (located in // one of V8's trusted heap spaces, outside of the sandbox) from inside the // sandbox in a memory-safe way. When the sandbox is disabled, these are // regular tagged pointers. using TrustedPointerHandle = IndirectPointerHandle; // The size of the virtual memory reservation for the trusted pointer table. // As with the external pointer table, a maximum table size in combination with // shifted indices allows omitting bounds checks. constexpr size_t kTrustedPointerTableReservationSize = 64 MB; // The trusted pointer handles are stores shifted to the left by this amount // to guarantee that they are smaller than the maximum table size. constexpr uint32_t kTrustedPointerHandleShift = 9; // A null handle always references an entry that contains nullptr. constexpr TrustedPointerHandle kNullTrustedPointerHandle = kNullIndirectPointerHandle; // The maximum number of entries in an trusted pointer table. constexpr int kTrustedPointerTableEntrySize = 8; constexpr int kTrustedPointerTableEntrySizeLog2 = 3; constexpr size_t kMaxTrustedPointers = kTrustedPointerTableReservationSize / kTrustedPointerTableEntrySize; static_assert((1 << (32 - kTrustedPointerHandleShift)) == kMaxTrustedPointers, "kTrustedPointerTableReservationSize and " "kTrustedPointerHandleShift don't match"); // // Code Pointers. // // A pointer to a Code object. // Essentially a specialized version of a trusted pointer that (when the // sandbox is enabled) uses the code pointer table (CPT) instead of the TPT. // Each entry in the CPT contains both a pointer to a Code object as well as a // pointer to the Code's entrypoint. This allows calling/jumping into Code with // one fewer memory access (compared to the case where the entrypoint pointer // first needs to be loaded from the Code object). As such, a CodePointerHandle // can be used both to obtain the referenced Code object and to directly load // its entrypoint. // // When the sandbox is disabled, these are regular tagged pointers. using CodePointerHandle = IndirectPointerHandle; // The size of the virtual memory reservation for the code pointer table. // As with the other tables, a maximum table size in combination with shifted // indices allows omitting bounds checks. constexpr size_t kCodePointerTableReservationSize = 16 * MB; // Code pointer handles are shifted by a different amount than indirect pointer // handles as the tables have a different maximum size. constexpr uint32_t kCodePointerHandleShift = 12; // A null handle always references an entry that contains nullptr. constexpr CodePointerHandle kNullCodePointerHandle = kNullIndirectPointerHandle; // It can sometimes be necessary to distinguish a code pointer handle from a // trusted pointer handle. A typical example would be a union trusted pointer // field that can refer to both Code objects and other trusted objects. To // support these use-cases, we use a simple marking scheme where some of the // low bits of a code pointer handle are set, while they will be unset on a // trusted pointer handle. This way, the correct table to resolve the handle // can be determined even in the absence of a type tag. constexpr uint32_t kCodePointerHandleMarker = 0x1; static_assert(kCodePointerHandleShift > 0); static_assert(kTrustedPointerHandleShift > 0); // The maximum number of entries in a code pointer table. constexpr int kCodePointerTableEntrySize = 16; constexpr int kCodePointerTableEntrySizeLog2 = 4; constexpr size_t kMaxCodePointers = kCodePointerTableReservationSize / kCodePointerTableEntrySize; static_assert( (1 << (32 - kCodePointerHandleShift)) == kMaxCodePointers, "kCodePointerTableReservationSize and kCodePointerHandleShift don't match"); constexpr int kCodePointerTableEntryEntrypointOffset = 0; constexpr int kCodePointerTableEntryCodeObjectOffset = 8; // Constants that can be used to mark places that should be modified once // certain types of objects are moved out of the sandbox and into trusted space. constexpr bool kRuntimeGeneratedCodeObjectsLiveInTrustedSpace = true; constexpr bool kBuiltinCodeObjectsLiveInTrustedSpace = false; constexpr bool kAllCodeObjectsLiveInTrustedSpace = kRuntimeGeneratedCodeObjectsLiveInTrustedSpace && kBuiltinCodeObjectsLiveInTrustedSpace; // {obj} must be the raw tagged pointer representation of a HeapObject // that's guaranteed to never be in ReadOnlySpace. V8_EXPORT internal::Isolate* IsolateFromNeverReadOnlySpaceObject(Address obj); // Returns if we need to throw when an error occurs. This infers the language // mode based on the current context and the closure. This returns true if the // language mode is strict. V8_EXPORT bool ShouldThrowOnError(internal::Isolate* isolate); /** * This class exports constants and functionality from within v8 that * is necessary to implement inline functions in the v8 api. Don't * depend on functions and constants defined here. / class Internals { #ifdef V8_MAP_PACKING V8_INLINE static constexpr Address UnpackMapWord(Address mapword) { // TODO(wenyuzhao): Clear header metadata. return mapword ^ kMapWordXorMask; } #endif public: // These values match non-compiler-dependent values defined within // the implementation of v8. static const int kHeapObjectMapOffset = 0; static const int kMapInstanceTypeOffset = 1 kApiTaggedSize + kApiInt32Size; static const int kStringResourceOffset = 1 * kApiTaggedSize + 2 * kApiInt32Size; static const int kOddballKindOffset = 4 * kApiTaggedSize + kApiDoubleSize; static const int kJSObjectHeaderSize = 3 * kApiTaggedSize; static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize; static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize; static const int kEmbedderDataSlotSize = kApiSystemPointerSize; #ifdef V8_ENABLE_SANDBOX static const int kEmbedderDataSlotExternalPointerOffset = kApiTaggedSize; #else static const int kEmbedderDataSlotExternalPointerOffset = 0; #endif static const int kNativeContextEmbedderDataOffset = 6 * kApiTaggedSize; static const int kStringRepresentationAndEncodingMask = 0x0f; static const int kStringEncodingMask = 0x8; static const int kExternalTwoByteRepresentationTag = 0x02; static const int kExternalOneByteRepresentationTag = 0x0a; static const uint32_t kNumIsolateDataSlots = 4; static const int kStackGuardSize = 8 * kApiSystemPointerSize; static const int kNumberOfBooleanFlags = 6; static const int kErrorMessageParamSize = 1; static const int kTablesAlignmentPaddingSize = 1; static const int kBuiltinTier0EntryTableSize = 7 * kApiSystemPointerSize; static const int kBuiltinTier0TableSize = 7 * kApiSystemPointerSize; static const int kLinearAllocationAreaSize = 3 * kApiSystemPointerSize; static const int kThreadLocalTopSize = 30 * kApiSystemPointerSize; static const int kHandleScopeDataSize = 2 * kApiSystemPointerSize + 2 * kApiInt32Size; // ExternalPointerTable and TrustedPointerTable layout guarantees. static const int kExternalPointerTableBasePointerOffset = 0; static const int kExternalPointerTableSize = 2 * kApiSystemPointerSize; static const int kTrustedPointerTableSize = 2 * kApiSystemPointerSize; static const int kTrustedPointerTableBasePointerOffset = 0; // IsolateData layout guarantees. static const int kIsolateCageBaseOffset = 0; static const int kIsolateStackGuardOffset = kIsolateCageBaseOffset + kApiSystemPointerSize; static const int kVariousBooleanFlagsOffset = kIsolateStackGuardOffset + kStackGuardSize; static const int kErrorMessageParamOffset = kVariousBooleanFlagsOffset + kNumberOfBooleanFlags; static const int kBuiltinTier0EntryTableOffset = kErrorMessageParamOffset + kErrorMessageParamSize + kTablesAlignmentPaddingSize; static const int kBuiltinTier0TableOffset = kBuiltinTier0EntryTableOffset + kBuiltinTier0EntryTableSize; static const int kNewAllocationInfoOffset = kBuiltinTier0TableOffset + kBuiltinTier0TableSize; static const int kOldAllocationInfoOffset = kNewAllocationInfoOffset + kLinearAllocationAreaSize; static const int kFastCCallAlignmentPaddingSize = kApiSystemPointerSize == 8 ? 0 : kApiSystemPointerSize; static const int kIsolateFastCCallCallerFpOffset = kOldAllocationInfoOffset + kLinearAllocationAreaSize + kFastCCallAlignmentPaddingSize; static const int kIsolateFastCCallCallerPcOffset = kIsolateFastCCallCallerFpOffset + kApiSystemPointerSize; static const int kIsolateFastApiCallTargetOffset = kIsolateFastCCallCallerPcOffset + kApiSystemPointerSize; static const int kIsolateLongTaskStatsCounterOffset = kIsolateFastApiCallTargetOffset + kApiSystemPointerSize; static const int kIsolateThreadLocalTopOffset = kIsolateLongTaskStatsCounterOffset + kApiSizetSize; static const int kIsolateHandleScopeDataOffset = kIsolateThreadLocalTopOffset + kThreadLocalTopSize; static const int kIsolateEmbedderDataOffset = kIsolateHandleScopeDataOffset + kHandleScopeDataSize; #ifdef V8_COMPRESS_POINTERS static const int kIsolateExternalPointerTableOffset = kIsolateEmbedderDataOffset + kNumIsolateDataSlots * kApiSystemPointerSize; static const int kIsolateSharedExternalPointerTableAddressOffset = kIsolateExternalPointerTableOffset + kExternalPointerTableSize; #ifdef V8_ENABLE_SANDBOX static const int kIsolateTrustedCageBaseOffset = kIsolateSharedExternalPointerTableAddressOffset + kApiSystemPointerSize; static const int kIsolateTrustedPointerTableOffset = kIsolateTrustedCageBaseOffset + kApiSystemPointerSize; static const int kIsolateApiCallbackThunkArgumentOffset = kIsolateTrustedPointerTableOffset + kTrustedPointerTableSize; #else static const int kIsolateApiCallbackThunkArgumentOffset = kIsolateSharedExternalPointerTableAddressOffset + kApiSystemPointerSize; #endif // V8_ENABLE_SANDBOX #else static const int kIsolateApiCallbackThunkArgumentOffset = kIsolateEmbedderDataOffset + kNumIsolateDataSlots * kApiSystemPointerSize; #endif // V8_COMPRESS_POINTERS static const int kContinuationPreservedEmbedderDataOffset = kIsolateApiCallbackThunkArgumentOffset + kApiSystemPointerSize; static const int kWasm64OOBOffsetAlignmentPaddingSize = 0; static const int kWasm64OOBOffsetOffset = kContinuationPreservedEmbedderDataOffset + kApiSystemPointerSize + kWasm64OOBOffsetAlignmentPaddingSize; static const int kIsolateRootsOffset = kWasm64OOBOffsetOffset + sizeof(int64_t); #if V8_STATIC_ROOTS_BOOL // These constants are copied from static-roots.h and guarded by static asserts. #define EXPORTED_STATIC_ROOTS_PTR_LIST(V) \ V(UndefinedValue, 0x69) \ V(NullValue, 0x85) \ V(TrueValue, 0xc9) \ V(FalseValue, 0xad) \ V(EmptyString, 0xa1) \ V(TheHoleValue, 0x719) using Tagged_t = uint32_t; struct StaticReadOnlyRoot { #define DEF_ROOT(name, value) static constexpr Tagged_t k##name = value; EXPORTED_STATIC_ROOTS_PTR_LIST(DEF_ROOT) #undef DEF_ROOT static constexpr Tagged_t kFirstStringMap = 0xe5; static constexpr Tagged_t kLastStringMap = 0x47d; #define PLUSONE(...) +1 static constexpr size_t kNumberOfExportedStaticRoots = 2 + EXPORTED_STATIC_ROOTS_PTR_LIST(PLUSONE); #undef PLUSONE }; #endif // V8_STATIC_ROOTS_BOOL static const int kUndefinedValueRootIndex = 4; static const int kTheHoleValueRootIndex = 5; static const int kNullValueRootIndex = 6; static const int kTrueValueRootIndex = 7; static const int kFalseValueRootIndex = 8; static const int kEmptyStringRootIndex = 9; static const int kNodeClassIdOffset = 1 * kApiSystemPointerSize; static const int kNodeFlagsOffset = 1 * kApiSystemPointerSize + 3; static const int kNodeStateMask = 0x3; static const int kNodeStateIsWeakValue = 2; static const int kFirstNonstringType = 0x80; static const int kOddballType = 0x83; static const int kForeignType = 0xcc; static const int kJSSpecialApiObjectType = 0x410; static const int kJSObjectType = 0x421; static const int kFirstJSApiObjectType = 0x422; static const int kLastJSApiObjectType = 0x80A; // Defines a range [kFirstEmbedderJSApiObjectType, kJSApiObjectTypesCount] // of JSApiObject instance type values that an embedder can use. static const int kFirstEmbedderJSApiObjectType = 0; static const int kLastEmbedderJSApiObjectType = kLastJSApiObjectType - kFirstJSApiObjectType; static const int kUndefinedOddballKind = 4; static const int kNullOddballKind = 3; // Constants used by PropertyCallbackInfo to check if we should throw when an // error occurs. static const int kThrowOnError = 0; static const int kDontThrow = 1; static const int kInferShouldThrowMode = 2; // Soft limit for AdjustAmountofExternalAllocatedMemory. Trigger an // incremental GC once the external memory reaches this limit. static constexpr int kExternalAllocationSoftLimit = 64 * 1024 * 1024; #ifdef V8_MAP_PACKING static const uintptr_t kMapWordMetadataMask = 0xffffULL << 48; // The lowest two bits of mapwords are always `0b10` static const uintptr_t kMapWordSignature = 0b10; // XORing a (non-compressed) map with this mask ensures that the two // low-order bits are 0b10. The 0 at the end makes this look like a Smi, // although real Smis have all lower 32 bits unset. We only rely on these // values passing as Smis in very few places. static const int kMapWordXorMask = 0b11; #endif V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate); V8_INLINE static void CheckInitialized(v8::Isolate* isolate) { #ifdef V8_ENABLE_CHECKS CheckInitializedImpl(isolate); #endif } V8_INLINE static constexpr bool HasHeapObjectTag(Address value) { return (value & kHeapObjectTagMask) == static_cast<Address>(kHeapObjectTag); } V8_INLINE static constexpr int SmiValue(Address value) { return PlatformSmiTagging::SmiToInt(value); } V8_INLINE static constexpr Address IntToSmi(int value) { return internal::IntToSmi(value); } V8_INLINE static constexpr bool IsValidSmi(intptr_t value) { return PlatformSmiTagging::IsValidSmi(value); } #if V8_STATIC_ROOTS_BOOL V8_INLINE static bool is_identical(Address obj, Tagged_t constant) { return static_cast<Tagged_t>(obj) == constant; } V8_INLINE static bool CheckInstanceMapRange(Address obj, Tagged_t first_map, Tagged_t last_map) { auto map = ReadRawField<Tagged_t>(obj, kHeapObjectMapOffset); #ifdef V8_MAP_PACKING map = UnpackMapWord(map); #endif return map >= first_map && map <= last_map; } #endif V8_INLINE static int GetInstanceType(Address obj) { Address map = ReadTaggedPointerField(obj, kHeapObjectMapOffset); #ifdef V8_MAP_PACKING map = UnpackMapWord(map); #endif return ReadRawField<uint16_t>(map, kMapInstanceTypeOffset); } V8_INLINE static Address LoadMap(Address obj) { if (!HasHeapObjectTag(obj)) return kNullAddress; Address map = ReadTaggedPointerField(obj, kHeapObjectMapOffset); #ifdef V8_MAP_PACKING map = UnpackMapWord(map); #endif return map; } V8_INLINE static int GetOddballKind(Address obj) { return SmiValue(ReadTaggedSignedField(obj, kOddballKindOffset)); } V8_INLINE static bool IsExternalTwoByteString(int instance_type) { int representation = (instance_type & kStringRepresentationAndEncodingMask); return representation == kExternalTwoByteRepresentationTag; } V8_INLINE static constexpr bool CanHaveInternalField(int instance_type) { static_assert(kJSObjectType + 1 == kFirstJSApiObjectType); static_assert(kJSObjectType < kLastJSApiObjectType); static_assert(kFirstJSApiObjectType < kLastJSApiObjectType); // Check for IsJSObject() \|\| IsJSSpecialApiObject() \|\| IsJSApiObject() return instance_type == kJSSpecialApiObjectType \|\| // inlined version of base::IsInRange (static_cast<unsigned>(static_cast<unsigned>(instance_type) - static_cast<unsigned>(kJSObjectType)) <= static_cast<unsigned>(kLastJSApiObjectType - kJSObjectType)); } V8_INLINE static uint8_t GetNodeFlag(Address* obj, int shift) { uint8_t* addr = reinterpret_cast<uint8_t>(obj) + kNodeFlagsOffset; return addr & static_cast<uint8_t>(1U << shift); } V8_INLINE static void UpdateNodeFlag(Address* obj, bool value, int shift) { uint8_t* addr = reinterpret_cast<uint8_t>(obj) + kNodeFlagsOffset; uint8_t mask = static_cast<uint8_t>(1U << shift); addr = static_cast<uint8_t>((addr & ~mask) \| (value << shift)); } V8_INLINE static uint8_t GetNodeState(Address obj) { uint8_t* addr = reinterpret_cast<uint8_t>(obj) + kNodeFlagsOffset; return addr & kNodeStateMask; } V8_INLINE static void UpdateNodeState(Address* obj, uint8_t value) { uint8_t* addr = reinterpret_cast<uint8_t>(obj) + kNodeFlagsOffset; addr = static_cast<uint8_t>((addr & ~kNodeStateMask) \| value); } V8_INLINE static void SetEmbedderData(v8::Isolate isolate, uint32_t slot, void* data) { Address addr = reinterpret_cast<Address>(isolate) + kIsolateEmbedderDataOffset + slot * kApiSystemPointerSize; reinterpret_cast<void>(addr) = data; } V8_INLINE static void GetEmbedderData(const v8::Isolate* isolate, uint32_t slot) { Address addr = reinterpret_cast<Address>(isolate) + kIsolateEmbedderDataOffset + slot * kApiSystemPointerSize; return reinterpret_cast<void const>(addr); } V8_INLINE static void IncrementLongTasksStatsCounter(v8::Isolate isolate) { Address addr = reinterpret_cast<Address>(isolate) + kIsolateLongTaskStatsCounterOffset; ++(reinterpret_cast<size_t>(addr)); } V8_INLINE static Address* GetRootSlot(v8::Isolate* isolate, int index) { Address addr = reinterpret_cast<Address>(isolate) + kIsolateRootsOffset + index * kApiSystemPointerSize; return reinterpret_cast<Address>(addr); } V8_INLINE static Address GetRoot(v8::Isolate isolate, int index) { #if V8_STATIC_ROOTS_BOOL Address base = reinterpret_cast<Address>( reinterpret_cast<uintptr_t>(isolate) + kIsolateCageBaseOffset); switch (index) { #define DECOMPRESS_ROOT(name, ...) \ case k##name##RootIndex: \ return base + StaticReadOnlyRoot::k##name; EXPORTED_STATIC_ROOTS_PTR_LIST(DECOMPRESS_ROOT) #undef DECOMPRESS_ROOT #undef EXPORTED_STATIC_ROOTS_PTR_LIST default: break; } #endif // V8_STATIC_ROOTS_BOOL return GetRootSlot(isolate, index); } #ifdef V8_ENABLE_SANDBOX V8_INLINE static Address GetExternalPointerTableBase(v8::Isolate* isolate) { Address addr = reinterpret_cast<Address>(isolate) + kIsolateExternalPointerTableOffset + kExternalPointerTableBasePointerOffset; return reinterpret_cast<Address>(addr); } V8_INLINE static Address GetSharedExternalPointerTableBase( v8::Isolate* isolate) { Address addr = reinterpret_cast<Address>(isolate) + kIsolateSharedExternalPointerTableAddressOffset; addr = reinterpret_cast<Address>(addr); addr += kExternalPointerTableBasePointerOffset; return reinterpret_cast<Address>(addr); } #endif template <typename T> V8_INLINE static T ReadRawField(Address heap_object_ptr, int offset) { Address addr = heap_object_ptr + offset - kHeapObjectTag; #ifdef V8_COMPRESS_POINTERS if (sizeof(T) > kApiTaggedSize) { // TODO(ishell, v8:8875): When pointer compression is enabled 8-byte size // fields (external pointers, doubles and BigInt data) are only // kTaggedSize aligned so we have to use unaligned pointer friendly way of // accessing them in order to avoid undefined behavior in C++ code. T r; memcpy(&r, reinterpret_cast<void>(addr), sizeof(T)); return r; } #endif return reinterpret_cast<const T>(addr); } V8_INLINE static Address ReadTaggedPointerField(Address heap_object_ptr, int offset) { #ifdef V8_COMPRESS_POINTERS uint32_t value = ReadRawField<uint32_t>(heap_object_ptr, offset); Address base = GetPtrComprCageBaseFromOnHeapAddress(heap_object_ptr); return base + static_cast<Address>(static_cast<uintptr_t>(value)); #else return ReadRawField<Address>(heap_object_ptr, offset); #endif } V8_INLINE static Address ReadTaggedSignedField(Address heap_object_ptr, int offset) { #ifdef V8_COMPRESS_POINTERS uint32_t value = ReadRawField<uint32_t>(heap_object_ptr, offset); return static_cast<Address>(static_cast<uintptr_t>(value)); #else return ReadRawField<Address>(heap_object_ptr, offset); #endif } V8_INLINE static v8::Isolate* GetIsolateForSandbox(Address obj) { #ifdef V8_ENABLE_SANDBOX return reinterpret_cast<v8::Isolate>( internal::IsolateFromNeverReadOnlySpaceObject(obj)); #else // Not used in non-sandbox mode. return nullptr; #endif } template <ExternalPointerTag tag> V8_INLINE static Address ReadExternalPointerField(v8::Isolate isolate, Address heap_object_ptr, int offset) { #ifdef V8_ENABLE_SANDBOX static_assert(tag != kExternalPointerNullTag); // See src/sandbox/external-pointer-table-inl.h. Logic duplicated here so // it can be inlined and doesn't require an additional call. Address* table = IsSharedExternalPointerType(tag) ? GetSharedExternalPointerTableBase(isolate) : GetExternalPointerTableBase(isolate); internal::ExternalPointerHandle handle = ReadRawField<ExternalPointerHandle>(heap_object_ptr, offset); uint32_t index = handle >> kExternalPointerIndexShift; std::atomic<Address>* ptr = reinterpret_cast<std::atomic<Address>>(&table[index]); Address entry = std::atomic_load_explicit(ptr, std::memory_order_relaxed); return entry & ~tag; #else return ReadRawField<Address>(heap_object_ptr, offset); #endif // V8_ENABLE_SANDBOX } #ifdef V8_COMPRESS_POINTERS V8_INLINE static Address GetPtrComprCageBaseFromOnHeapAddress(Address addr) { return addr & -static_cast<intptr_t>(kPtrComprCageBaseAlignment); } V8_INLINE static uint32_t CompressTagged(Address value) { return static_cast<uint32_t>(value); } V8_INLINE static Address DecompressTaggedField(Address heap_object_ptr, uint32_t value) { Address base = GetPtrComprCageBaseFromOnHeapAddress(heap_object_ptr); return base + static_cast<Address>(static_cast<uintptr_t>(value)); } #endif // V8_COMPRESS_POINTERS }; // Only perform cast check for types derived from v8::Data since // other types do not implement the Cast method. template <bool PerformCheck> struct CastCheck { template <class T> static void Perform(T data); }; template <> template <class T> void CastCheck<true>::Perform(T* data) { T::Cast(data); } template <> template <class T> void CastCheck<false>::Perform(T* data) {} template <class T> V8_INLINE void PerformCastCheck(T* data) { CastCheck<std::is_base_of<Data, T>::value && !std::is_same<Data, std::remove_cv_t<T>>::value>::Perform(data); } // A base class for backing stores, which is needed due to vagaries of // how static casts work with std::shared_ptr. class BackingStoreBase {}; // The maximum value in enum GarbageCollectionReason, defined in heap.h. // This is needed for histograms sampling garbage collection reasons. constexpr int kGarbageCollectionReasonMaxValue = 27; // Base class for the address block allocator compatible with standard // containers, which registers its allocated range as strong roots. class V8_EXPORT StrongRootAllocatorBase { public: Heap* heap() const { return heap_; } bool operator==(const StrongRootAllocatorBase& other) const { return heap_ == other.heap_; } bool operator!=(const StrongRootAllocatorBase& other) const { return heap_ != other.heap_; } protected: explicit StrongRootAllocatorBase(Heap* heap) : heap_(heap) {} explicit StrongRootAllocatorBase(v8::Isolate* isolate); // Allocate/deallocate a range of n elements of type internal::Address. Address* allocate_impl(size_t n); void deallocate_impl(Address* p, size_t n) noexcept; private: Heap* heap_; }; // The general version of this template behaves just as std::allocator, with // the exception that the constructor takes the isolate as parameter. Only // specialized versions, e.g., internal::StrongRootAllocator<internal::Address> // and internal::StrongRootAllocator<v8::Local<T>> register the allocated range // as strong roots. template <typename T> class StrongRootAllocator : public StrongRootAllocatorBase, private std::allocator<T> { public: using value_type = T; explicit StrongRootAllocator(Heap* heap) : StrongRootAllocatorBase(heap) {} explicit StrongRootAllocator(v8::Isolate* isolate) : StrongRootAllocatorBase(isolate) {} template <typename U> StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept : StrongRootAllocatorBase(other) {} using std::allocator<T>::allocate; using std::allocator<T>::deallocate; }; // A class of iterators that wrap some different iterator type. // If specified, ElementType is the type of element accessed by the wrapper // iterator; in this case, the actual reference and pointer types of Iterator // must be convertible to ElementType& and ElementType, respectively. template <typename Iterator, typename ElementType = void> class WrappedIterator { public: static_assert( !std::is_void_v<ElementType> \|\| (std::is_convertible_v<typename std::iterator_traits<Iterator>::pointer, ElementType> && std::is_convertible_v<typename std::iterator_traits<Iterator>::reference, ElementType&>)); using iterator_category = typename std::iterator_traits<Iterator>::iterator_category; using difference_type = typename std::iterator_traits<Iterator>::difference_type; using value_type = std::conditional_t<std::is_void_v<ElementType>, typename std::iterator_traits<Iterator>::value_type, ElementType>; using pointer = std::conditional_t<std::is_void_v<ElementType>, typename std::iterator_traits<Iterator>::pointer, ElementType>; using reference = std::conditional_t<std::is_void_v<ElementType>, typename std::iterator_traits<Iterator>::reference, ElementType&>; constexpr WrappedIterator() noexcept : it_() {} constexpr explicit WrappedIterator(Iterator it) noexcept : it_(it) {} template <typename OtherIterator, typename OtherElementType, std::enable_if_t<std::is_convertible_v<OtherIterator, Iterator>, bool> = true> constexpr WrappedIterator( const WrappedIterator<OtherIterator, OtherElementType>& it) noexcept : it_(it.base()) {} constexpr reference operator() const noexcept { return it_; } constexpr pointer operator->() const noexcept { return it_.operator->(); } constexpr WrappedIterator& operator++() noexcept { ++it_; return this; } constexpr WrappedIterator operator++(int) noexcept { WrappedIterator result(this); ++(this); return result; } constexpr WrappedIterator& operator--() noexcept { --it_; return this; } constexpr WrappedIterator operator--(int) noexcept { WrappedIterator result(this); --(this); return result; } constexpr WrappedIterator operator+(difference_type n) const noexcept { WrappedIterator result(this); result += n; return result; } constexpr WrappedIterator& operator+=(difference_type n) noexcept { it_ += n; return this; } constexpr WrappedIterator operator-(difference_type n) const noexcept { return this + (-n); } constexpr WrappedIterator& operator-=(difference_type n) noexcept { this += -n; return this; } constexpr reference operator[](difference_type n) const noexcept { return it_[n]; } constexpr Iterator base() const noexcept { return it_; } private: template <typename OtherIterator, typename OtherElementType> friend class WrappedIterator; private: Iterator it_; }; template <typename Iterator, typename ElementType, typename OtherIterator, typename OtherElementType> constexpr bool operator==( const WrappedIterator<Iterator, ElementType>& x, const WrappedIterator<OtherIterator, OtherElementType>& y) noexcept { return x.base() == y.base(); } template <typename Iterator, typename ElementType, typename OtherIterator, typename OtherElementType> constexpr bool operator<( const WrappedIterator<Iterator, ElementType>& x, const WrappedIterator<OtherIterator, OtherElementType>& y) noexcept { return x.base() < y.base(); } template <typename Iterator, typename ElementType, typename OtherIterator, typename OtherElementType> constexpr bool operator!=( const WrappedIterator<Iterator, ElementType>& x, const WrappedIterator<OtherIterator, OtherElementType>& y) noexcept { return !(x == y); } template <typename Iterator, typename ElementType, typename OtherIterator, typename OtherElementType> constexpr bool operator>( const WrappedIterator<Iterator, ElementType>& x, const WrappedIterator<OtherIterator, OtherElementType>& y) noexcept { return y < x; } template <typename Iterator, typename ElementType, typename OtherIterator, typename OtherElementType> constexpr bool operator>=( const WrappedIterator<Iterator, ElementType>& x, const WrappedIterator<OtherIterator, OtherElementType>& y) noexcept { return !(x < y); } template <typename Iterator, typename ElementType, typename OtherIterator, typename OtherElementType> constexpr bool operator<=( const WrappedIterator<Iterator, ElementType>& x, const WrappedIterator<OtherIterator, OtherElementType>& y) noexcept { return !(y < x); } template <typename Iterator, typename ElementType, typename OtherIterator, typename OtherElementType> constexpr auto operator-( const WrappedIterator<Iterator, ElementType>& x, const WrappedIterator<OtherIterator, OtherElementType>& y) noexcept -> decltype(x.base() - y.base()) { return x.base() - y.base(); } template <typename Iterator, typename ElementType> constexpr WrappedIterator<Iterator> operator+( typename WrappedIterator<Iterator, ElementType>::difference_type n, const WrappedIterator<Iterator, ElementType>& x) noexcept { x += n; return x; } // Helper functions about values contained in handles. // A value is either an indirect pointer or a direct pointer, depending on // whether direct local support is enabled. class ValueHelper final { public: #ifdef V8_ENABLE_DIRECT_LOCAL static constexpr Address kTaggedNullAddress = 1; static constexpr Address kEmpty = kTaggedNullAddress; #else static constexpr Address kEmpty = kNullAddress; #endif // V8_ENABLE_DIRECT_LOCAL template <typename T> V8_INLINE static bool IsEmpty(T* value) { return reinterpret_cast<Address>(value) == kEmpty; } // Returns a handle's "value" for all kinds of abstract handles. For Local, // it is equivalent to `handle`. The variadic parameters support handle // types with extra type parameters, like `Persistent<T, M>`. template <template <typename T, typename... Ms> typename H, typename T, typename... Ms> V8_INLINE static T HandleAsValue(const H<T, Ms...>& handle) { return handle.template value<T>(); } #ifdef V8_ENABLE_DIRECT_LOCAL template <typename T> V8_INLINE static Address ValueAsAddress(const T* value) { return reinterpret_cast<Address>(value); } template <typename T, bool check_null = true, typename S> V8_INLINE static T* SlotAsValue(S* slot) { if (check_null && slot == nullptr) { return reinterpret_cast<T>(kTaggedNullAddress); } return reinterpret_cast<T*>(slot); } #else // !V8_ENABLE_DIRECT_LOCAL template <typename T> V8_INLINE static Address ValueAsAddress(const T value) { return reinterpret_cast<const Address>(value); } template <typename T, bool check_null = true, typename S> V8_INLINE static T* SlotAsValue(S* slot) { return reinterpret_cast<T>(slot); } #endif // V8_ENABLE_DIRECT_LOCAL }; /* * Helper functions about handles. / class HandleHelper final { public: /* * Checks whether two handles are equal. * They are equal iff they are both empty or they are both non-empty and the * objects to which they refer are physically equal. * * If both handles refer to JS objects, this is the same as strict equality. * For primitives, such as numbers or strings, a `false` return value does not * indicate that the values aren't equal in the JavaScript sense. * Use `Value::StrictEquals()` to check primitives for equality. / template <typename T1, typename T2> V8_INLINE static bool EqualHandles(const T1& lhs, const T2& rhs) { if (lhs.IsEmpty()) return rhs.IsEmpty(); if (rhs.IsEmpty()) return false; return lhs.ptr() == rhs.ptr(); } static V8_EXPORT bool IsOnStack(const void ptr); static V8_EXPORT void VerifyOnStack(const void* ptr); static V8_EXPORT void VerifyOnMainThread(); }; V8_EXPORT void VerifyHandleIsNonEmpty(bool is_empty); } // namespace internal } // namespace v8 #endif // INCLUDE_V8_INTERNAL_H_	57.22 KB	2025-03-03 12:36
📄 v8-isolate.h // Copyright 2021 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. #ifndef INCLUDE_V8_ISOLATE_H_ #define INCLUDE_V8_ISOLATE_H_ #include <stddef.h> #include <stdint.h> #include <memory> #include <string> #include <utility> #include "cppgc/common.h" #include "v8-array-buffer.h" // NOLINT(build/include_directory) #include "v8-callbacks.h" // NOLINT(build/include_directory) #include "v8-data.h" // NOLINT(build/include_directory) #include "v8-debug.h" // NOLINT(build/include_directory) #include "v8-embedder-heap.h" // NOLINT(build/include_directory) #include "v8-function-callback.h" // NOLINT(build/include_directory) #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-microtask.h" // NOLINT(build/include_directory) #include "v8-persistent-handle.h" // NOLINT(build/include_directory) #include "v8-primitive.h" // NOLINT(build/include_directory) #include "v8-statistics.h" // NOLINT(build/include_directory) #include "v8-unwinder.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class CppHeap; class HeapProfiler; class MicrotaskQueue; class StartupData; class ScriptOrModule; class SharedArrayBuffer; namespace internal { class MicrotaskQueue; class ThreadLocalTop; } // namespace internal namespace metrics { class Recorder; } // namespace metrics /** * A set of constraints that specifies the limits of the runtime's memory use. * You must set the heap size before initializing the VM - the size cannot be * adjusted after the VM is initialized. * * If you are using threads then you should hold the V8::Locker lock while * setting the stack limit and you must set a non-default stack limit separately * for each thread. * * The arguments for set_max_semi_space_size, set_max_old_space_size, * set_max_executable_size, set_code_range_size specify limits in MB. * * The argument for set_max_semi_space_size_in_kb is in KB. / class V8_EXPORT ResourceConstraints { public: /* * Configures the constraints with reasonable default values based on the * provided heap size limit. The heap size includes both the young and * the old generation. * * \param initial_heap_size_in_bytes The initial heap size or zero. * By default V8 starts with a small heap and dynamically grows it to * match the set of live objects. This may lead to ineffective * garbage collections at startup if the live set is large. * Setting the initial heap size avoids such garbage collections. * Note that this does not affect young generation garbage collections. * * \param maximum_heap_size_in_bytes The hard limit for the heap size. * When the heap size approaches this limit, V8 will perform series of * garbage collections and invoke the NearHeapLimitCallback. If the garbage * collections do not help and the callback does not increase the limit, * then V8 will crash with V8::FatalProcessOutOfMemory. / void ConfigureDefaultsFromHeapSize(size_t initial_heap_size_in_bytes, size_t maximum_heap_size_in_bytes); /* * Configures the constraints with reasonable default values based on the * capabilities of the current device the VM is running on. * * \param physical_memory The total amount of physical memory on the current * device, in bytes. * \param virtual_memory_limit The amount of virtual memory on the current * device, in bytes, or zero, if there is no limit. / void ConfigureDefaults(uint64_t physical_memory, uint64_t virtual_memory_limit); /* * The address beyond which the VM's stack may not grow. / uint32_t stack_limit() const { return stack_limit_; } void set_stack_limit(uint32_t* value) { stack_limit_ = value; } /** * The amount of virtual memory reserved for generated code. This is relevant * for 64-bit architectures that rely on code range for calls in code. * * When V8_COMPRESS_POINTERS_IN_SHARED_CAGE is defined, there is a shared * process-wide code range that is lazily initialized. This value is used to * configure that shared code range when the first Isolate is * created. Subsequent Isolates ignore this value. / size_t code_range_size_in_bytes() const { return code_range_size_; } void set_code_range_size_in_bytes(size_t limit) { code_range_size_ = limit; } /* * The maximum size of the old generation. * When the old generation approaches this limit, V8 will perform series of * garbage collections and invoke the NearHeapLimitCallback. * If the garbage collections do not help and the callback does not * increase the limit, then V8 will crash with V8::FatalProcessOutOfMemory. / size_t max_old_generation_size_in_bytes() const { return max_old_generation_size_; } void set_max_old_generation_size_in_bytes(size_t limit) { max_old_generation_size_ = limit; } /* * The maximum size of the young generation, which consists of two semi-spaces * and a large object space. This affects frequency of Scavenge garbage * collections and should be typically much smaller that the old generation. / size_t max_young_generation_size_in_bytes() const { return max_young_generation_size_; } void set_max_young_generation_size_in_bytes(size_t limit) { max_young_generation_size_ = limit; } size_t initial_old_generation_size_in_bytes() const { return initial_old_generation_size_; } void set_initial_old_generation_size_in_bytes(size_t initial_size) { initial_old_generation_size_ = initial_size; } size_t initial_young_generation_size_in_bytes() const { return initial_young_generation_size_; } void set_initial_young_generation_size_in_bytes(size_t initial_size) { initial_young_generation_size_ = initial_size; } private: static constexpr size_t kMB = 1048576u; size_t code_range_size_ = 0; size_t max_old_generation_size_ = 0; size_t max_young_generation_size_ = 0; size_t initial_old_generation_size_ = 0; size_t initial_young_generation_size_ = 0; uint32_t stack_limit_ = nullptr; }; /** * Option flags passed to the SetRAILMode function. * See documentation https://developers.google.com/web/tools/chrome-devtools/ * profile/evaluate-performance/rail / enum RAILMode : unsigned { // Response performance mode: In this mode very low virtual machine latency // is provided. V8 will try to avoid JavaScript execution interruptions. // Throughput may be throttled. PERFORMANCE_RESPONSE, // Animation performance mode: In this mode low virtual machine latency is // provided. V8 will try to avoid as many JavaScript execution interruptions // as possible. Throughput may be throttled. This is the default mode. PERFORMANCE_ANIMATION, // Idle performance mode: The embedder is idle. V8 can complete deferred work // in this mode. PERFORMANCE_IDLE, // Load performance mode: In this mode high throughput is provided. V8 may // turn off latency optimizations. PERFORMANCE_LOAD }; /* * Memory pressure level for the MemoryPressureNotification. * kNone hints V8 that there is no memory pressure. * kModerate hints V8 to speed up incremental garbage collection at the cost of * of higher latency due to garbage collection pauses. * kCritical hints V8 to free memory as soon as possible. Garbage collection * pauses at this level will be large. / enum class MemoryPressureLevel { kNone, kModerate, kCritical }; /* * Indicator for the stack state. / using StackState = cppgc::EmbedderStackState; /* * Isolate represents an isolated instance of the V8 engine. V8 isolates have * completely separate states. Objects from one isolate must not be used in * other isolates. The embedder can create multiple isolates and use them in * parallel in multiple threads. An isolate can be entered by at most one * thread at any given time. The Locker/Unlocker API must be used to * synchronize. / class V8_EXPORT Isolate { public: /* * Initial configuration parameters for a new Isolate. / struct V8_EXPORT CreateParams { CreateParams(); ~CreateParams(); ALLOW_COPY_AND_MOVE_WITH_DEPRECATED_FIELDS(CreateParams) /* * Allows the host application to provide the address of a function that is * notified each time code is added, moved or removed. / JitCodeEventHandler code_event_handler = nullptr; /* * ResourceConstraints to use for the new Isolate. / ResourceConstraints constraints; /* * Explicitly specify a startup snapshot blob. The embedder owns the blob. * The embedder must ensure that the snapshot is from a trusted source. / const StartupData snapshot_blob = nullptr; /** * Enables the host application to provide a mechanism for recording * statistics counters. / CounterLookupCallback counter_lookup_callback = nullptr; /* * Enables the host application to provide a mechanism for recording * histograms. The CreateHistogram function returns a * histogram which will later be passed to the AddHistogramSample * function. / CreateHistogramCallback create_histogram_callback = nullptr; AddHistogramSampleCallback add_histogram_sample_callback = nullptr; /* * The ArrayBuffer::Allocator to use for allocating and freeing the backing * store of ArrayBuffers. * * If the shared_ptr version is used, the Isolate instance and every * \|BackingStore\| allocated using this allocator hold a std::shared_ptr * to the allocator, in order to facilitate lifetime * management for the allocator instance. / ArrayBuffer::Allocator array_buffer_allocator = nullptr; std::shared_ptr<ArrayBuffer::Allocator> array_buffer_allocator_shared; /** * Specifies an optional nullptr-terminated array of raw addresses in the * embedder that V8 can match against during serialization and use for * deserialization. This array and its content must stay valid for the * entire lifetime of the isolate. / const intptr_t external_references = nullptr; /** * Whether calling Atomics.wait (a function that may block) is allowed in * this isolate. This can also be configured via SetAllowAtomicsWait. / bool allow_atomics_wait = true; /* * Termination is postponed when there is no active SafeForTerminationScope. / bool only_terminate_in_safe_scope = false; /* * The following parameters describe the offsets for addressing type info * for wrapped API objects and are used by the fast C API * (for details see v8-fast-api-calls.h). / int embedder_wrapper_type_index = -1; int embedder_wrapper_object_index = -1; /* * Callbacks to invoke in case of fatal or OOM errors. / FatalErrorCallback fatal_error_callback = nullptr; OOMErrorCallback oom_error_callback = nullptr; /* * A CppHeap used to construct the Isolate. V8 takes ownership of the * CppHeap passed this way. / CppHeap cpp_heap = nullptr; }; /** * Stack-allocated class which sets the isolate for all operations * executed within a local scope. / class V8_EXPORT V8_NODISCARD Scope { public: explicit Scope(Isolate isolate) : v8_isolate_(isolate) { v8_isolate_->Enter(); } ~Scope() { v8_isolate_->Exit(); } // Prevent copying of Scope objects. Scope(const Scope&) = delete; Scope& operator=(const Scope&) = delete; private: Isolate* const v8_isolate_; }; /** * Assert that no Javascript code is invoked. / class V8_EXPORT V8_NODISCARD DisallowJavascriptExecutionScope { public: enum OnFailure { CRASH_ON_FAILURE, THROW_ON_FAILURE, DUMP_ON_FAILURE }; DisallowJavascriptExecutionScope(Isolate isolate, OnFailure on_failure); ~DisallowJavascriptExecutionScope(); // Prevent copying of Scope objects. DisallowJavascriptExecutionScope(const DisallowJavascriptExecutionScope&) = delete; DisallowJavascriptExecutionScope& operator=( const DisallowJavascriptExecutionScope&) = delete; private: v8::Isolate* const v8_isolate_; const OnFailure on_failure_; bool was_execution_allowed_; }; /** * Introduce exception to DisallowJavascriptExecutionScope. / class V8_EXPORT V8_NODISCARD AllowJavascriptExecutionScope { public: explicit AllowJavascriptExecutionScope(Isolate isolate); ~AllowJavascriptExecutionScope(); // Prevent copying of Scope objects. AllowJavascriptExecutionScope(const AllowJavascriptExecutionScope&) = delete; AllowJavascriptExecutionScope& operator=( const AllowJavascriptExecutionScope&) = delete; private: Isolate* const v8_isolate_; bool was_execution_allowed_assert_; bool was_execution_allowed_throws_; bool was_execution_allowed_dump_; }; /** * Do not run microtasks while this scope is active, even if microtasks are * automatically executed otherwise. / class V8_EXPORT V8_NODISCARD SuppressMicrotaskExecutionScope { public: explicit SuppressMicrotaskExecutionScope( Isolate isolate, MicrotaskQueue* microtask_queue = nullptr); ~SuppressMicrotaskExecutionScope(); // Prevent copying of Scope objects. SuppressMicrotaskExecutionScope(const SuppressMicrotaskExecutionScope&) = delete; SuppressMicrotaskExecutionScope& operator=( const SuppressMicrotaskExecutionScope&) = delete; private: internal::Isolate* const i_isolate_; internal::MicrotaskQueue* const microtask_queue_; internal::Address previous_stack_height_; friend class internal::ThreadLocalTop; }; /** * This scope allows terminations inside direct V8 API calls and forbid them * inside any recursive API calls without explicit SafeForTerminationScope. / class V8_EXPORT V8_NODISCARD SafeForTerminationScope { public: V8_DEPRECATE_SOON("All code should be safe for termination") explicit SafeForTerminationScope(v8::Isolate v8_isolate) {} ~SafeForTerminationScope() {} // Prevent copying of Scope objects. SafeForTerminationScope(const SafeForTerminationScope&) = delete; SafeForTerminationScope& operator=(const SafeForTerminationScope&) = delete; }; /** * Types of garbage collections that can be requested via * RequestGarbageCollectionForTesting. / enum GarbageCollectionType { kFullGarbageCollection, kMinorGarbageCollection }; /* * Features reported via the SetUseCounterCallback callback. Do not change * assigned numbers of existing items; add new features to the end of this * list. * Dead features can be marked `V8_DEPRECATE_SOON`, then `V8_DEPRECATED`, and * then finally be renamed to `kOBSOLETE_...` to stop embedders from using * them. / enum UseCounterFeature { kUseAsm = 0, kBreakIterator = 1, kOBSOLETE_LegacyConst = 2, kOBSOLETE_MarkDequeOverflow = 3, kOBSOLETE_StoreBufferOverflow = 4, kOBSOLETE_SlotsBufferOverflow = 5, kOBSOLETE_ObjectObserve = 6, kForcedGC = 7, kSloppyMode = 8, kStrictMode = 9, kOBSOLETE_StrongMode = 10, kRegExpPrototypeStickyGetter = 11, kRegExpPrototypeToString = 12, kRegExpPrototypeUnicodeGetter = 13, kOBSOLETE_IntlV8Parse = 14, kOBSOLETE_IntlPattern = 15, kOBSOLETE_IntlResolved = 16, kOBSOLETE_PromiseChain = 17, kOBSOLETE_PromiseAccept = 18, kOBSOLETE_PromiseDefer = 19, kHtmlCommentInExternalScript = 20, kHtmlComment = 21, kSloppyModeBlockScopedFunctionRedefinition = 22, kForInInitializer = 23, kOBSOLETE_ArrayProtectorDirtied = 24, kArraySpeciesModified = 25, kArrayPrototypeConstructorModified = 26, kOBSOLETE_ArrayInstanceProtoModified = 27, kArrayInstanceConstructorModified = 28, kOBSOLETE_LegacyFunctionDeclaration = 29, kOBSOLETE_RegExpPrototypeSourceGetter = 30, kOBSOLETE_RegExpPrototypeOldFlagGetter = 31, kDecimalWithLeadingZeroInStrictMode = 32, kLegacyDateParser = 33, kDefineGetterOrSetterWouldThrow = 34, kFunctionConstructorReturnedUndefined = 35, kAssigmentExpressionLHSIsCallInSloppy = 36, kAssigmentExpressionLHSIsCallInStrict = 37, kPromiseConstructorReturnedUndefined = 38, kOBSOLETE_ConstructorNonUndefinedPrimitiveReturn = 39, kOBSOLETE_LabeledExpressionStatement = 40, kOBSOLETE_LineOrParagraphSeparatorAsLineTerminator = 41, kIndexAccessor = 42, kErrorCaptureStackTrace = 43, kErrorPrepareStackTrace = 44, kErrorStackTraceLimit = 45, kWebAssemblyInstantiation = 46, kDeoptimizerDisableSpeculation = 47, kOBSOLETE_ArrayPrototypeSortJSArrayModifiedPrototype = 48, kFunctionTokenOffsetTooLongForToString = 49, kWasmSharedMemory = 50, kWasmThreadOpcodes = 51, kOBSOLETE_AtomicsNotify = 52, kOBSOLETE_AtomicsWake = 53, kCollator = 54, kNumberFormat = 55, kDateTimeFormat = 56, kPluralRules = 57, kRelativeTimeFormat = 58, kLocale = 59, kListFormat = 60, kSegmenter = 61, kStringLocaleCompare = 62, kOBSOLETE_StringToLocaleUpperCase = 63, kStringToLocaleLowerCase = 64, kNumberToLocaleString = 65, kDateToLocaleString = 66, kDateToLocaleDateString = 67, kDateToLocaleTimeString = 68, kAttemptOverrideReadOnlyOnPrototypeSloppy = 69, kAttemptOverrideReadOnlyOnPrototypeStrict = 70, kOBSOLETE_OptimizedFunctionWithOneShotBytecode = 71, kRegExpMatchIsTrueishOnNonJSRegExp = 72, kRegExpMatchIsFalseishOnJSRegExp = 73, kOBSOLETE_DateGetTimezoneOffset = 74, kStringNormalize = 75, kCallSiteAPIGetFunctionSloppyCall = 76, kCallSiteAPIGetThisSloppyCall = 77, kOBSOLETE_RegExpMatchAllWithNonGlobalRegExp = 78, kRegExpExecCalledOnSlowRegExp = 79, kRegExpReplaceCalledOnSlowRegExp = 80, kDisplayNames = 81, kSharedArrayBufferConstructed = 82, kArrayPrototypeHasElements = 83, kObjectPrototypeHasElements = 84, kNumberFormatStyleUnit = 85, kDateTimeFormatRange = 86, kDateTimeFormatDateTimeStyle = 87, kBreakIteratorTypeWord = 88, kBreakIteratorTypeLine = 89, kInvalidatedArrayBufferDetachingProtector = 90, kInvalidatedArrayConstructorProtector = 91, kInvalidatedArrayIteratorLookupChainProtector = 92, kInvalidatedArraySpeciesLookupChainProtector = 93, kInvalidatedIsConcatSpreadableLookupChainProtector = 94, kInvalidatedMapIteratorLookupChainProtector = 95, kInvalidatedNoElementsProtector = 96, kInvalidatedPromiseHookProtector = 97, kInvalidatedPromiseResolveLookupChainProtector = 98, kInvalidatedPromiseSpeciesLookupChainProtector = 99, kInvalidatedPromiseThenLookupChainProtector = 100, kInvalidatedRegExpSpeciesLookupChainProtector = 101, kInvalidatedSetIteratorLookupChainProtector = 102, kInvalidatedStringIteratorLookupChainProtector = 103, kInvalidatedStringLengthOverflowLookupChainProtector = 104, kInvalidatedTypedArraySpeciesLookupChainProtector = 105, kWasmSimdOpcodes = 106, kVarRedeclaredCatchBinding = 107, kWasmRefTypes = 108, kOBSOLETE_WasmBulkMemory = 109, kOBSOLETE_WasmMultiValue = 110, kWasmExceptionHandling = 111, kInvalidatedMegaDOMProtector = 112, kFunctionPrototypeArguments = 113, kFunctionPrototypeCaller = 114, kTurboFanOsrCompileStarted = 115, kAsyncStackTaggingCreateTaskCall = 116, kDurationFormat = 117, kInvalidatedNumberStringNotRegexpLikeProtector = 118, kOBSOLETE_RegExpUnicodeSetIncompatibilitiesWithUnicodeMode = 119, kImportAssertionDeprecatedSyntax = 120, kLocaleInfoObsoletedGetters = 121, kLocaleInfoFunctions = 122, kCompileHintsMagicAll = 123, kInvalidatedNoProfilingProtector = 124, kWasmMemory64 = 125, kWasmMultiMemory = 126, kWasmGC = 127, kWasmImportedStrings = 128, kSourceMappingUrlMagicCommentAtSign = 129, kTemporalObject = 130, kWasmModuleCompilation = 131, kInvalidatedNoUndetectableObjectsProtector = 132, kWasmJavaScriptPromiseIntegration = 133, kWasmReturnCall = 134, kWasmExtendedConst = 135, kWasmRelaxedSimd = 136, kWasmTypeReflection = 137, kWasmExnRef = 138, kWasmTypedFuncRef = 139, kInvalidatedStringWrapperToPrimitiveProtector = 140, // If you add new values here, you'll also need to update Chromium's: // web_feature.mojom, use_counter_callback.cc, and enums.xml. V8 changes to // this list need to be landed first, then changes on the Chromium side. kUseCounterFeatureCount // This enum value must be last. }; enum MessageErrorLevel { kMessageLog = (1 << 0), kMessageDebug = (1 << 1), kMessageInfo = (1 << 2), kMessageError = (1 << 3), kMessageWarning = (1 << 4), kMessageAll = kMessageLog \| kMessageDebug \| kMessageInfo \| kMessageError \| kMessageWarning, }; using UseCounterCallback = void ()(Isolate* isolate, UseCounterFeature feature); /** * Allocates a new isolate but does not initialize it. Does not change the * currently entered isolate. * * Only Isolate::GetData() and Isolate::SetData(), which access the * embedder-controlled parts of the isolate, are allowed to be called on the * uninitialized isolate. To initialize the isolate, call * `Isolate::Initialize()` or initialize a `SnapshotCreator`. * * When an isolate is no longer used its resources should be freed * by calling Dispose(). Using the delete operator is not allowed. * * V8::Initialize() must have run prior to this. / static Isolate Allocate(); /** * Initialize an Isolate previously allocated by Isolate::Allocate(). / static void Initialize(Isolate isolate, const CreateParams& params); /** * Creates a new isolate. Does not change the currently entered * isolate. * * When an isolate is no longer used its resources should be freed * by calling Dispose(). Using the delete operator is not allowed. * * V8::Initialize() must have run prior to this. / static Isolate New(const CreateParams& params); /** * Returns the entered isolate for the current thread or NULL in * case there is no current isolate. * * This method must not be invoked before V8::Initialize() was invoked. / static Isolate GetCurrent(); /** * Returns the entered isolate for the current thread or NULL in * case there is no current isolate. * * No checks are performed by this method. / static Isolate TryGetCurrent(); /** * Return true if this isolate is currently active. / bool IsCurrent() const; / * Clears the set of objects held strongly by the heap. This set of * objects are originally built when a WeakRef is created or * successfully dereferenced. * * This is invoked automatically after microtasks are run. See * MicrotasksPolicy for when microtasks are run. * * This needs to be manually invoked only if the embedder is manually running * microtasks via a custom MicrotaskQueue class's PerformCheckpoint. In that * case, it is the embedder's responsibility to make this call at a time which * does not interrupt synchronous ECMAScript code execution. / void ClearKeptObjects(); /* * Custom callback used by embedders to help V8 determine if it should abort * when it throws and no internal handler is predicted to catch the * exception. If --abort-on-uncaught-exception is used on the command line, * then V8 will abort if either: * - no custom callback is set. * - the custom callback set returns true. * Otherwise, the custom callback will not be called and V8 will not abort. / using AbortOnUncaughtExceptionCallback = bool ()(Isolate); void SetAbortOnUncaughtExceptionCallback( AbortOnUncaughtExceptionCallback callback); /* * This specifies the callback called by the upcoming dynamic * import() language feature to load modules. / void SetHostImportModuleDynamicallyCallback( HostImportModuleDynamicallyCallback callback); /* * This specifies the callback called by the upcoming import.meta * language feature to retrieve host-defined meta data for a module. / void SetHostInitializeImportMetaObjectCallback( HostInitializeImportMetaObjectCallback callback); /* * This specifies the callback called by the upcoming ShadowRealm * construction language feature to retrieve host created globals. / void SetHostCreateShadowRealmContextCallback( HostCreateShadowRealmContextCallback callback); /* * This specifies the callback called when the stack property of Error * is accessed. / void SetPrepareStackTraceCallback(PrepareStackTraceCallback callback); #if defined(V8_OS_WIN) /* * This specifies the callback called when an ETW tracing session starts. / void SetFilterETWSessionByURLCallback(FilterETWSessionByURLCallback callback); #endif // V8_OS_WIN /* * Optional notification that the system is running low on memory. * V8 uses these notifications to guide heuristics. * It is allowed to call this function from another thread while * the isolate is executing long running JavaScript code. / void MemoryPressureNotification(MemoryPressureLevel level); /* * Optional request from the embedder to tune v8 towards energy efficiency * rather than speed if `battery_saver_mode_enabled` is true, because the * embedder is in battery saver mode. If false, the correct tuning is left * to v8 to decide. / void SetBatterySaverMode(bool battery_saver_mode_enabled); /* * Drop non-essential caches. Should only be called from testing code. * The method can potentially block for a long time and does not necessarily * trigger GC. / void ClearCachesForTesting(); /* * Methods below this point require holding a lock (using Locker) in * a multi-threaded environment. / /* * Sets this isolate as the entered one for the current thread. * Saves the previously entered one (if any), so that it can be * restored when exiting. Re-entering an isolate is allowed. / void Enter(); /* * Exits this isolate by restoring the previously entered one in the * current thread. The isolate may still stay the same, if it was * entered more than once. * * Requires: this == Isolate::GetCurrent(). / void Exit(); /* * Disposes the isolate. The isolate must not be entered by any * thread to be disposable. / void Dispose(); /* * Dumps activated low-level V8 internal stats. This can be used instead * of performing a full isolate disposal. / void DumpAndResetStats(); /* * Discards all V8 thread-specific data for the Isolate. Should be used * if a thread is terminating and it has used an Isolate that will outlive * the thread -- all thread-specific data for an Isolate is discarded when * an Isolate is disposed so this call is pointless if an Isolate is about * to be Disposed. / void DiscardThreadSpecificMetadata(); /* * Associate embedder-specific data with the isolate. \|slot\| has to be * between 0 and GetNumberOfDataSlots() - 1. / V8_INLINE void SetData(uint32_t slot, void data); /** * Retrieve embedder-specific data from the isolate. * Returns NULL if SetData has never been called for the given \|slot\|. / V8_INLINE void GetData(uint32_t slot); /** * Returns the maximum number of available embedder data slots. Valid slots * are in the range of 0 - GetNumberOfDataSlots() - 1. / V8_INLINE static uint32_t GetNumberOfDataSlots(); /* * Return data that was previously attached to the isolate snapshot via * SnapshotCreator, and removes the reference to it. * Repeated call with the same index returns an empty MaybeLocal. / template <class T> V8_INLINE MaybeLocal<T> GetDataFromSnapshotOnce(size_t index); /* * Returns the value that was set or restored by * SetContinuationPreservedEmbedderData(), if any. / Local<Value> GetContinuationPreservedEmbedderData(); /* * Sets a value that will be stored on continuations and reset while the * continuation runs. / void SetContinuationPreservedEmbedderData(Local<Value> data); /* * Get statistics about the heap memory usage. / void GetHeapStatistics(HeapStatistics heap_statistics); /** * Returns the number of spaces in the heap. / size_t NumberOfHeapSpaces(); /* * Get the memory usage of a space in the heap. * * \param space_statistics The HeapSpaceStatistics object to fill in * statistics. * \param index The index of the space to get statistics from, which ranges * from 0 to NumberOfHeapSpaces() - 1. * \returns true on success. / bool GetHeapSpaceStatistics(HeapSpaceStatistics space_statistics, size_t index); /** * Returns the number of types of objects tracked in the heap at GC. / size_t NumberOfTrackedHeapObjectTypes(); /* * Get statistics about objects in the heap. * * \param object_statistics The HeapObjectStatistics object to fill in * statistics of objects of given type, which were live in the previous GC. * \param type_index The index of the type of object to fill details about, * which ranges from 0 to NumberOfTrackedHeapObjectTypes() - 1. * \returns true on success. / bool GetHeapObjectStatisticsAtLastGC(HeapObjectStatistics object_statistics, size_t type_index); /** * Get statistics about code and its metadata in the heap. * * \param object_statistics The HeapCodeStatistics object to fill in * statistics of code, bytecode and their metadata. * \returns true on success. / bool GetHeapCodeAndMetadataStatistics(HeapCodeStatistics object_statistics); /** * This API is experimental and may change significantly. * * Enqueues a memory measurement request and invokes the delegate with the * results. * * \param delegate the delegate that defines which contexts to measure and * reports the results. * * \param execution promptness executing the memory measurement. * The kEager value is expected to be used only in tests. / bool MeasureMemory( std::unique_ptr<MeasureMemoryDelegate> delegate, MeasureMemoryExecution execution = MeasureMemoryExecution::kDefault); /* * Get a call stack sample from the isolate. * \param state Execution state. * \param frames Caller allocated buffer to store stack frames. * \param frames_limit Maximum number of frames to capture. The buffer must * be large enough to hold the number of frames. * \param sample_info The sample info is filled up by the function * provides number of actual captured stack frames and * the current VM state. * \note GetStackSample should only be called when the JS thread is paused or * interrupted. Otherwise the behavior is undefined. / void GetStackSample(const RegisterState& state, void* frames, size_t frames_limit, SampleInfo* sample_info); /** * Adjusts the amount of registered external memory. Used to give V8 an * indication of the amount of externally allocated memory that is kept alive * by JavaScript objects. V8 uses this to decide when to perform global * garbage collections. Registering externally allocated memory will trigger * global garbage collections more often than it would otherwise in an attempt * to garbage collect the JavaScript objects that keep the externally * allocated memory alive. * * \param change_in_bytes the change in externally allocated memory that is * kept alive by JavaScript objects. * \returns the adjusted value. / int64_t AdjustAmountOfExternalAllocatedMemory(int64_t change_in_bytes); /* * Returns heap profiler for this isolate. Will return NULL until the isolate * is initialized. / HeapProfiler GetHeapProfiler(); /** * Tells the VM whether the embedder is idle or not. / void SetIdle(bool is_idle); /* Returns the ArrayBuffer::Allocator used in this isolate. / ArrayBuffer::Allocator GetArrayBufferAllocator(); /** Returns true if this isolate has a current context. / bool InContext(); /* * Returns the context of the currently running JavaScript, or the context * on the top of the stack if no JavaScript is running. / Local<Context> GetCurrentContext(); /* * Returns either the last context entered through V8's C++ API, or the * context of the currently running microtask while processing microtasks. * If a context is entered while executing a microtask, that context is * returned. / Local<Context> GetEnteredOrMicrotaskContext(); /* * Returns the Context that corresponds to the Incumbent realm in HTML spec. * https://html.spec.whatwg.org/multipage/webappapis.html#incumbent / Local<Context> GetIncumbentContext(); /* * Schedules a v8::Exception::Error with the given message. * See ThrowException for more details. Templatized to provide compile-time * errors in case of too long strings (see v8::String::NewFromUtf8Literal). / template <int N> Local<Value> ThrowError(const char (&message)[N]) { return ThrowError(String::NewFromUtf8Literal(this, message)); } Local<Value> ThrowError(Local<String> message); /* * Schedules an exception to be thrown when returning to JavaScript. When an * exception has been scheduled it is illegal to invoke any JavaScript * operation; the caller must return immediately and only after the exception * has been handled does it become legal to invoke JavaScript operations. / Local<Value> ThrowException(Local<Value> exception); using GCCallback = void ()(Isolate* isolate, GCType type, GCCallbackFlags flags); using GCCallbackWithData = void ()(Isolate isolate, GCType type, GCCallbackFlags flags, void* data); /** * Enables the host application to receive a notification before a * garbage collection. * * \param callback The callback to be invoked. The callback is allowed to * allocate but invocation is not re-entrant: a callback triggering * garbage collection will not be called again. JS execution is prohibited * from these callbacks. A single callback may only be registered once. * \param gc_type_filter A filter in case it should be applied. / void AddGCPrologueCallback(GCCallback callback, GCType gc_type_filter = kGCTypeAll); /* * \copydoc AddGCPrologueCallback(GCCallback, GCType) * * \param data Additional data that should be passed to the callback. / void AddGCPrologueCallback(GCCallbackWithData callback, void data = nullptr, GCType gc_type_filter = kGCTypeAll); /** * This function removes a callback which was added by * `AddGCPrologueCallback`. * * \param callback the callback to remove. / void RemoveGCPrologueCallback(GCCallback callback); /* * \copydoc AddGCPrologueCallback(GCCallback) * * \param data Additional data that was used to install the callback. / void RemoveGCPrologueCallback(GCCallbackWithData, void data = nullptr); /** * Enables the host application to receive a notification after a * garbage collection. * * \copydetails AddGCPrologueCallback(GCCallback, GCType) / void AddGCEpilogueCallback(GCCallback callback, GCType gc_type_filter = kGCTypeAll); /* * \copydoc AddGCEpilogueCallback(GCCallback, GCType) * * \param data Additional data that should be passed to the callback. / void AddGCEpilogueCallback(GCCallbackWithData callback, void data = nullptr, GCType gc_type_filter = kGCTypeAll); /** * This function removes a callback which was added by * `AddGCEpilogueCallback`. * * \param callback the callback to remove. / void RemoveGCEpilogueCallback(GCCallback callback); /* * \copydoc RemoveGCEpilogueCallback(GCCallback) * * \param data Additional data that was used to install the callback. / void RemoveGCEpilogueCallback(GCCallbackWithData callback, void data = nullptr); /** * Sets an embedder roots handle that V8 should consider when performing * non-unified heap garbage collections. The intended use case is for setting * a custom handler after invoking `AttachCppHeap()`. * * V8 does not take ownership of the handler. / void SetEmbedderRootsHandler(EmbedderRootsHandler handler); /** * Attaches a managed C++ heap as an extension to the JavaScript heap. The * embedder maintains ownership of the CppHeap. At most one C++ heap can be * attached to V8. * * Multi-threaded use requires the use of v8::Locker/v8::Unlocker, see * CppHeap. * * If a CppHeap is set via CreateParams, then this call is a noop. / V8_DEPRECATE_SOON( "Set the heap on Isolate creation using CreateParams instead.") void AttachCppHeap(CppHeap); /** * Detaches a managed C++ heap if one was attached using `AttachCppHeap()`. * * If a CppHeap is set via CreateParams, then this call is a noop. / V8_DEPRECATE_SOON( "Set the heap on Isolate creation using CreateParams instead.") void DetachCppHeap(); /* * \returns the C++ heap managed by V8. Only available if such a heap has been * attached using `AttachCppHeap()`. / CppHeap GetCppHeap() const; /** * Use for \|AtomicsWaitCallback\| to indicate the type of event it receives. / enum class AtomicsWaitEvent { /* Indicates that this call is happening before waiting. / kStartWait, /* `Atomics.wait()` finished because of an `Atomics.wake()` call. / kWokenUp, /* `Atomics.wait()` finished because it timed out. / kTimedOut, /* `Atomics.wait()` was interrupted through \|TerminateExecution()\|. / kTerminatedExecution, /* `Atomics.wait()` was stopped through \|AtomicsWaitWakeHandle\|. / kAPIStopped, /* `Atomics.wait()` did not wait, as the initial condition was not met. / kNotEqual }; /* * Passed to \|AtomicsWaitCallback\| as a means of stopping an ongoing * `Atomics.wait` call. / class V8_EXPORT AtomicsWaitWakeHandle { public: /* * Stop this `Atomics.wait()` call and call the \|AtomicsWaitCallback\| * with \|kAPIStopped\|. * * This function may be called from another thread. The caller has to ensure * through proper synchronization that it is not called after * the finishing \|AtomicsWaitCallback\|. * * Note that the ECMAScript specification does not plan for the possibility * of wakeups that are neither coming from a timeout or an `Atomics.wake()` * call, so this may invalidate assumptions made by existing code. * The embedder may accordingly wish to schedule an exception in the * finishing \|AtomicsWaitCallback\|. / void Wake(); }; /* * Embedder callback for `Atomics.wait()` that can be added through * \|SetAtomicsWaitCallback\|. * * This will be called just before starting to wait with the \|event\| value * \|kStartWait\| and after finishing waiting with one of the other * values of \|AtomicsWaitEvent\| inside of an `Atomics.wait()` call. * * \|array_buffer\| will refer to the underlying SharedArrayBuffer, * \|offset_in_bytes\| to the location of the waited-on memory address inside * the SharedArrayBuffer. * * \|value\| and \|timeout_in_ms\| will be the values passed to * the `Atomics.wait()` call. If no timeout was used, \|timeout_in_ms\| * will be `INFINITY`. * * In the \|kStartWait\| callback, \|stop_handle\| will be an object that * is only valid until the corresponding finishing callback and that * can be used to stop the wait process while it is happening. * * This callback may schedule exceptions, unless \|event\| is equal to * \|kTerminatedExecution\|. / using AtomicsWaitCallback = void ()(AtomicsWaitEvent event, Local<SharedArrayBuffer> array_buffer, size_t offset_in_bytes, int64_t value, double timeout_in_ms, AtomicsWaitWakeHandle* stop_handle, void* data); /** * Set a new \|AtomicsWaitCallback\|. This overrides an earlier * \|AtomicsWaitCallback\|, if there was any. If \|callback\| is nullptr, * this unsets the callback. \|data\| will be passed to the callback * as its last parameter. / void SetAtomicsWaitCallback(AtomicsWaitCallback callback, void data); using GetExternallyAllocatedMemoryInBytesCallback = size_t ()(); /* * Set the callback that tells V8 how much memory is currently allocated * externally of the V8 heap. Ideally this memory is somehow connected to V8 * objects and may get freed-up when the corresponding V8 objects get * collected by a V8 garbage collection. / void SetGetExternallyAllocatedMemoryInBytesCallback( GetExternallyAllocatedMemoryInBytesCallback callback); /* * Forcefully terminate the current thread of JavaScript execution * in the given isolate. * * This method can be used by any thread even if that thread has not * acquired the V8 lock with a Locker object. / void TerminateExecution(); /* * Is V8 terminating JavaScript execution. * * Returns true if JavaScript execution is currently terminating * because of a call to TerminateExecution. In that case there are * still JavaScript frames on the stack and the termination * exception is still active. / bool IsExecutionTerminating(); /* * Resume execution capability in the given isolate, whose execution * was previously forcefully terminated using TerminateExecution(). * * When execution is forcefully terminated using TerminateExecution(), * the isolate can not resume execution until all JavaScript frames * have propagated the uncatchable exception which is generated. This * method allows the program embedding the engine to handle the * termination event and resume execution capability, even if * JavaScript frames remain on the stack. * * This method can be used by any thread even if that thread has not * acquired the V8 lock with a Locker object. / void CancelTerminateExecution(); /* * Request V8 to interrupt long running JavaScript code and invoke * the given \|callback\| passing the given \|data\| to it. After \|callback\| * returns control will be returned to the JavaScript code. * There may be a number of interrupt requests in flight. * Can be called from another thread without acquiring a \|Locker\|. * Registered \|callback\| must not reenter interrupted Isolate. / void RequestInterrupt(InterruptCallback callback, void data); /** * Returns true if there is ongoing background work within V8 that will * eventually post a foreground task, like asynchronous WebAssembly * compilation. / bool HasPendingBackgroundTasks(); /* * Request garbage collection in this Isolate. It is only valid to call this * function if --expose_gc was specified. * * This should only be used for testing purposes and not to enforce a garbage * collection schedule. It has strong negative impact on the garbage * collection performance. Use MemoryPressureNotification() instead to * influence the garbage collection schedule. / void RequestGarbageCollectionForTesting(GarbageCollectionType type); /* * Request garbage collection with a specific embedderstack state in this * Isolate. It is only valid to call this function if --expose_gc was * specified. * * This should only be used for testing purposes and not to enforce a garbage * collection schedule. It has strong negative impact on the garbage * collection performance. Use MemoryPressureNotification() instead to * influence the garbage collection schedule. / void RequestGarbageCollectionForTesting(GarbageCollectionType type, StackState stack_state); /* * Set the callback to invoke for logging event. / void SetEventLogger(LogEventCallback that); /* * Adds a callback to notify the host application right before a script * is about to run. If a script re-enters the runtime during executing, the * BeforeCallEnteredCallback is invoked for each re-entrance. * Executing scripts inside the callback will re-trigger the callback. / void AddBeforeCallEnteredCallback(BeforeCallEnteredCallback callback); /* * Removes callback that was installed by AddBeforeCallEnteredCallback. / void RemoveBeforeCallEnteredCallback(BeforeCallEnteredCallback callback); /* * Adds a callback to notify the host application when a script finished * running. If a script re-enters the runtime during executing, the * CallCompletedCallback is only invoked when the outer-most script * execution ends. Executing scripts inside the callback do not trigger * further callbacks. / void AddCallCompletedCallback(CallCompletedCallback callback); /* * Removes callback that was installed by AddCallCompletedCallback. / void RemoveCallCompletedCallback(CallCompletedCallback callback); /* * Set the PromiseHook callback for various promise lifecycle * events. / void SetPromiseHook(PromiseHook hook); /* * Set callback to notify about promise reject with no handler, or * revocation of such a previous notification once the handler is added. / void SetPromiseRejectCallback(PromiseRejectCallback callback); /* * Runs the default MicrotaskQueue until it gets empty and perform other * microtask checkpoint steps, such as calling ClearKeptObjects. Asserts that * the MicrotasksPolicy is not kScoped. Any exceptions thrown by microtask * callbacks are swallowed. / void PerformMicrotaskCheckpoint(); /* * Enqueues the callback to the default MicrotaskQueue / void EnqueueMicrotask(Local<Function> microtask); /* * Enqueues the callback to the default MicrotaskQueue / void EnqueueMicrotask(MicrotaskCallback callback, void data = nullptr); /** * Controls how Microtasks are invoked. See MicrotasksPolicy for details. / void SetMicrotasksPolicy(MicrotasksPolicy policy); /* * Returns the policy controlling how Microtasks are invoked. / MicrotasksPolicy GetMicrotasksPolicy() const; /* * Adds a callback to notify the host application after * microtasks were run on the default MicrotaskQueue. The callback is * triggered by explicit RunMicrotasks call or automatic microtasks execution * (see SetMicrotaskPolicy). * * Callback will trigger even if microtasks were attempted to run, * but the microtasks queue was empty and no single microtask was actually * executed. * * Executing scripts inside the callback will not re-trigger microtasks and * the callback. / void AddMicrotasksCompletedCallback( MicrotasksCompletedCallbackWithData callback, void data = nullptr); /** * Removes callback that was installed by AddMicrotasksCompletedCallback. / void RemoveMicrotasksCompletedCallback( MicrotasksCompletedCallbackWithData callback, void data = nullptr); /** * Sets a callback for counting the number of times a feature of V8 is used. / void SetUseCounterCallback(UseCounterCallback callback); /* * Enables the host application to provide a mechanism for recording * statistics counters. / void SetCounterFunction(CounterLookupCallback); /* * Enables the host application to provide a mechanism for recording * histograms. The CreateHistogram function returns a * histogram which will later be passed to the AddHistogramSample * function. / void SetCreateHistogramFunction(CreateHistogramCallback); void SetAddHistogramSampleFunction(AddHistogramSampleCallback); /* * Enables the host application to provide a mechanism for recording * event based metrics. In order to use this interface * include/v8-metrics.h * needs to be included and the recorder needs to be derived from the * Recorder base class defined there. * This method can only be called once per isolate and must happen during * isolate initialization before background threads are spawned. / void SetMetricsRecorder( const std::shared_ptr<metrics::Recorder>& metrics_recorder); /* * Enables the host application to provide a mechanism for recording a * predefined set of data as crash keys to be used in postmortem debugging in * case of a crash. / void SetAddCrashKeyCallback(AddCrashKeyCallback); /* * Optional notification that the embedder is idle. * V8 uses the notification to perform garbage collection. * This call can be used repeatedly if the embedder remains idle. * Returns true if the embedder should stop calling IdleNotificationDeadline * until real work has been done. This indicates that V8 has done * as much cleanup as it will be able to do. * * The deadline_in_seconds argument specifies the deadline V8 has to finish * garbage collection work. deadline_in_seconds is compared with * MonotonicallyIncreasingTime() and should be based on the same timebase as * that function. There is no guarantee that the actual work will be done * within the time limit. / V8_DEPRECATE_SOON( "Use MemoryPressureNotification() to influence the GC schedule.") bool IdleNotificationDeadline(double deadline_in_seconds); /* * Optional notification that the system is running low on memory. * V8 uses these notifications to attempt to free memory. / void LowMemoryNotification(); /* * Optional notification that a context has been disposed. V8 uses these * notifications to guide the GC heuristic and cancel FinalizationRegistry * cleanup tasks. Returns the number of context disposals - including this one * - since the last time V8 had a chance to clean up. * * The optional parameter \|dependant_context\| specifies whether the disposed * context was depending on state from other contexts or not. / int ContextDisposedNotification(bool dependant_context = true); /* * Optional notification that the isolate switched to the foreground. * V8 uses these notifications to guide heuristics. / void IsolateInForegroundNotification(); /* * Optional notification that the isolate switched to the background. * V8 uses these notifications to guide heuristics. / void IsolateInBackgroundNotification(); /* * Optional notification to tell V8 the current performance requirements * of the embedder based on RAIL. * V8 uses these notifications to guide heuristics. * This is an unfinished experimental feature. Semantics and implementation * may change frequently. / void SetRAILMode(RAILMode rail_mode); /* * Update load start time of the RAIL mode / void UpdateLoadStartTime(); /* * Optional notification to tell V8 the current isolate is used for debugging * and requires higher heap limit. / void IncreaseHeapLimitForDebugging(); /* * Restores the original heap limit after IncreaseHeapLimitForDebugging(). / void RestoreOriginalHeapLimit(); /* * Returns true if the heap limit was increased for debugging and the * original heap limit was not restored yet. / bool IsHeapLimitIncreasedForDebugging(); /* * Allows the host application to provide the address of a function that is * notified each time code is added, moved or removed. * * \param options options for the JIT code event handler. * \param event_handler the JIT code event handler, which will be invoked * each time code is added, moved or removed. * \note \p event_handler won't get notified of existent code. * \note since code removal notifications are not currently issued, the * \p event_handler may get notifications of code that overlaps earlier * code notifications. This happens when code areas are reused, and the * earlier overlapping code areas should therefore be discarded. * \note the events passed to \p event_handler and the strings they point to * are not guaranteed to live past each call. The \p event_handler must * copy strings and other parameters it needs to keep around. * \note the set of events declared in JitCodeEvent::EventType is expected to * grow over time, and the JitCodeEvent structure is expected to accrue * new members. The \p event_handler function must ignore event codes * it does not recognize to maintain future compatibility. * \note Use Isolate::CreateParams to get events for code executed during * Isolate setup. / void SetJitCodeEventHandler(JitCodeEventOptions options, JitCodeEventHandler event_handler); /* * Modifies the stack limit for this Isolate. * * \param stack_limit An address beyond which the Vm's stack may not grow. * * \note If you are using threads then you should hold the V8::Locker lock * while setting the stack limit and you must set a non-default stack * limit separately for each thread. / void SetStackLimit(uintptr_t stack_limit); /* * Returns a memory range that can potentially contain jitted code. Code for * V8's 'builtins' will not be in this range if embedded builtins is enabled. * * On Win64, embedders are advised to install function table callbacks for * these ranges, as default SEH won't be able to unwind through jitted code. * The first page of the code range is reserved for the embedder and is * committed, writable, and executable, to be used to store unwind data, as * documented in * https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64. * * Might be empty on other platforms. * * https://code.google.com/p/v8/issues/detail?id=3598 / void GetCodeRange(void* start, size_t* length_in_bytes); /** * As GetCodeRange, but for embedded builtins (these live in a distinct * memory region from other V8 Code objects). / void GetEmbeddedCodeRange(const void* start, size_t* length_in_bytes); /** * Returns the JSEntryStubs necessary for use with the Unwinder API. / JSEntryStubs GetJSEntryStubs(); static constexpr size_t kMinCodePagesBufferSize = 32; /* * Copies the code heap pages currently in use by V8 into \|code_pages_out\|. * \|code_pages_out\| must have at least kMinCodePagesBufferSize capacity and * must be empty. * * Signal-safe, does not allocate, does not access the V8 heap. * No code on the stack can rely on pages that might be missing. * * Returns the number of pages available to be copied, which might be greater * than \|capacity\|. In this case, only \|capacity\| pages will be copied into * \|code_pages_out\|. The caller should provide a bigger buffer on the next * call in order to get all available code pages, but this is not required. / size_t CopyCodePages(size_t capacity, MemoryRange code_pages_out); /** Set the callback to invoke in case of fatal errors. / void SetFatalErrorHandler(FatalErrorCallback that); /* Set the callback to invoke in case of OOM errors. / void SetOOMErrorHandler(OOMErrorCallback that); /* * Add a callback to invoke in case the heap size is close to the heap limit. * If multiple callbacks are added, only the most recently added callback is * invoked. / void AddNearHeapLimitCallback(NearHeapLimitCallback callback, void data); /** * Remove the given callback and restore the heap limit to the * given limit. If the given limit is zero, then it is ignored. * If the current heap size is greater than the given limit, * then the heap limit is restored to the minimal limit that * is possible for the current heap size. / void RemoveNearHeapLimitCallback(NearHeapLimitCallback callback, size_t heap_limit); /* * If the heap limit was changed by the NearHeapLimitCallback, then the * initial heap limit will be restored once the heap size falls below the * given threshold percentage of the initial heap limit. * The threshold percentage is a number in (0.0, 1.0) range. / void AutomaticallyRestoreInitialHeapLimit(double threshold_percent = 0.5); /* * Set the callback to invoke to check if code generation from * strings should be allowed. / void SetModifyCodeGenerationFromStringsCallback( ModifyCodeGenerationFromStringsCallback2 callback); /* * Set the callback to invoke to check if wasm code generation should * be allowed. / void SetAllowWasmCodeGenerationCallback( AllowWasmCodeGenerationCallback callback); /* * Embedder over{ride\|load} injection points for wasm APIs. The expectation * is that the embedder sets them at most once. / void SetWasmModuleCallback(ExtensionCallback callback); void SetWasmInstanceCallback(ExtensionCallback callback); void SetWasmStreamingCallback(WasmStreamingCallback callback); void SetWasmAsyncResolvePromiseCallback( WasmAsyncResolvePromiseCallback callback); void SetWasmLoadSourceMapCallback(WasmLoadSourceMapCallback callback); void SetWasmImportedStringsEnabledCallback( WasmImportedStringsEnabledCallback callback); void SetSharedArrayBufferConstructorEnabledCallback( SharedArrayBufferConstructorEnabledCallback callback); void SetWasmJSPIEnabledCallback(WasmJSPIEnabledCallback callback); /* * Register callback to control whether compile hints magic comments are * enabled. / void SetJavaScriptCompileHintsMagicEnabledCallback( JavaScriptCompileHintsMagicEnabledCallback callback); /* * This function can be called by the embedder to signal V8 that the dynamic * enabling of features has finished. V8 can now set up dynamically added * features. / void InstallConditionalFeatures(Local<Context> context); /* * Check if V8 is dead and therefore unusable. This is the case after * fatal errors such as out-of-memory situations. / bool IsDead(); /* * Adds a message listener (errors only). * * The same message listener can be added more than once and in that * case it will be called more than once for each message. * * If data is specified, it will be passed to the callback when it is called. * Otherwise, the exception object will be passed to the callback instead. / bool AddMessageListener(MessageCallback that, Local<Value> data = Local<Value>()); /* * Adds a message listener. * * The same message listener can be added more than once and in that * case it will be called more than once for each message. * * If data is specified, it will be passed to the callback when it is called. * Otherwise, the exception object will be passed to the callback instead. * * A listener can listen for particular error levels by providing a mask. / bool AddMessageListenerWithErrorLevel(MessageCallback that, int message_levels, Local<Value> data = Local<Value>()); /* * Remove all message listeners from the specified callback function. / void RemoveMessageListeners(MessageCallback that); /* Callback function for reporting failed access checks./ void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback); /* * Tells V8 to capture current stack trace when uncaught exception occurs * and report it to the message listeners. The option is off by default. / void SetCaptureStackTraceForUncaughtExceptions( bool capture, int frame_limit = 10, StackTrace::StackTraceOptions options = StackTrace::kOverview); /* * Iterates through all external resources referenced from current isolate * heap. GC is not invoked prior to iterating, therefore there is no * guarantee that visited objects are still alive. / V8_DEPRECATE_SOON("Will be removed without replacement. crbug.com/v8/14172") void VisitExternalResources(ExternalResourceVisitor visitor); /** * Check if this isolate is in use. * True if at least one thread Enter'ed this isolate. / bool IsInUse(); /* * Set whether calling Atomics.wait (a function that may block) is allowed in * this isolate. This can also be configured via * CreateParams::allow_atomics_wait. / void SetAllowAtomicsWait(bool allow); /* * Time zone redetection indicator for * DateTimeConfigurationChangeNotification. * * kSkip indicates V8 that the notification should not trigger redetecting * host time zone. kRedetect indicates V8 that host time zone should be * redetected, and used to set the default time zone. * * The host time zone detection may require file system access or similar * operations unlikely to be available inside a sandbox. If v8 is run inside a * sandbox, the host time zone has to be detected outside the sandbox before * calling DateTimeConfigurationChangeNotification function. / enum class TimeZoneDetection { kSkip, kRedetect }; /* * Notification that the embedder has changed the time zone, daylight savings * time or other date / time configuration parameters. V8 keeps a cache of * various values used for date / time computation. This notification will * reset those cached values for the current context so that date / time * configuration changes would be reflected. * * This API should not be called more than needed as it will negatively impact * the performance of date operations. / void DateTimeConfigurationChangeNotification( TimeZoneDetection time_zone_detection = TimeZoneDetection::kSkip); /* * Notification that the embedder has changed the locale. V8 keeps a cache of * various values used for locale computation. This notification will reset * those cached values for the current context so that locale configuration * changes would be reflected. * * This API should not be called more than needed as it will negatively impact * the performance of locale operations. / void LocaleConfigurationChangeNotification(); /* * Returns the default locale in a string if Intl support is enabled. * Otherwise returns an empty string. / std::string GetDefaultLocale(); Isolate() = delete; ~Isolate() = delete; Isolate(const Isolate&) = delete; Isolate& operator=(const Isolate&) = delete; // Deleting operator new and delete here is allowed as ctor and dtor is also // deleted. void operator new(size_t size) = delete; void* operator new[](size_t size) = delete; void operator delete(void, size_t) = delete; void operator delete[](void, size_t) = delete; private: template <class K, class V, class Traits> friend class PersistentValueMapBase; internal::Address* GetDataFromSnapshotOnce(size_t index); void ReportExternalAllocationLimitReached(); }; void Isolate::SetData(uint32_t slot, void* data) { using I = internal::Internals; I::SetEmbedderData(this, slot, data); } void* Isolate::GetData(uint32_t slot) { using I = internal::Internals; return I::GetEmbedderData(this, slot); } uint32_t Isolate::GetNumberOfDataSlots() { using I = internal::Internals; return I::kNumIsolateDataSlots; } template <class T> MaybeLocal<T> Isolate::GetDataFromSnapshotOnce(size_t index) { if (auto slot = GetDataFromSnapshotOnce(index); slot) { internal::PerformCastCheck( internal::ValueHelper::SlotAsValue<T, false>(slot)); return Local<T>::FromSlot(slot); } return {}; } } // namespace v8 #endif // INCLUDE_V8_ISOLATE_H_	63.38 KB	2025-03-03 12:36
📄 v8-json.h // Copyright 2021 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. #ifndef INCLUDE_V8_JSON_H_ #define INCLUDE_V8_JSON_H_ #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; class Value; class String; /** * A JSON Parser and Stringifier. / class V8_EXPORT JSON { public: /* * Tries to parse the string \|json_string\| and returns it as value if * successful. * * \param the context in which to parse and create the value. * \param json_string The string to parse. * \return The corresponding value if successfully parsed. / static V8_WARN_UNUSED_RESULT MaybeLocal<Value> Parse( Local<Context> context, Local<String> json_string); /* * Tries to stringify the JSON-serializable object \|json_object\| and returns * it as string if successful. * * \param json_object The JSON-serializable object to stringify. * \return The corresponding string if successfully stringified. */ static V8_WARN_UNUSED_RESULT MaybeLocal<String> Stringify( Local<Context> context, Local<Value> json_object, Local<String> gap = Local<String>()); }; } // namespace v8 #endif // INCLUDE_V8_JSON_H_	1.32 KB	2025-03-03 12:36
📄 v8-local-handle.h // Copyright 2021 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. #ifndef INCLUDE_V8_LOCAL_HANDLE_H_ #define INCLUDE_V8_LOCAL_HANDLE_H_ #include <stddef.h> #include <type_traits> #include <vector> #include "v8-handle-base.h" // NOLINT(build/include_directory) #include "v8-internal.h" // NOLINT(build/include_directory) namespace v8 { template <class T> class LocalBase; template <class T> class Local; template <class T> class LocalVector; template <class F> class MaybeLocal; template <class T> class Eternal; template <class T> class Global; template <class T> class NonCopyablePersistentTraits; template <class T> class PersistentBase; template <class T, class M = NonCopyablePersistentTraits<T>> class Persistent; class TracedReferenceBase; template <class T> class BasicTracedReference; template <class F> class TracedReference; class Boolean; class Context; class EscapableHandleScope; template <class F> class FunctionCallbackInfo; class Isolate; class Object; template <class F1, class F2, class F3> class PersistentValueMapBase; template <class F1, class F2> class PersistentValueVector; class Primitive; class Private; template <class F> class PropertyCallbackInfo; template <class F> class ReturnValue; class String; template <class F> class Traced; class TypecheckWitness; class Utils; namespace debug { class ConsoleCallArguments; } namespace internal { template <typename T> class CustomArguments; template <typename T> class LocalUnchecked; class SamplingHeapProfiler; } // namespace internal namespace api_internal { // Called when ToLocalChecked is called on an empty Local. V8_EXPORT void ToLocalEmpty(); } // namespace api_internal /** * A stack-allocated class that governs a number of local handles. * After a handle scope has been created, all local handles will be * allocated within that handle scope until either the handle scope is * deleted or another handle scope is created. If there is already a * handle scope and a new one is created, all allocations will take * place in the new handle scope until it is deleted. After that, * new handles will again be allocated in the original handle scope. * * After the handle scope of a local handle has been deleted the * garbage collector will no longer track the object stored in the * handle and may deallocate it. The behavior of accessing a handle * for which the handle scope has been deleted is undefined. / class V8_EXPORT V8_NODISCARD HandleScope { public: explicit HandleScope(Isolate isolate); ~HandleScope(); /** * Counts the number of allocated handles. / static int NumberOfHandles(Isolate isolate); V8_INLINE Isolate* GetIsolate() const { return reinterpret_cast<Isolate>(i_isolate_); } HandleScope(const HandleScope&) = delete; void operator=(const HandleScope&) = delete; static internal::Address CreateHandleForCurrentIsolate( internal::Address value); protected: V8_INLINE HandleScope() = default; void Initialize(Isolate* isolate); static internal::Address* CreateHandle(internal::Isolate* i_isolate, internal::Address value); private: // Declaring operator new and delete as deleted is not spec compliant. // Therefore declare them private instead to disable dynamic alloc void* operator new(size_t size); void* operator new[](size_t size); void operator delete(void, size_t); void operator delete[](void, size_t); internal::Isolate* i_isolate_; internal::Address* prev_next_; internal::Address* prev_limit_; #ifdef V8_ENABLE_CHECKS int scope_level_ = 0; #endif // LocalBase<T>::New uses CreateHandle with an Isolate* parameter. template <typename T> friend class LocalBase; // Object::GetInternalField and Context::GetEmbedderData use CreateHandle with // a HeapObject in their shortcuts. friend class Object; friend class Context; }; /** * A base class for local handles. * Its implementation depends on whether direct local support is enabled. * When it is, a local handle contains a direct pointer to the referenced * object, otherwise it contains an indirect pointer. / #ifdef V8_ENABLE_DIRECT_LOCAL template <typename T> class LocalBase : public api_internal::DirectHandleBase { protected: template <class F> friend class Local; V8_INLINE LocalBase() = default; V8_INLINE explicit LocalBase(internal::Address ptr) : DirectHandleBase(ptr) {} template <typename S> V8_INLINE LocalBase(const LocalBase<S>& other) : DirectHandleBase(other) {} V8_INLINE static LocalBase<T> New(Isolate isolate, internal::Address value) { return LocalBase<T>(value); } V8_INLINE static LocalBase<T> New(Isolate* isolate, T* that) { return LocalBase<T>::New(isolate, internal::ValueHelper::ValueAsAddress(that)); } V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) { return LocalBase<T>(slot); } }; #else // !V8_ENABLE_DIRECT_LOCAL template <typename T> class LocalBase : public api_internal::IndirectHandleBase { protected: template <class F> friend class Local; V8_INLINE LocalBase() = default; V8_INLINE explicit LocalBase(internal::Address location) : IndirectHandleBase(location) {} template <typename S> V8_INLINE LocalBase(const LocalBase<S>& other) : IndirectHandleBase(other) {} V8_INLINE static LocalBase<T> New(Isolate* isolate, internal::Address value) { return LocalBase(HandleScope::CreateHandle( reinterpret_cast<internal::Isolate>(isolate), value)); } V8_INLINE static LocalBase<T> New(Isolate isolate, T* that) { if (internal::ValueHelper::IsEmpty(that)) return LocalBase<T>(); return LocalBase<T>::New(isolate, internal::ValueHelper::ValueAsAddress(that)); } V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) { return LocalBase<T>(slot); } }; #endif // V8_ENABLE_DIRECT_LOCAL /** * An object reference managed by the v8 garbage collector. * * All objects returned from v8 have to be tracked by the garbage collector so * that it knows that the objects are still alive. Also, because the garbage * collector may move objects, it is unsafe to point directly to an object. * Instead, all objects are stored in handles which are known by the garbage * collector and updated whenever an object moves. Handles should always be * passed by value (except in cases like out-parameters) and they should never * be allocated on the heap. * * There are two types of handles: local and persistent handles. * * Local handles are light-weight and transient and typically used in local * operations. They are managed by HandleScopes. That means that a HandleScope * must exist on the stack when they are created and that they are only valid * inside of the HandleScope active during their creation. For passing a local * handle to an outer HandleScope, an EscapableHandleScope and its Escape() * method must be used. * * Persistent handles can be used when storing objects across several * independent operations and have to be explicitly deallocated when they're no * longer used. * * It is safe to extract the object stored in the handle by dereferencing the * handle (for instance, to extract the Object* from a Local<Object>); the value * will still be governed by a handle behind the scenes and the same rules apply * to these values as to their handles. / template <class T> class V8_TRIVIAL_ABI Local : public LocalBase<T>, #ifdef V8_ENABLE_LOCAL_OFF_STACK_CHECK public api_internal::StackAllocated<true> #else public api_internal::StackAllocated<false> #endif { public: V8_INLINE Local() = default; template <class S> V8_INLINE Local(Local<S> that) : LocalBase<T>(that) { /* * This check fails when trying to convert between incompatible * handles. For example, converting from a Local<String> to a * Local<Number>. / static_assert(std::is_base_of<T, S>::value, "type check"); } V8_INLINE T operator->() const { return this->template value<T>(); } V8_INLINE T* operator() const { return this->operator->(); } /* * Checks whether two handles are equal or different. * They are equal iff they are both empty or they are both non-empty and the * objects to which they refer are physically equal. * * If both handles refer to JS objects, this is the same as strict * non-equality. For primitives, such as numbers or strings, a `true` return * value does not indicate that the values aren't equal in the JavaScript * sense. Use `Value::StrictEquals()` to check primitives for equality. / template <class S> V8_INLINE bool operator==(const Local<S>& that) const { return internal::HandleHelper::EqualHandles(this, that); } template <class S> V8_INLINE bool operator==(const PersistentBase<S>& that) const { return internal::HandleHelper::EqualHandles(this, that); } template <class S> V8_INLINE bool operator!=(const Local<S>& that) const { return !operator==(that); } template <class S> V8_INLINE bool operator!=(const Persistent<S>& that) const { return !operator==(that); } /* * Cast a handle to a subclass, e.g. Local<Value> to Local<Object>. * This is only valid if the handle actually refers to a value of the * target type. / template <class S> V8_INLINE static Local<T> Cast(Local<S> that) { #ifdef V8_ENABLE_CHECKS // If we're going to perform the type check then we have to check // that the handle isn't empty before doing the checked cast. if (that.IsEmpty()) return Local<T>(); T::Cast(that.template value<S>()); #endif return Local<T>(LocalBase<T>(that)); } /* * Calling this is equivalent to Local<S>::Cast(). * In particular, this is only valid if the handle actually refers to a value * of the target type. / template <class S> V8_INLINE Local<S> As() const { return Local<S>::Cast(this); } /** * Create a local handle for the content of another handle. * The referee is kept alive by the local handle even when * the original handle is destroyed/disposed. / V8_INLINE static Local<T> New(Isolate isolate, Local<T> that) { return New(isolate, that.template value<T, true>()); } V8_INLINE static Local<T> New(Isolate* isolate, const PersistentBase<T>& that) { return New(isolate, that.template value<T, true>()); } V8_INLINE static Local<T> New(Isolate* isolate, const BasicTracedReference<T>& that) { return New(isolate, that.template value<T, true>()); } private: friend class TracedReferenceBase; friend class Utils; template <class F> friend class Eternal; template <class F> friend class Global; template <class F> friend class Local; template <class F> friend class MaybeLocal; template <class F, class M> friend class Persistent; template <class F> friend class FunctionCallbackInfo; template <class F> friend class PropertyCallbackInfo; friend class String; friend class Object; friend class Context; friend class Isolate; friend class Private; template <class F> friend class internal::CustomArguments; friend Local<Primitive> Undefined(Isolate* isolate); friend Local<Primitive> Null(Isolate* isolate); friend Local<Boolean> True(Isolate* isolate); friend Local<Boolean> False(Isolate* isolate); friend class HandleScope; friend class EscapableHandleScope; friend class InternalEscapableScope; template <class F1, class F2, class F3> friend class PersistentValueMapBase; template <class F1, class F2> friend class PersistentValueVector; template <class F> friend class ReturnValue; template <class F> friend class Traced; friend class internal::SamplingHeapProfiler; friend class internal::HandleHelper; friend class debug::ConsoleCallArguments; friend class internal::LocalUnchecked<T>; explicit Local(no_checking_tag do_not_check) : LocalBase<T>(), StackAllocated(do_not_check) {} explicit Local(const Local<T>& other, no_checking_tag do_not_check) : LocalBase<T>(other), StackAllocated(do_not_check) {} V8_INLINE explicit Local(const LocalBase<T>& other) : LocalBase<T>(other) {} V8_INLINE static Local<T> FromSlot(internal::Address* slot) { return Local<T>(LocalBase<T>::FromSlot(slot)); } #ifdef V8_ENABLE_DIRECT_LOCAL friend class TypecheckWitness; V8_INLINE static Local<T> FromAddress(internal::Address ptr) { return Local<T>(LocalBase<T>(ptr)); } #endif // V8_ENABLE_DIRECT_LOCAL V8_INLINE static Local<T> New(Isolate* isolate, internal::Address value) { return Local<T>(LocalBase<T>::New(isolate, value)); } V8_INLINE static Local<T> New(Isolate* isolate, T* that) { return Local<T>(LocalBase<T>::New(isolate, that)); } // Unsafe cast, should be avoided. template <class S> V8_INLINE Local<S> UnsafeAs() const { return Local<S>(LocalBase<S>(this)); } }; namespace internal { // A local variant that is suitable for off-stack allocation. // Used internally by LocalVector<T>. Not to be used directly! template <typename T> class V8_TRIVIAL_ABI LocalUnchecked : public Local<T> { public: LocalUnchecked() : Local<T>(Local<T>::do_not_check) {} #if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI // In this case, the check is also enforced in the copy constructor and we // need to suppress it. LocalUnchecked(const LocalUnchecked& other) : Local<T>(other, Local<T>::do_not_check) {} LocalUnchecked& operator=(const LocalUnchecked&) = default; #endif // Implicit conversion from Local. LocalUnchecked(const Local<T>& other) // NOLINT(runtime/explicit) : Local<T>(other, Local<T>::do_not_check) {} }; #ifdef V8_ENABLE_DIRECT_LOCAL // Off-stack allocated direct locals must be registered as strong roots. // For off-stack indirect locals, this is not necessary. template <typename T> class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase { public: using value_type = LocalUnchecked<T>; static_assert(std::is_standard_layout_v<value_type>); static_assert(sizeof(value_type) == sizeof(Address)); explicit StrongRootAllocator(Heap heap) : StrongRootAllocatorBase(heap) {} explicit StrongRootAllocator(v8::Isolate* isolate) : StrongRootAllocatorBase(isolate) {} template <typename U> StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept : StrongRootAllocatorBase(other) {} value_type* allocate(size_t n) { return reinterpret_cast<value_type>(allocate_impl(n)); } void deallocate(value_type p, size_t n) noexcept { return deallocate_impl(reinterpret_cast<Address>(p), n); } }; #endif // V8_ENABLE_DIRECT_LOCAL } // namespace internal template <typename T> class LocalVector { private: using element_type = internal::LocalUnchecked<T>; #ifdef V8_ENABLE_DIRECT_LOCAL using allocator_type = internal::StrongRootAllocator<element_type>; static allocator_type make_allocator(Isolate isolate) noexcept { return allocator_type(isolate); } #else using allocator_type = std::allocator<element_type>; static allocator_type make_allocator(Isolate* isolate) noexcept { return allocator_type(); } #endif // V8_ENABLE_DIRECT_LOCAL using vector_type = std::vector<element_type, allocator_type>; public: using value_type = Local<T>; using reference = value_type&; using const_reference = const value_type&; using size_type = size_t; using difference_type = ptrdiff_t; using iterator = internal::WrappedIterator<typename vector_type::iterator, Local<T>>; using const_iterator = internal::WrappedIterator<typename vector_type::const_iterator, const Local<T>>; explicit LocalVector(Isolate* isolate) : backing_(make_allocator(isolate)) {} LocalVector(Isolate* isolate, size_t n) : backing_(n, make_allocator(isolate)) {} explicit LocalVector(Isolate* isolate, std::initializer_list<Local<T>> init) : backing_(make_allocator(isolate)) { if (init.size() == 0) return; backing_.reserve(init.size()); backing_.insert(backing_.end(), init.begin(), init.end()); } iterator begin() noexcept { return iterator(backing_.begin()); } const_iterator begin() const noexcept { return const_iterator(backing_.begin()); } iterator end() noexcept { return iterator(backing_.end()); } const_iterator end() const noexcept { return const_iterator(backing_.end()); } size_t size() const noexcept { return backing_.size(); } bool empty() const noexcept { return backing_.empty(); } void reserve(size_t n) { backing_.reserve(n); } void shrink_to_fit() { backing_.shrink_to_fit(); } Local<T>& operator[](size_t n) { return backing_[n]; } const Local<T>& operator[](size_t n) const { return backing_[n]; } Local<T>& at(size_t n) { return backing_.at(n); } const Local<T>& at(size_t n) const { return backing_.at(n); } Local<T>& front() { return backing_.front(); } const Local<T>& front() const { return backing_.front(); } Local<T>& back() { return backing_.back(); } const Local<T>& back() const { return backing_.back(); } Local<T>* data() noexcept { return backing_.data(); } const Local<T>* data() const noexcept { return backing_.data(); } iterator insert(const_iterator pos, const Local<T>& value) { return iterator(backing_.insert(pos.base(), value)); } template <typename InputIt> iterator insert(const_iterator pos, InputIt first, InputIt last) { return iterator(backing_.insert(pos.base(), first, last)); } iterator insert(const_iterator pos, std::initializer_list<Local<T>> init) { return iterator(backing_.insert(pos.base(), init.begin(), init.end())); } LocalVector<T>& operator=(std::initializer_list<Local<T>> init) { backing_.clear(); backing_.insert(backing_.end(), init.begin(), init.end()); return this; } void push_back(const Local<T>& x) { backing_.push_back(x); } void pop_back() { backing_.pop_back(); } void emplace_back(const Local<T>& x) { backing_.emplace_back(x); } void clear() noexcept { backing_.clear(); } void resize(size_t n) { backing_.resize(n); } void swap(LocalVector<T>& other) { backing_.swap(other.backing_); } friend bool operator==(const LocalVector<T>& x, const LocalVector<T>& y) { return x.backing_ == y.backing_; } friend bool operator!=(const LocalVector<T>& x, const LocalVector<T>& y) { return x.backing_ != y.backing_; } friend bool operator<(const LocalVector<T>& x, const LocalVector<T>& y) { return x.backing_ < y.backing_; } friend bool operator>(const LocalVector<T>& x, const LocalVector<T>& y) { return x.backing_ > y.backing_; } friend bool operator<=(const LocalVector<T>& x, const LocalVector<T>& y) { return x.backing_ <= y.backing_; } friend bool operator>=(const LocalVector<T>& x, const LocalVector<T>& y) { return x.backing_ >= y.backing_; } private: vector_type backing_; }; #if !defined(V8_IMMINENT_DEPRECATION_WARNINGS) // Handle is an alias for Local for historical reasons. template <class T> using Handle = Local<T>; #endif /* * A MaybeLocal<> is a wrapper around Local<> that enforces a check whether * the Local<> is empty before it can be used. * * If an API method returns a MaybeLocal<>, the API method can potentially fail * either because an exception is thrown, or because an exception is pending, * e.g. because a previous API call threw an exception that hasn't been caught * yet, or because a TerminateExecution exception was thrown. In that case, an * empty MaybeLocal is returned. / template <class T> class MaybeLocal { public: V8_INLINE MaybeLocal() : local_() {} template <class S> V8_INLINE MaybeLocal(Local<S> that) : local_(that) {} V8_INLINE bool IsEmpty() const { return local_.IsEmpty(); } /* * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty, * \|false\| is returned and \|out\| is assigned with nullptr. / template <class S> V8_WARN_UNUSED_RESULT V8_INLINE bool ToLocal(Local<S> out) const { out = local_; return !IsEmpty(); } /* * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty, * V8 will crash the process. / V8_INLINE Local<T> ToLocalChecked() { if (V8_UNLIKELY(IsEmpty())) api_internal::ToLocalEmpty(); return local_; } /* * Converts this MaybeLocal<> to a Local<>, using a default value if this * MaybeLocal<> is empty. / template <class S> V8_INLINE Local<S> FromMaybe(Local<S> default_value) const { return IsEmpty() ? default_value : Local<S>(local_); } /* * Cast a handle to a subclass, e.g. MaybeLocal<Value> to MaybeLocal<Object>. * This is only valid if the handle actually refers to a value of the target * type. / template <class S> V8_INLINE static MaybeLocal<T> Cast(MaybeLocal<S> that) { #ifdef V8_ENABLE_CHECKS // If we're going to perform the type check then we have to check // that the handle isn't empty before doing the checked cast. if (that.IsEmpty()) return MaybeLocal<T>(); T::Cast(that.local_.template value<S>()); #endif return MaybeLocal<T>(that.local_); } /* * Calling this is equivalent to MaybeLocal<S>::Cast(). * In particular, this is only valid if the handle actually refers to a value * of the target type. / template <class S> V8_INLINE MaybeLocal<S> As() const { return MaybeLocal<S>::Cast(this); } private: Local<T> local_; template <typename S> friend class MaybeLocal; }; /** * A HandleScope which first allocates a handle in the current scope * which will be later filled with the escape value. / class V8_EXPORT V8_NODISCARD EscapableHandleScopeBase : public HandleScope { public: explicit EscapableHandleScopeBase(Isolate isolate); V8_INLINE ~EscapableHandleScopeBase() = default; EscapableHandleScopeBase(const EscapableHandleScopeBase&) = delete; void operator=(const EscapableHandleScopeBase&) = delete; void* operator new(size_t size) = delete; void* operator new[](size_t size) = delete; void operator delete(void, size_t) = delete; void operator delete[](void, size_t) = delete; protected: /** * Pushes the value into the previous scope and returns a handle to it. * Cannot be called twice. / internal::Address EscapeSlot(internal::Address* escape_value); private: internal::Address* escape_slot_; }; class V8_EXPORT V8_NODISCARD EscapableHandleScope : public EscapableHandleScopeBase { public: explicit EscapableHandleScope(Isolate* isolate) : EscapableHandleScopeBase(isolate) {} V8_INLINE ~EscapableHandleScope() = default; template <class T> V8_INLINE Local<T> Escape(Local<T> value) { #ifdef V8_ENABLE_DIRECT_LOCAL return value; #else if (value.IsEmpty()) return value; return Local<T>::FromSlot(EscapeSlot(value.slot())); #endif } template <class T> V8_INLINE MaybeLocal<T> EscapeMaybe(MaybeLocal<T> value) { return Escape(value.FromMaybe(Local<T>())); } }; /** * A SealHandleScope acts like a handle scope in which no handle allocations * are allowed. It can be useful for debugging handle leaks. * Handles can be allocated within inner normal HandleScopes. / class V8_EXPORT V8_NODISCARD SealHandleScope { public: explicit SealHandleScope(Isolate isolate); ~SealHandleScope(); SealHandleScope(const SealHandleScope&) = delete; void operator=(const SealHandleScope&) = delete; void* operator new(size_t size) = delete; void* operator new[](size_t size) = delete; void operator delete(void, size_t) = delete; void operator delete[](void, size_t) = delete; private: internal::Isolate* const i_isolate_; internal::Address* prev_limit_; int prev_sealed_level_; }; } // namespace v8 #endif // INCLUDE_V8_LOCAL_HANDLE_H_	23.6 KB	2025-03-03 12:36
📄 v8-locker.h // Copyright 2021 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. #ifndef INCLUDE_V8_LOCKER_H_ #define INCLUDE_V8_LOCKER_H_ #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { namespace internal { class Isolate; } // namespace internal class Isolate; /** * Multiple threads in V8 are allowed, but only one thread at a time is allowed * to use any given V8 isolate, see the comments in the Isolate class. The * definition of 'using a V8 isolate' includes accessing handles or holding onto * object pointers obtained from V8 handles while in the particular V8 isolate. * It is up to the user of V8 to ensure, perhaps with locking, that this * constraint is not violated. In addition to any other synchronization * mechanism that may be used, the v8::Locker and v8::Unlocker classes must be * used to signal thread switches to V8. * * v8::Locker is a scoped lock object. While it's active, i.e. between its * construction and destruction, the current thread is allowed to use the locked * isolate. V8 guarantees that an isolate can be locked by at most one thread at * any time. In other words, the scope of a v8::Locker is a critical section. * * Sample usage: * \code * ... * { * v8::Locker locker(isolate); * v8::Isolate::Scope isolate_scope(isolate); * ... * // Code using V8 and isolate goes here. * ... * } // Destructor called here * \endcode * * If you wish to stop using V8 in a thread A you can do this either by * destroying the v8::Locker object as above or by constructing a v8::Unlocker * object: * * \code * { * isolate->Exit(); * v8::Unlocker unlocker(isolate); * ... * // Code not using V8 goes here while V8 can run in another thread. * ... * } // Destructor called here. * isolate->Enter(); * \endcode * * The Unlocker object is intended for use in a long-running callback from V8, * where you want to release the V8 lock for other threads to use. * * The v8::Locker is a recursive lock, i.e. you can lock more than once in a * given thread. This can be useful if you have code that can be called either * from code that holds the lock or from code that does not. The Unlocker is * not recursive so you can not have several Unlockers on the stack at once, and * you cannot use an Unlocker in a thread that is not inside a Locker's scope. * * An unlocker will unlock several lockers if it has to and reinstate the * correct depth of locking on its destruction, e.g.: * * \code * // V8 not locked. * { * v8::Locker locker(isolate); * Isolate::Scope isolate_scope(isolate); * // V8 locked. * { * v8::Locker another_locker(isolate); * // V8 still locked (2 levels). * { * isolate->Exit(); * v8::Unlocker unlocker(isolate); * // V8 not locked. * } * isolate->Enter(); * // V8 locked again (2 levels). * } * // V8 still locked (1 level). * } * // V8 Now no longer locked. * \endcode / class V8_EXPORT Unlocker { public: /* * Initialize Unlocker for a given Isolate. / V8_INLINE explicit Unlocker(Isolate isolate) { Initialize(isolate); } ~Unlocker(); private: void Initialize(Isolate* isolate); internal::Isolate* isolate_; }; class V8_EXPORT Locker { public: /** * Initialize Locker for a given Isolate. / V8_INLINE explicit Locker(Isolate isolate) { Initialize(isolate); } ~Locker(); /** * Returns whether or not the locker for a given isolate, is locked by the * current thread. / static bool IsLocked(Isolate isolate); // Disallow copying and assigning. Locker(const Locker&) = delete; void operator=(const Locker&) = delete; private: void Initialize(Isolate* isolate); bool has_lock_; bool top_level_; internal::Isolate* isolate_; }; } // namespace v8 #endif // INCLUDE_V8_LOCKER_H_	3.86 KB	2025-03-03 12:36
📄 v8-maybe.h // Copyright 2021 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. #ifndef INCLUDE_V8_MAYBE_H_ #define INCLUDE_V8_MAYBE_H_ #include <type_traits> #include <utility> #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { namespace api_internal { // Called when ToChecked is called on an empty Maybe. V8_EXPORT void FromJustIsNothing(); } // namespace api_internal /** * A simple Maybe type, representing an object which may or may not have a * value, see https://hackage.haskell.org/package/base/docs/Data-Maybe.html. * * If an API method returns a Maybe<>, the API method can potentially fail * either because an exception is thrown, or because an exception is pending, * e.g. because a previous API call threw an exception that hasn't been caught * yet, or because a TerminateExecution exception was thrown. In that case, a * "Nothing" value is returned. / template <class T> class Maybe { public: V8_INLINE bool IsNothing() const { return !has_value_; } V8_INLINE bool IsJust() const { return has_value_; } /* * An alias for \|FromJust\|. Will crash if the Maybe<> is nothing. / V8_INLINE T ToChecked() const { return FromJust(); } /* * Short-hand for ToChecked(), which doesn't return a value. To be used, where * the actual value of the Maybe is not needed like Object::Set. / V8_INLINE void Check() const { if (V8_UNLIKELY(!IsJust())) api_internal::FromJustIsNothing(); } /* * Converts this Maybe<> to a value of type T. If this Maybe<> is * nothing (empty), \|false\| is returned and \|out\| is left untouched. / V8_WARN_UNUSED_RESULT V8_INLINE bool To(T out) const { if (V8_LIKELY(IsJust())) out = value_; return IsJust(); } /* * Converts this Maybe<> to a value of type T. If this Maybe<> is * nothing (empty), V8 will crash the process. / V8_INLINE T FromJust() const& { if (V8_UNLIKELY(!IsJust())) api_internal::FromJustIsNothing(); return value_; } /* * Converts this Maybe<> to a value of type T. If this Maybe<> is * nothing (empty), V8 will crash the process. / V8_INLINE T FromJust() && { if (V8_UNLIKELY(!IsJust())) api_internal::FromJustIsNothing(); return std::move(value_); } /* * Converts this Maybe<> to a value of type T, using a default value if this * Maybe<> is nothing (empty). / V8_INLINE T FromMaybe(const T& default_value) const { return has_value_ ? value_ : default_value; } V8_INLINE bool operator==(const Maybe& other) const { return (IsJust() == other.IsJust()) && (!IsJust() \|\| FromJust() == other.FromJust()); } V8_INLINE bool operator!=(const Maybe& other) const { return !operator==(other); } private: Maybe() : has_value_(false) {} explicit Maybe(const T& t) : has_value_(true), value_(t) {} explicit Maybe(T&& t) : has_value_(true), value_(std::move(t)) {} bool has_value_; T value_; template <class U> friend Maybe<U> Nothing(); template <class U> friend Maybe<U> Just(const U& u); template <class U, std::enable_if_t<!std::is_lvalue_reference_v<U>>> friend Maybe<U> Just(U&& u); }; template <class T> inline Maybe<T> Nothing() { return Maybe<T>(); } template <class T> inline Maybe<T> Just(const T& t) { return Maybe<T>(t); } // Don't use forwarding references here but instead use two overloads. // Forwarding references only work when type deduction takes place, which is not // the case for callsites such as Just<Type>(t). template <class T, std::enable_if_t<!std::is_lvalue_reference_v<T>>* = nullptr> inline Maybe<T> Just(T&& t) { return Maybe<T>(std::move(t)); } // A template specialization of Maybe<T> for the case of T = void. template <> class Maybe<void> { public: V8_INLINE bool IsNothing() const { return !is_valid_; } V8_INLINE bool IsJust() const { return is_valid_; } V8_INLINE bool operator==(const Maybe& other) const { return IsJust() == other.IsJust(); } V8_INLINE bool operator!=(const Maybe& other) const { return !operator==(other); } private: struct JustTag {}; Maybe() : is_valid_(false) {} explicit Maybe(JustTag) : is_valid_(true) {} bool is_valid_; template <class U> friend Maybe<U> Nothing(); friend Maybe<void> JustVoid(); }; inline Maybe<void> JustVoid() { return Maybe<void>(Maybe<void>::JustTag()); } } // namespace v8 #endif // INCLUDE_V8_MAYBE_H_	4.47 KB	2025-03-03 12:36
📄 v8-memory-span.h // Copyright 2021 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. #ifndef INCLUDE_V8_MEMORY_SPAN_H_ #define INCLUDE_V8_MEMORY_SPAN_H_ #include <stddef.h> #include <array> #include <iterator> #include <type_traits> #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { /** * Points to an unowned contiguous buffer holding a known number of elements. * * This is similar to std::span (under consideration for C++20), but does not * require advanced C++ support. In the (far) future, this may be replaced with * or aliased to std::span. * * To facilitate future migration, this class exposes a subset of the interface * implemented by std::span. / template <typename T> class V8_EXPORT MemorySpan { private: /* Some C++ machinery, brought from the future. / template <typename From, typename To> using is_array_convertible = std::is_convertible<From ()[], To ()[]>; template <typename From, typename To> static constexpr bool is_array_convertible_v = is_array_convertible<From, To>::value; template <typename It> using iter_reference_t = decltype(std::declval<It&>()); template <typename It, typename = void> struct is_compatible_iterator : std::false_type {}; template <typename It> struct is_compatible_iterator< It, std::void_t< std::is_base_of<std::random_access_iterator_tag, typename std::iterator_traits<It>::iterator_category>, is_array_convertible<std::remove_reference_t<iter_reference_t<It>>, T>>> : std::true_type {}; template <typename It> static constexpr bool is_compatible_iterator_v = is_compatible_iterator<It>::value; template <typename U> static constexpr U* to_address(U* p) noexcept { return p; } template <typename It, typename = std::void_t<decltype(std::declval<It&>().operator->())>> static constexpr auto to_address(It it) noexcept { return it.operator->(); } public: /** The default constructor creates an empty span. / constexpr MemorySpan() = default; /* Constructor from nullptr and count, for backwards compatibility. * This is not compatible with C++20 std::span. / constexpr MemorySpan(std::nullptr_t, size_t) {} /* Constructor from "iterator" and count. / template <typename Iterator, std::enable_if_t<is_compatible_iterator_v<Iterator>, bool> = true> constexpr MemorySpan(Iterator first, size_t count) // NOLINT(runtime/explicit) : data_(to_address(first)), size_(count) {} /* Constructor from two "iterators". / template <typename Iterator, std::enable_if_t<is_compatible_iterator_v<Iterator> && !std::is_convertible_v<Iterator, size_t>, bool> = true> constexpr MemorySpan(Iterator first, Iterator last) // NOLINT(runtime/explicit) : data_(to_address(first)), size_(last - first) {} /* Implicit conversion from C-style array. / template <size_t N> constexpr MemorySpan(T (&a)[N]) noexcept // NOLINT(runtime/explicit) : data_(a), size_(N) {} /* Implicit conversion from std::array. / template <typename U, size_t N, std::enable_if_t<is_array_convertible_v<U, T>, bool> = true> constexpr MemorySpan( std::array<U, N>& a) noexcept // NOLINT(runtime/explicit) : data_(a.data()), size_{N} {} /* Implicit conversion from const std::array. / template <typename U, size_t N, std::enable_if_t<is_array_convertible_v<const U, T>, bool> = true> constexpr MemorySpan( const std::array<U, N>& a) noexcept // NOLINT(runtime/explicit) : data_(a.data()), size_{N} {} /* Returns a pointer to the beginning of the buffer. / constexpr T data() const { return data_; } /** Returns the number of elements that the buffer holds. / constexpr size_t size() const { return size_; } constexpr T& operator[](size_t i) const { return data_[i]; } /* Returns true if the buffer is empty. / constexpr bool empty() const { return size() == 0; } class Iterator { public: using iterator_category = std::forward_iterator_tag; using value_type = T; using difference_type = std::ptrdiff_t; using pointer = value_type; using reference = value_type&; T& operator() const { return ptr_; } T* operator->() const { return ptr_; } bool operator==(Iterator other) const { return ptr_ == other.ptr_; } bool operator!=(Iterator other) const { return !(this == other); } Iterator& operator++() { ++ptr_; return this; } Iterator operator++(int) { Iterator temp(this); ++(this); return temp; } private: friend class MemorySpan<T>; explicit Iterator(T* ptr) : ptr_(ptr) {} T* ptr_ = nullptr; }; Iterator begin() const { return Iterator(data_); } Iterator end() const { return Iterator(data_ + size_); } private: T* data_ = nullptr; size_t size_ = 0; }; /** * Helper function template to create an array of fixed length, initialized by * the provided initializer list, without explicitly specifying the array size, * e.g. * * auto arr = v8::to_array<Local<String>>({v8_str("one"), v8_str("two")}); * * In the future, this may be replaced with or aliased to std::to_array (under * consideration for C++20). */ namespace detail { template <class T, std::size_t N, std::size_t... I> constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl( T (&a)[N], std::index_sequence<I...>) { return {{a[I]...}}; } template <class T, std::size_t N, std::size_t... I> constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl( T (&&a)[N], std::index_sequence<I...>) { return {{std::move(a[I])...}}; } } // namespace detail template <class T, std::size_t N> constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) { return detail::to_array_lvalue_impl(a, std::make_index_sequence<N>{}); } template <class T, std::size_t N> constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&&a)[N]) { return detail::to_array_rvalue_impl(std::move(a), std::make_index_sequence<N>{}); } } // namespace v8 #endif // INCLUDE_V8_MEMORY_SPAN_H_	6.27 KB	2025-03-03 12:36
📄 v8-message.h // Copyright 2021 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. #ifndef INCLUDE_V8_MESSAGE_H_ #define INCLUDE_V8_MESSAGE_H_ #include <stdio.h> #include <iosfwd> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-maybe.h" // NOLINT(build/include_directory) #include "v8-primitive.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Integer; class PrimitiveArray; class StackTrace; class String; class Value; /** * The optional attributes of ScriptOrigin. / class ScriptOriginOptions { public: V8_INLINE ScriptOriginOptions(bool is_shared_cross_origin = false, bool is_opaque = false, bool is_wasm = false, bool is_module = false) : flags_((is_shared_cross_origin ? kIsSharedCrossOrigin : 0) \| (is_wasm ? kIsWasm : 0) \| (is_opaque ? kIsOpaque : 0) \| (is_module ? kIsModule : 0)) {} V8_INLINE ScriptOriginOptions(int flags) : flags_(flags & (kIsSharedCrossOrigin \| kIsOpaque \| kIsWasm \| kIsModule)) {} bool IsSharedCrossOrigin() const { return (flags_ & kIsSharedCrossOrigin) != 0; } bool IsOpaque() const { return (flags_ & kIsOpaque) != 0; } bool IsWasm() const { return (flags_ & kIsWasm) != 0; } bool IsModule() const { return (flags_ & kIsModule) != 0; } int Flags() const { return flags_; } private: enum { kIsSharedCrossOrigin = 1, kIsOpaque = 1 << 1, kIsWasm = 1 << 2, kIsModule = 1 << 3 }; const int flags_; }; /* * The origin, within a file, of a script. / class V8_EXPORT ScriptOrigin { public: V8_DEPRECATE_SOON("Use constructor without the isolate.") V8_INLINE ScriptOrigin(Isolate isolate, Local<Value> resource_name, int resource_line_offset = 0, int resource_column_offset = 0, bool resource_is_shared_cross_origin = false, int script_id = -1, Local<Value> source_map_url = Local<Value>(), bool resource_is_opaque = false, bool is_wasm = false, bool is_module = false, Local<Data> host_defined_options = Local<Data>()) : resource_name_(resource_name), resource_line_offset_(resource_line_offset), resource_column_offset_(resource_column_offset), options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm, is_module), script_id_(script_id), source_map_url_(source_map_url), host_defined_options_(host_defined_options) { VerifyHostDefinedOptions(); } V8_INLINE ScriptOrigin(Local<Value> resource_name, int resource_line_offset = 0, int resource_column_offset = 0, bool resource_is_shared_cross_origin = false, int script_id = -1, Local<Value> source_map_url = Local<Value>(), bool resource_is_opaque = false, bool is_wasm = false, bool is_module = false, Local<Data> host_defined_options = Local<Data>()) : resource_name_(resource_name), resource_line_offset_(resource_line_offset), resource_column_offset_(resource_column_offset), options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm, is_module), script_id_(script_id), source_map_url_(source_map_url), host_defined_options_(host_defined_options) { VerifyHostDefinedOptions(); } V8_INLINE Local<Value> ResourceName() const; V8_INLINE int LineOffset() const; V8_INLINE int ColumnOffset() const; V8_INLINE int ScriptId() const; V8_INLINE Local<Value> SourceMapUrl() const; V8_INLINE Local<Data> GetHostDefinedOptions() const; V8_INLINE ScriptOriginOptions Options() const { return options_; } private: void VerifyHostDefinedOptions() const; Local<Value> resource_name_; int resource_line_offset_; int resource_column_offset_; ScriptOriginOptions options_; int script_id_; Local<Value> source_map_url_; Local<Data> host_defined_options_; }; /** * An error message. / class V8_EXPORT Message { public: Local<String> Get() const; /* * Return the isolate to which the Message belongs. / Isolate GetIsolate() const; V8_WARN_UNUSED_RESULT MaybeLocal<String> GetSource( Local<Context> context) const; V8_WARN_UNUSED_RESULT MaybeLocal<String> GetSourceLine( Local<Context> context) const; /** * Returns the origin for the script from where the function causing the * error originates. / ScriptOrigin GetScriptOrigin() const; /* * Returns the resource name for the script from where the function causing * the error originates. / Local<Value> GetScriptResourceName() const; /* * Exception stack trace. By default stack traces are not captured for * uncaught exceptions. SetCaptureStackTraceForUncaughtExceptions allows * to change this option. / Local<StackTrace> GetStackTrace() const; /* * Returns the number, 1-based, of the line where the error occurred. / V8_WARN_UNUSED_RESULT Maybe<int> GetLineNumber(Local<Context> context) const; /* * Returns the index within the script of the first character where * the error occurred. / int GetStartPosition() const; /* * Returns the index within the script of the last character where * the error occurred. / int GetEndPosition() const; /* * Returns the Wasm function index where the error occurred. Returns -1 if * message is not from a Wasm script. / int GetWasmFunctionIndex() const; /* * Returns the error level of the message. / int ErrorLevel() const; /* * Returns the index within the line of the first character where * the error occurred. / int GetStartColumn() const; V8_WARN_UNUSED_RESULT Maybe<int> GetStartColumn(Local<Context> context) const; /* * Returns the index within the line of the last character where * the error occurred. / int GetEndColumn() const; V8_WARN_UNUSED_RESULT Maybe<int> GetEndColumn(Local<Context> context) const; /* * Passes on the value set by the embedder when it fed the script from which * this Message was generated to V8. / bool IsSharedCrossOrigin() const; bool IsOpaque() const; static void PrintCurrentStackTrace(Isolate isolate, std::ostream& out); static const int kNoLineNumberInfo = 0; static const int kNoColumnInfo = 0; static const int kNoScriptIdInfo = 0; static const int kNoWasmFunctionIndexInfo = -1; }; Local<Value> ScriptOrigin::ResourceName() const { return resource_name_; } Local<Data> ScriptOrigin::GetHostDefinedOptions() const { return host_defined_options_; } int ScriptOrigin::LineOffset() const { return resource_line_offset_; } int ScriptOrigin::ColumnOffset() const { return resource_column_offset_; } int ScriptOrigin::ScriptId() const { return script_id_; } Local<Value> ScriptOrigin::SourceMapUrl() const { return source_map_url_; } } // namespace v8 #endif // INCLUDE_V8_MESSAGE_H_	7.24 KB	2025-03-03 12:36
📄 v8-microtask-queue.h // Copyright 2021 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. #ifndef INCLUDE_V8_MICROTASKS_QUEUE_H_ #define INCLUDE_V8_MICROTASKS_QUEUE_H_ #include <stddef.h> #include <memory> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-microtask.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Function; namespace internal { class Isolate; class MicrotaskQueue; } // namespace internal /** * Represents the microtask queue, where microtasks are stored and processed. * https://html.spec.whatwg.org/multipage/webappapis.html#microtask-queue * https://html.spec.whatwg.org/multipage/webappapis.html#enqueuejob(queuename,-job,-arguments) * https://html.spec.whatwg.org/multipage/webappapis.html#perform-a-microtask-checkpoint * * A MicrotaskQueue instance may be associated to multiple Contexts by passing * it to Context::New(), and they can be detached by Context::DetachGlobal(). * The embedder must keep the MicrotaskQueue instance alive until all associated * Contexts are gone or detached. * * Use the same instance of MicrotaskQueue for all Contexts that may access each * other synchronously. E.g. for Web embedding, use the same instance for all * origins that share the same URL scheme and eTLD+1. / class V8_EXPORT MicrotaskQueue { public: /* * Creates an empty MicrotaskQueue instance. / static std::unique_ptr<MicrotaskQueue> New( Isolate isolate, MicrotasksPolicy policy = MicrotasksPolicy::kAuto); virtual ~MicrotaskQueue() = default; /** * Enqueues the callback to the queue. / virtual void EnqueueMicrotask(Isolate isolate, Local<Function> microtask) = 0; /** * Enqueues the callback to the queue. / virtual void EnqueueMicrotask(v8::Isolate isolate, MicrotaskCallback callback, void* data = nullptr) = 0; /** * Adds a callback to notify the embedder after microtasks were run. The * callback is triggered by explicit RunMicrotasks call or automatic * microtasks execution (see Isolate::SetMicrotasksPolicy). * * Callback will trigger even if microtasks were attempted to run, * but the microtasks queue was empty and no single microtask was actually * executed. * * Executing scripts inside the callback will not re-trigger microtasks and * the callback. / virtual void AddMicrotasksCompletedCallback( MicrotasksCompletedCallbackWithData callback, void data = nullptr) = 0; /** * Removes callback that was installed by AddMicrotasksCompletedCallback. / virtual void RemoveMicrotasksCompletedCallback( MicrotasksCompletedCallbackWithData callback, void data = nullptr) = 0; /** * Runs microtasks if no microtask is running on this MicrotaskQueue instance. / virtual void PerformCheckpoint(Isolate isolate) = 0; /** * Returns true if a microtask is running on this MicrotaskQueue instance. / virtual bool IsRunningMicrotasks() const = 0; /* * Returns the current depth of nested MicrotasksScope that has * kRunMicrotasks. / virtual int GetMicrotasksScopeDepth() const = 0; MicrotaskQueue(const MicrotaskQueue&) = delete; MicrotaskQueue& operator=(const MicrotaskQueue&) = delete; private: friend class internal::MicrotaskQueue; MicrotaskQueue() = default; }; /* * This scope is used to control microtasks when MicrotasksPolicy::kScoped * is used on Isolate. In this mode every non-primitive call to V8 should be * done inside some MicrotasksScope. * Microtasks are executed when topmost MicrotasksScope marked as kRunMicrotasks * exits. * kDoNotRunMicrotasks should be used to annotate calls not intended to trigger * microtasks. / class V8_EXPORT V8_NODISCARD MicrotasksScope { public: enum Type { kRunMicrotasks, kDoNotRunMicrotasks }; V8_DEPRECATE_SOON( "May be incorrect if context was created with non-default microtask " "queue") MicrotasksScope(Isolate isolate, Type type); MicrotasksScope(Local<Context> context, Type type); MicrotasksScope(Isolate* isolate, MicrotaskQueue* microtask_queue, Type type); ~MicrotasksScope(); /** * Runs microtasks if no kRunMicrotasks scope is currently active. / static void PerformCheckpoint(Isolate isolate); /** * Returns current depth of nested kRunMicrotasks scopes. / static int GetCurrentDepth(Isolate isolate); /** * Returns true while microtasks are being executed. / static bool IsRunningMicrotasks(Isolate isolate); // Prevent copying. MicrotasksScope(const MicrotasksScope&) = delete; MicrotasksScope& operator=(const MicrotasksScope&) = delete; private: internal::Isolate* const i_isolate_; internal::MicrotaskQueue* const microtask_queue_; bool run_; }; } // namespace v8 #endif // INCLUDE_V8_MICROTASKS_QUEUE_H_	4.95 KB	2025-03-03 12:36
📄 v8-microtask.h // Copyright 2021 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. #ifndef INCLUDE_V8_MICROTASK_H_ #define INCLUDE_V8_MICROTASK_H_ namespace v8 { class Isolate; // --- Microtasks Callbacks --- using MicrotasksCompletedCallbackWithData = void ()(Isolate, void); using MicrotaskCallback = void ()(void* data); /** * Policy for running microtasks: * - explicit: microtasks are invoked with the * Isolate::PerformMicrotaskCheckpoint() method; * - scoped: microtasks invocation is controlled by MicrotasksScope objects; * - auto: microtasks are invoked when the script call depth decrements * to zero. */ enum class MicrotasksPolicy { kExplicit, kScoped, kAuto }; } // namespace v8 #endif // INCLUDE_V8_MICROTASK_H_	861 B	2025-03-03 12:36
📄 v8-object.h // Copyright 2021 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. #ifndef INCLUDE_V8_OBJECT_H_ #define INCLUDE_V8_OBJECT_H_ #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-maybe.h" // NOLINT(build/include_directory) #include "v8-persistent-handle.h" // NOLINT(build/include_directory) #include "v8-primitive.h" // NOLINT(build/include_directory) #include "v8-traced-handle.h" // NOLINT(build/include_directory) #include "v8-value.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Array; class Function; class FunctionTemplate; template <typename T> class PropertyCallbackInfo; /** * A private symbol * * This is an experimental feature. Use at your own risk. / class V8_EXPORT Private : public Data { public: /* * Returns the print name string of the private symbol, or undefined if none. / Local<Value> Name() const; /* * Create a private symbol. If name is not empty, it will be the description. / static Local<Private> New(Isolate isolate, Local<String> name = Local<String>()); /** * Retrieve a global private symbol. If a symbol with this name has not * been retrieved in the same isolate before, it is created. * Note that private symbols created this way are never collected, so * they should only be used for statically fixed properties. * Also, there is only one global name space for the names used as keys. * To minimize the potential for clashes, use qualified names as keys, * e.g., "Class#property". / static Local<Private> ForApi(Isolate isolate, Local<String> name); V8_INLINE static Private* Cast(Data* data); private: Private(); static void CheckCast(Data* that); }; /** * An instance of a Property Descriptor, see Ecma-262 6.2.4. * * Properties in a descriptor are present or absent. If you do not set * `enumerable`, `configurable`, and `writable`, they are absent. If `value`, * `get`, or `set` are absent, but you must specify them in the constructor, use * empty handles. * * Accessors `get` and `set` must be callable or undefined if they are present. * * \note Only query properties if they are present, i.e., call `x()` only if * `has_x()` returns true. * * \code * // var desc = {writable: false} * v8::PropertyDescriptor d(Local<Value>()), false); * d.value(); // error, value not set * if (d.has_writable()) { * d.writable(); // false * } * * // var desc = {value: undefined} * v8::PropertyDescriptor d(v8::Undefined(isolate)); * * // var desc = {get: undefined} * v8::PropertyDescriptor d(v8::Undefined(isolate), Local<Value>())); * \endcode / class V8_EXPORT PropertyDescriptor { public: // GenericDescriptor PropertyDescriptor(); // DataDescriptor explicit PropertyDescriptor(Local<Value> value); // DataDescriptor with writable property PropertyDescriptor(Local<Value> value, bool writable); // AccessorDescriptor PropertyDescriptor(Local<Value> get, Local<Value> set); ~PropertyDescriptor(); Local<Value> value() const; bool has_value() const; Local<Value> get() const; bool has_get() const; Local<Value> set() const; bool has_set() const; void set_enumerable(bool enumerable); bool enumerable() const; bool has_enumerable() const; void set_configurable(bool configurable); bool configurable() const; bool has_configurable() const; bool writable() const; bool has_writable() const; struct PrivateData; PrivateData get_private() const { return private_; } PropertyDescriptor(const PropertyDescriptor&) = delete; void operator=(const PropertyDescriptor&) = delete; private: PrivateData* private_; }; /** * PropertyAttribute. / enum PropertyAttribute { /* None. / None = 0, / ReadOnly, i.e., not writable. / ReadOnly = 1 << 0, / DontEnum, i.e., not enumerable. / DontEnum = 1 << 1, / DontDelete, i.e., not configurable. / DontDelete = 1 << 2 }; / * Accessor[Getter\|Setter] are used as callback functions when * setting\|getting a particular property. See Object and ObjectTemplate's * method SetAccessor. / using AccessorGetterCallback = void ()(Local<String> property, const PropertyCallbackInfo<Value>& info); using AccessorNameGetterCallback = void ()(Local<Name> property, const PropertyCallbackInfo<Value>& info); using AccessorSetterCallback = void ()(Local<String> property, Local<Value> value, const PropertyCallbackInfo<void>& info); using AccessorNameSetterCallback = void ()(Local<Name> property, Local<Value> value, const PropertyCallbackInfo<void>& info); /* * Access control specifications. * * Some accessors should be accessible across contexts. These * accessors have an explicit access control parameter which specifies * the kind of cross-context access that should be allowed. * / enum AccessControl { DEFAULT = 0, }; /* * Property filter bits. They can be or'ed to build a composite filter. / enum PropertyFilter { ALL_PROPERTIES = 0, ONLY_WRITABLE = 1, ONLY_ENUMERABLE = 2, ONLY_CONFIGURABLE = 4, SKIP_STRINGS = 8, SKIP_SYMBOLS = 16 }; /* * Options for marking whether callbacks may trigger JS-observable side effects. * Side-effect-free callbacks are allowlisted during debug evaluation with * throwOnSideEffect. It applies when calling a Function, FunctionTemplate, * or an Accessor callback. For Interceptors, please see * PropertyHandlerFlags's kHasNoSideEffect. * Callbacks that only cause side effects to the receiver are allowlisted if * invoked on receiver objects that are created within the same debug-evaluate * call, as these objects are temporary and the side effect does not escape. / enum class SideEffectType { kHasSideEffect, kHasNoSideEffect, kHasSideEffectToReceiver }; /* * Keys/Properties filter enums: * * KeyCollectionMode limits the range of collected properties. kOwnOnly limits * the collected properties to the given Object only. kIncludesPrototypes will * include all keys of the objects's prototype chain as well. / enum class KeyCollectionMode { kOwnOnly, kIncludePrototypes }; /* * kIncludesIndices allows for integer indices to be collected, while * kSkipIndices will exclude integer indices from being collected. / enum class IndexFilter { kIncludeIndices, kSkipIndices }; /* * kConvertToString will convert integer indices to strings. * kKeepNumbers will return numbers for integer indices. / enum class KeyConversionMode { kConvertToString, kKeepNumbers, kNoNumbers }; /* * Integrity level for objects. / enum class IntegrityLevel { kFrozen, kSealed }; /* * A JavaScript object (ECMA-262, 4.3.3) / class V8_EXPORT Object : public Value { public: /* * Set only return Just(true) or Empty(), so if it should never fail, use * result.Check(). / V8_WARN_UNUSED_RESULT Maybe<bool> Set(Local<Context> context, Local<Value> key, Local<Value> value); V8_WARN_UNUSED_RESULT Maybe<bool> Set(Local<Context> context, uint32_t index, Local<Value> value); /* * Implements CreateDataProperty(O, P, V), see * https://tc39.es/ecma262/#sec-createdataproperty. * * Defines a configurable, writable, enumerable property with the given value * on the object unless the property already exists and is not configurable * or the object is not extensible. * * Returns true on success. / V8_WARN_UNUSED_RESULT Maybe<bool> CreateDataProperty(Local<Context> context, Local<Name> key, Local<Value> value); V8_WARN_UNUSED_RESULT Maybe<bool> CreateDataProperty(Local<Context> context, uint32_t index, Local<Value> value); /* * Implements [[DefineOwnProperty]] for data property case, see * https://tc39.es/ecma262/#table-essential-internal-methods. * * In general, CreateDataProperty will be faster, however, does not allow * for specifying attributes. * * Returns true on success. / V8_WARN_UNUSED_RESULT Maybe<bool> DefineOwnProperty( Local<Context> context, Local<Name> key, Local<Value> value, PropertyAttribute attributes = None); /* * Implements Object.defineProperty(O, P, Attributes), see * https://tc39.es/ecma262/#sec-object.defineproperty. * * The defineProperty function is used to add an own property or * update the attributes of an existing own property of an object. * * Both data and accessor descriptors can be used. * * In general, CreateDataProperty is faster, however, does not allow * for specifying attributes or an accessor descriptor. * * The PropertyDescriptor can change when redefining a property. * * Returns true on success. / V8_WARN_UNUSED_RESULT Maybe<bool> DefineProperty( Local<Context> context, Local<Name> key, PropertyDescriptor& descriptor); V8_WARN_UNUSED_RESULT MaybeLocal<Value> Get(Local<Context> context, Local<Value> key); V8_WARN_UNUSED_RESULT MaybeLocal<Value> Get(Local<Context> context, uint32_t index); /* * Gets the property attributes of a property which can be None or * any combination of ReadOnly, DontEnum and DontDelete. Returns * None when the property doesn't exist. / V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute> GetPropertyAttributes( Local<Context> context, Local<Value> key); /* * Implements Object.getOwnPropertyDescriptor(O, P), see * https://tc39.es/ecma262/#sec-object.getownpropertydescriptor. / V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetOwnPropertyDescriptor( Local<Context> context, Local<Name> key); /* * Object::Has() calls the abstract operation HasProperty(O, P), see * https://tc39.es/ecma262/#sec-hasproperty. Has() returns * true, if the object has the property, either own or on the prototype chain. * Interceptors, i.e., PropertyQueryCallbacks, are called if present. * * Has() has the same side effects as JavaScript's `variable in object`. * For example, calling Has() on a revoked proxy will throw an exception. * * \note Has() converts the key to a name, which possibly calls back into * JavaScript. * * See also v8::Object::HasOwnProperty() and * v8::Object::HasRealNamedProperty(). / V8_WARN_UNUSED_RESULT Maybe<bool> Has(Local<Context> context, Local<Value> key); V8_WARN_UNUSED_RESULT Maybe<bool> Delete(Local<Context> context, Local<Value> key); V8_WARN_UNUSED_RESULT Maybe<bool> Has(Local<Context> context, uint32_t index); V8_WARN_UNUSED_RESULT Maybe<bool> Delete(Local<Context> context, uint32_t index); V8_DEPRECATE_SOON("Use SetNativeDataProperty instead") V8_WARN_UNUSED_RESULT Maybe<bool> SetAccessor( Local<Context> context, Local<Name> name, AccessorNameGetterCallback getter, AccessorNameSetterCallback setter = nullptr, MaybeLocal<Value> data = MaybeLocal<Value>(), AccessControl deprecated_settings = DEFAULT, PropertyAttribute attribute = None, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); void SetAccessorProperty(Local<Name> name, Local<Function> getter, Local<Function> setter = Local<Function>(), PropertyAttribute attributes = None); /* * Sets a native data property like Template::SetNativeDataProperty, but * this method sets on this object directly. / V8_WARN_UNUSED_RESULT Maybe<bool> SetNativeDataProperty( Local<Context> context, Local<Name> name, AccessorNameGetterCallback getter, AccessorNameSetterCallback setter = nullptr, Local<Value> data = Local<Value>(), PropertyAttribute attributes = None, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); /* * Attempts to create a property with the given name which behaves like a data * property, except that the provided getter is invoked (and provided with the * data value) to supply its value the first time it is read. After the * property is accessed once, it is replaced with an ordinary data property. * * Analogous to Template::SetLazyDataProperty. / V8_WARN_UNUSED_RESULT Maybe<bool> SetLazyDataProperty( Local<Context> context, Local<Name> name, AccessorNameGetterCallback getter, Local<Value> data = Local<Value>(), PropertyAttribute attributes = None, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); /* * Functionality for private properties. * This is an experimental feature, use at your own risk. * Note: Private properties are not inherited. Do not rely on this, since it * may change. / Maybe<bool> HasPrivate(Local<Context> context, Local<Private> key); Maybe<bool> SetPrivate(Local<Context> context, Local<Private> key, Local<Value> value); Maybe<bool> DeletePrivate(Local<Context> context, Local<Private> key); MaybeLocal<Value> GetPrivate(Local<Context> context, Local<Private> key); /* * Returns an array containing the names of the enumerable properties * of this object, including properties from prototype objects. The * array returned by this method contains the same values as would * be enumerated by a for-in statement over this object. / V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetPropertyNames( Local<Context> context); V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetPropertyNames( Local<Context> context, KeyCollectionMode mode, PropertyFilter property_filter, IndexFilter index_filter, KeyConversionMode key_conversion = KeyConversionMode::kKeepNumbers); /* * This function has the same functionality as GetPropertyNames but * the returned array doesn't contain the names of properties from * prototype objects. / V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetOwnPropertyNames( Local<Context> context); /* * Returns an array containing the names of the filtered properties * of this object, including properties from prototype objects. The * array returned by this method contains the same values as would * be enumerated by a for-in statement over this object. / V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetOwnPropertyNames( Local<Context> context, PropertyFilter filter, KeyConversionMode key_conversion = KeyConversionMode::kKeepNumbers); /* * Get the prototype object. This does not skip objects marked to * be skipped by __proto__ and it does not consult the security * handler. / Local<Value> GetPrototype(); /* * Set the prototype object. This does not skip objects marked to * be skipped by __proto__ and it does not consult the security * handler. / V8_WARN_UNUSED_RESULT Maybe<bool> SetPrototype(Local<Context> context, Local<Value> prototype); /* * Finds an instance of the given function template in the prototype * chain. / Local<Object> FindInstanceInPrototypeChain(Local<FunctionTemplate> tmpl); /* * Call builtin Object.prototype.toString on this object. * This is different from Value::ToString() that may call * user-defined toString function. This one does not. / V8_WARN_UNUSED_RESULT MaybeLocal<String> ObjectProtoToString( Local<Context> context); /* * Returns the name of the function invoked as a constructor for this object. / Local<String> GetConstructorName(); /* * Sets the integrity level of the object. / Maybe<bool> SetIntegrityLevel(Local<Context> context, IntegrityLevel level); /* Gets the number of internal fields for this Object. / int InternalFieldCount() const; /* Same as above, but works for PersistentBase. / V8_INLINE static int InternalFieldCount( const PersistentBase<Object>& object) { return object.template value<Object>()->InternalFieldCount(); } /* Same as above, but works for BasicTracedReference. / V8_INLINE static int InternalFieldCount( const BasicTracedReference<Object>& object) { return object.template value<Object>()->InternalFieldCount(); } /* * Gets the data from an internal field. * To cast the return value into v8::Value subtypes, it needs to be * casted to a v8::Value first. For example, to cast it into v8::External: * * object->GetInternalField(index).As<v8::Value>().As<v8::External>(); * * The embedder should make sure that the internal field being retrieved * using this method has already been set with SetInternalField() before. / V8_INLINE Local<Data> GetInternalField(int index); / Sets the data in an internal field. / void SetInternalField(int index, Local<Data> data); /* * Gets a 2-byte-aligned native pointer from an internal field. This field * must have been set by SetAlignedPointerInInternalField, everything else * leads to undefined behavior. / V8_INLINE void GetAlignedPointerFromInternalField(int index); V8_INLINE void* GetAlignedPointerFromInternalField(v8::Isolate* isolate, int index); /** Same as above, but works for PersistentBase. / V8_INLINE static void GetAlignedPointerFromInternalField( const PersistentBase<Object>& object, int index) { return object.template value<Object>()->GetAlignedPointerFromInternalField( index); } /** Same as above, but works for TracedReference. / V8_INLINE static void GetAlignedPointerFromInternalField( const BasicTracedReference<Object>& object, int index) { return object.template value<Object>()->GetAlignedPointerFromInternalField( index); } /** * Sets a 2-byte-aligned native pointer in an internal field. To retrieve such * a field, GetAlignedPointerFromInternalField must be used, everything else * leads to undefined behavior. / void SetAlignedPointerInInternalField(int index, void value); void SetAlignedPointerInInternalFields(int argc, int indices[], void* values[]); /** * HasOwnProperty() is like JavaScript's Object.prototype.hasOwnProperty(). * * See also v8::Object::Has() and v8::Object::HasRealNamedProperty(). / V8_WARN_UNUSED_RESULT Maybe<bool> HasOwnProperty(Local<Context> context, Local<Name> key); V8_WARN_UNUSED_RESULT Maybe<bool> HasOwnProperty(Local<Context> context, uint32_t index); /* * Use HasRealNamedProperty() if you want to check if an object has an own * property without causing side effects, i.e., without calling interceptors. * * This function is similar to v8::Object::HasOwnProperty(), but it does not * call interceptors. * * \note Consider using non-masking interceptors, i.e., the interceptors are * not called if the receiver has the real named property. See * `v8::PropertyHandlerFlags::kNonMasking`. * * See also v8::Object::Has(). / V8_WARN_UNUSED_RESULT Maybe<bool> HasRealNamedProperty(Local<Context> context, Local<Name> key); V8_WARN_UNUSED_RESULT Maybe<bool> HasRealIndexedProperty( Local<Context> context, uint32_t index); V8_WARN_UNUSED_RESULT Maybe<bool> HasRealNamedCallbackProperty( Local<Context> context, Local<Name> key); /* * If result.IsEmpty() no real property was located in the prototype chain. * This means interceptors in the prototype chain are not called. / V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetRealNamedPropertyInPrototypeChain( Local<Context> context, Local<Name> key); /* * Gets the property attributes of a real property in the prototype chain, * which can be None or any combination of ReadOnly, DontEnum and DontDelete. * Interceptors in the prototype chain are not called. / V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute> GetRealNamedPropertyAttributesInPrototypeChain(Local<Context> context, Local<Name> key); /* * If result.IsEmpty() no real property was located on the object or * in the prototype chain. * This means interceptors in the prototype chain are not called. / V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetRealNamedProperty( Local<Context> context, Local<Name> key); /* * Gets the property attributes of a real property which can be * None or any combination of ReadOnly, DontEnum and DontDelete. * Interceptors in the prototype chain are not called. / V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute> GetRealNamedPropertyAttributes( Local<Context> context, Local<Name> key); /* Tests for a named lookup interceptor./ bool HasNamedLookupInterceptor() const; /* Tests for an index lookup interceptor./ bool HasIndexedLookupInterceptor() const; /* * Returns the identity hash for this object. The current implementation * uses a hidden property on the object to store the identity hash. * * The return value will never be 0. Also, it is not guaranteed to be * unique. / int GetIdentityHash(); /* * Clone this object with a fast but shallow copy. Values will point * to the same values as the original object. / // TODO(dcarney): take an isolate and optionally bail out? Local<Object> Clone(); /* * Returns the context in which the object was created. / MaybeLocal<Context> GetCreationContext(); /* * Shortcut for GetCreationContext().ToLocalChecked(). / Local<Context> GetCreationContextChecked(); / Same as above, but works for Persistents / V8_INLINE static MaybeLocal<Context> GetCreationContext( const PersistentBase<Object>& object) { return object.template value<Object>()->GetCreationContext(); } /* * Gets the context in which the object was created (see GetCreationContext()) * and if it's available reads respective embedder field value. * If the context can't be obtained nullptr is returned. * Basically it's a shortcut for * obj->GetCreationContext().GetAlignedPointerFromEmbedderData(index) * which doesn't create a handle for Context object on the way and doesn't * try to expand the embedder data attached to the context. * In case the Local<Context> is already available because of other reasons, * it's fine to keep using Context::GetAlignedPointerFromEmbedderData(). / void GetAlignedPointerFromEmbedderDataInCreationContext(int index); /** * Checks whether a callback is set by the * ObjectTemplate::SetCallAsFunctionHandler method. * When an Object is callable this method returns true. / bool IsCallable() const; /* * True if this object is a constructor. / bool IsConstructor() const; /* * True if this object can carry information relevant to the embedder in its * embedder fields, false otherwise. This is generally true for objects * constructed through function templates but also holds for other types where * V8 automatically adds internal fields at compile time, such as e.g. * v8::ArrayBuffer. / bool IsApiWrapper() const; /* * True if this object was created from an object template which was marked * as undetectable. See v8::ObjectTemplate::MarkAsUndetectable for more * information. / bool IsUndetectable() const; /* * Call an Object as a function if a callback is set by the * ObjectTemplate::SetCallAsFunctionHandler method. / V8_WARN_UNUSED_RESULT MaybeLocal<Value> CallAsFunction(Local<Context> context, Local<Value> recv, int argc, Local<Value> argv[]); /* * Call an Object as a constructor if a callback is set by the * ObjectTemplate::SetCallAsFunctionHandler method. * Note: This method behaves like the Function::NewInstance method. / V8_WARN_UNUSED_RESULT MaybeLocal<Value> CallAsConstructor( Local<Context> context, int argc, Local<Value> argv[]); /* * Return the isolate to which the Object belongs to. / Isolate GetIsolate(); V8_INLINE static Isolate* GetIsolate(const TracedReference<Object>& handle) { return handle.template value<Object>()->GetIsolate(); } /** * If this object is a Set, Map, WeakSet or WeakMap, this returns a * representation of the elements of this object as an array. * If this object is a SetIterator or MapIterator, this returns all * elements of the underlying collection, starting at the iterator's current * position. * For other types, this will return an empty MaybeLocal<Array> (without * scheduling an exception). / MaybeLocal<Array> PreviewEntries(bool is_key_value); static Local<Object> New(Isolate* isolate); /** * Creates a JavaScript object with the given properties, and * a the given prototype_or_null (which can be any JavaScript * value, and if it's null, the newly created object won't have * a prototype at all). This is similar to Object.create(). * All properties will be created as enumerable, configurable * and writable properties. / static Local<Object> New(Isolate isolate, Local<Value> prototype_or_null, Local<Name>* names, Local<Value>* values, size_t length); V8_INLINE static Object* Cast(Value* obj); /** * Support for TC39 "dynamic code brand checks" proposal. * * This API allows to query whether an object was constructed from a * "code like" ObjectTemplate. * * See also: v8::ObjectTemplate::SetCodeLike / bool IsCodeLike(Isolate isolate) const; private: Object(); static void CheckCast(Value* obj); Local<Data> SlowGetInternalField(int index); void* SlowGetAlignedPointerFromInternalField(int index); void* SlowGetAlignedPointerFromInternalField(v8::Isolate* isolate, int index); }; // --- Implementation --- Local<Data> Object::GetInternalField(int index) { #ifndef V8_ENABLE_CHECKS using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); // Fast path: If the object is a plain JSObject, which is the common case, we // know where to find the internal fields and can return the value directly. int instance_type = I::GetInstanceType(obj); if (I::CanHaveInternalField(instance_type)) { int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index); A value = I::ReadRawField<A>(obj, offset); #ifdef V8_COMPRESS_POINTERS // We read the full pointer value and then decompress it in order to avoid // dealing with potential endiannes issues. value = I::DecompressTaggedField(obj, static_cast<uint32_t>(value)); #endif auto isolate = reinterpret_cast<v8::Isolate>( internal::IsolateFromNeverReadOnlySpaceObject(obj)); return Local<Data>::New(isolate, value); } #endif return SlowGetInternalField(index); } void Object::GetAlignedPointerFromInternalField(v8::Isolate* isolate, int index) { #if !defined(V8_ENABLE_CHECKS) using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); // Fast path: If the object is a plain JSObject, which is the common case, we // know where to find the internal fields and can return the value directly. auto instance_type = I::GetInstanceType(obj); if (V8_LIKELY(I::CanHaveInternalField(instance_type))) { int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index) + I::kEmbedderDataSlotExternalPointerOffset; A value = I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>( isolate, obj, offset); return reinterpret_cast<void>(value); } #endif return SlowGetAlignedPointerFromInternalField(isolate, index); } void Object::GetAlignedPointerFromInternalField(int index) { #if !defined(V8_ENABLE_CHECKS) using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); // Fast path: If the object is a plain JSObject, which is the common case, we // know where to find the internal fields and can return the value directly. auto instance_type = I::GetInstanceType(obj); if (V8_LIKELY(I::CanHaveInternalField(instance_type))) { int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index) + I::kEmbedderDataSlotExternalPointerOffset; Isolate* isolate = I::GetIsolateForSandbox(obj); A value = I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>( isolate, obj, offset); return reinterpret_cast<void>(value); } #endif return SlowGetAlignedPointerFromInternalField(index); } Private Private::Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return reinterpret_cast<Private>(data); } Object Object::Cast(v8::Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Object*>(value); } } // namespace v8 #endif // INCLUDE_V8_OBJECT_H_	29.55 KB	2025-03-03 12:36
📄 v8-persistent-handle.h // Copyright 2021 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. #ifndef INCLUDE_V8_PERSISTENT_HANDLE_H_ #define INCLUDE_V8_PERSISTENT_HANDLE_H_ #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-weak-callback-info.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Isolate; template <class K, class V, class T> class PersistentValueMapBase; template <class V, class T> class PersistentValueVector; template <class T> class Global; template <class T> class PersistentBase; template <class K, class V, class T> class PersistentValueMap; class Value; namespace api_internal { V8_EXPORT internal::Address* Eternalize(v8::Isolate* isolate, Value* handle); V8_EXPORT internal::Address* CopyGlobalReference(internal::Address* from); V8_EXPORT void DisposeGlobal(internal::Address* global_handle); V8_EXPORT void MakeWeak(internal::Address** location_addr); V8_EXPORT void* ClearWeak(internal::Address* location); V8_EXPORT void AnnotateStrongRetainer(internal::Address* location, const char* label); V8_EXPORT internal::Address* GlobalizeReference(internal::Isolate* isolate, internal::Address value); V8_EXPORT void MoveGlobalReference(internal::Address from, internal::Address to); } // namespace api_internal /** * Eternal handles are set-once handles that live for the lifetime of the * isolate. / template <class T> class Eternal : public api_internal::IndirectHandleBase { public: V8_INLINE Eternal() = default; template <class S> V8_INLINE Eternal(Isolate isolate, Local<S> handle) { Set(isolate, handle); } // Can only be safely called if already set. V8_INLINE Local<T> Get(Isolate* isolate) const { // The eternal handle will never go away, so as with the roots, we don't // even need to open a handle. return Local<T>::FromSlot(slot()); } template <class S> void Set(Isolate* isolate, Local<S> handle) { static_assert(std::is_base_of<T, S>::value, "type check"); slot() = api_internal::Eternalize(isolate, handle.template UnsafeAs<Value>()); } }; namespace api_internal { V8_EXPORT void MakeWeak(internal::Address location, void* data, WeakCallbackInfo<void>::Callback weak_callback, WeakCallbackType type); } // namespace api_internal /** * An object reference that is independent of any handle scope. Where * a Local handle only lives as long as the HandleScope in which it was * allocated, a PersistentBase handle remains valid until it is explicitly * disposed using Reset(). * * A persistent handle contains a reference to a storage cell within * the V8 engine which holds an object value and which is updated by * the garbage collector whenever the object is moved. A new storage * cell can be created using the constructor or PersistentBase::Reset and * existing handles can be disposed using PersistentBase::Reset. * / template <class T> class PersistentBase : public api_internal::IndirectHandleBase { public: /* * If non-empty, destroy the underlying storage cell * IsEmpty() will return true after this call. / V8_INLINE void Reset(); /* * If non-empty, destroy the underlying storage cell * and create a new one with the contents of other if other is non empty / template <class S> V8_INLINE void Reset(Isolate isolate, const Local<S>& other); /** * If non-empty, destroy the underlying storage cell * and create a new one with the contents of other if other is non empty / template <class S> V8_INLINE void Reset(Isolate isolate, const PersistentBase<S>& other); V8_INLINE Local<T> Get(Isolate* isolate) const { return Local<T>::New(isolate, this); } template <class S> V8_INLINE bool operator==(const PersistentBase<S>& that) const { return internal::HandleHelper::EqualHandles(this, that); } template <class S> V8_INLINE bool operator==(const Local<S>& that) const { return internal::HandleHelper::EqualHandles(this, that); } template <class S> V8_INLINE bool operator!=(const PersistentBase<S>& that) const { return !operator==(that); } template <class S> V8_INLINE bool operator!=(const Local<S>& that) const { return !operator==(that); } /* * Install a finalization callback on this object. * NOTE: There is no guarantee as to when or even if the callback is * invoked. The invocation is performed solely on a best effort basis. * As always, GC-based finalization should not be relied upon for any * critical form of resource management! * * The callback is supposed to reset the handle. No further V8 API may be * called in this callback. In case additional work involving V8 needs to be * done, a second callback can be scheduled using * WeakCallbackInfo<void>::SetSecondPassCallback. / template <typename P> V8_INLINE void SetWeak(P parameter, typename WeakCallbackInfo<P>::Callback callback, WeakCallbackType type); /** * Turns this handle into a weak phantom handle without finalization callback. * The handle will be reset automatically when the garbage collector detects * that the object is no longer reachable. / V8_INLINE void SetWeak(); template <typename P> V8_INLINE P ClearWeak(); // TODO(dcarney): remove this. V8_INLINE void ClearWeak() { ClearWeak<void>(); } /** * Annotates the strong handle with the given label, which is then used by the * heap snapshot generator as a name of the edge from the root to the handle. * The function does not take ownership of the label and assumes that the * label is valid as long as the handle is valid. / V8_INLINE void AnnotateStrongRetainer(const char label); /** Returns true if the handle's reference is weak. / V8_INLINE bool IsWeak() const; /* * Assigns a wrapper class ID to the handle. / V8_INLINE void SetWrapperClassId(uint16_t class_id); /* * Returns the class ID previously assigned to this handle or 0 if no class ID * was previously assigned. / V8_INLINE uint16_t WrapperClassId() const; PersistentBase(const PersistentBase& other) = delete; void operator=(const PersistentBase&) = delete; private: friend class Isolate; friend class Utils; template <class F> friend class Local; template <class F1, class F2> friend class Persistent; template <class F> friend class Global; template <class F> friend class PersistentBase; template <class F> friend class ReturnValue; template <class F1, class F2, class F3> friend class PersistentValueMapBase; template <class F1, class F2> friend class PersistentValueVector; friend class Object; friend class internal::ValueHelper; V8_INLINE PersistentBase() = default; V8_INLINE explicit PersistentBase(internal::Address location) : IndirectHandleBase(location) {} V8_INLINE static internal::Address* New(Isolate* isolate, T* that); }; /** * Default traits for Persistent. This class does not allow * use of the copy constructor or assignment operator. * At present kResetInDestructor is not set, but that will change in a future * version. / template <class T> class NonCopyablePersistentTraits { public: using NonCopyablePersistent = Persistent<T, NonCopyablePersistentTraits<T>>; static const bool kResetInDestructor = false; template <class S, class M> V8_INLINE static void Copy(const Persistent<S, M>& source, NonCopyablePersistent dest) { static_assert(sizeof(S) < 0, "NonCopyablePersistentTraits::Copy is not instantiable"); } }; /** * Helper class traits to allow copying and assignment of Persistent. * This will clone the contents of storage cell, but not any of the flags, etc. / template <class T> struct CopyablePersistentTraits { using CopyablePersistent = Persistent<T, CopyablePersistentTraits<T>>; static const bool kResetInDestructor = true; template <class S, class M> static V8_INLINE void Copy(const Persistent<S, M>& source, CopyablePersistent dest) { // do nothing, just allow copy } }; /** * A PersistentBase which allows copy and assignment. * * Copy, assignment and destructor behavior is controlled by the traits * class M. * * CAVEAT: Persistent objects do not have proper destruction behavior by default * and as such will leak the object without explicit clear. Consider using * `v8::Global` instead which has proper destruction and move semantics. / template <class T, class M> class Persistent : public PersistentBase<T> { public: /* * A Persistent with no storage cell. / V8_INLINE Persistent() = default; /* * Construct a Persistent from a Local. * When the Local is non-empty, a new storage cell is created * pointing to the same object, and no flags are set. / template <class S> V8_INLINE Persistent(Isolate isolate, Local<S> that) : PersistentBase<T>( PersistentBase<T>::New(isolate, that.template value<S>())) { static_assert(std::is_base_of<T, S>::value, "type check"); } /** * Construct a Persistent from a Persistent. * When the Persistent is non-empty, a new storage cell is created * pointing to the same object, and no flags are set. / template <class S, class M2> V8_INLINE Persistent(Isolate isolate, const Persistent<S, M2>& that) : PersistentBase<T>( PersistentBase<T>::New(isolate, that.template value<S>())) { static_assert(std::is_base_of<T, S>::value, "type check"); } /** * The copy constructors and assignment operator create a Persistent * exactly as the Persistent constructor, but the Copy function from the * traits class is called, allowing the setting of flags based on the * copied Persistent. / V8_INLINE Persistent(const Persistent& that) : PersistentBase<T>() { Copy(that); } template <class S, class M2> V8_INLINE Persistent(const Persistent<S, M2>& that) : PersistentBase<T>() { Copy(that); } V8_INLINE Persistent& operator=(const Persistent& that) { Copy(that); return this; } template <class S, class M2> V8_INLINE Persistent& operator=(const Persistent<S, M2>& that) { Copy(that); return this; } /* * The destructor will dispose the Persistent based on the * kResetInDestructor flags in the traits class. Since not calling dispose * can result in a memory leak, it is recommended to always set this flag. / V8_INLINE ~Persistent() { if (M::kResetInDestructor) this->Reset(); } // TODO(dcarney): this is pretty useless, fix or remove template <class S, class M2> V8_INLINE static Persistent<T, M>& Cast(const Persistent<S, M2>& that) { #ifdef V8_ENABLE_CHECKS // If we're going to perform the type check then we have to check // that the handle isn't empty before doing the checked cast. if (!that.IsEmpty()) T::Cast(that.template value<S>()); #endif return reinterpret_cast<Persistent<T, M>&>( const_cast<Persistent<S, M2>&>(that)); } // TODO(dcarney): this is pretty useless, fix or remove template <class S, class M2> V8_INLINE Persistent<S, M2>& As() const { return Persistent<S, M2>::Cast(this); } private: friend class Isolate; friend class Utils; template <class F> friend class Local; template <class F1, class F2> friend class Persistent; template <class F> friend class ReturnValue; template <class S, class M2> V8_INLINE void Copy(const Persistent<S, M2>& that); }; /** * A PersistentBase which has move semantics. * * Note: Persistent class hierarchy is subject to future changes. / template <class T> class Global : public PersistentBase<T> { public: /* * A Global with no storage cell. / V8_INLINE Global() = default; /* * Construct a Global from a Local. * When the Local is non-empty, a new storage cell is created * pointing to the same object, and no flags are set. / template <class S> V8_INLINE Global(Isolate isolate, Local<S> that) : PersistentBase<T>( PersistentBase<T>::New(isolate, that.template value<S>())) { static_assert(std::is_base_of<T, S>::value, "type check"); } /** * Construct a Global from a PersistentBase. * When the Persistent is non-empty, a new storage cell is created * pointing to the same object, and no flags are set. / template <class S> V8_INLINE Global(Isolate isolate, const PersistentBase<S>& that) : PersistentBase<T>( PersistentBase<T>::New(isolate, that.template value<S>())) { static_assert(std::is_base_of<T, S>::value, "type check"); } /** * Move constructor. / V8_INLINE Global(Global&& other); V8_INLINE ~Global() { this->Reset(); } /* * Move via assignment. / template <class S> V8_INLINE Global& operator=(Global<S>&& rhs); /* * Pass allows returning uniques from functions, etc. / Global Pass() { return static_cast<Global&&>(this); } /* * For compatibility with Chromium's base::Bind (base::Passed). / using MoveOnlyTypeForCPP03 = void; Global(const Global&) = delete; void operator=(const Global&) = delete; private: template <class F> friend class ReturnValue; }; // UniquePersistent is an alias for Global for historical reason. template <class T> using UniquePersistent = Global<T>; /* * Interface for iterating through all the persistent handles in the heap. / class V8_EXPORT PersistentHandleVisitor { public: virtual ~PersistentHandleVisitor() = default; virtual void VisitPersistentHandle(Persistent<Value> value, uint16_t class_id) {} }; template <class T> internal::Address* PersistentBase<T>::New(Isolate* isolate, T* that) { if (internal::ValueHelper::IsEmpty(that)) return nullptr; return api_internal::GlobalizeReference( reinterpret_cast<internal::Isolate>(isolate), internal::ValueHelper::ValueAsAddress(that)); } template <class T, class M> template <class S, class M2> void Persistent<T, M>::Copy(const Persistent<S, M2>& that) { static_assert(std::is_base_of<T, S>::value, "type check"); this->Reset(); if (that.IsEmpty()) return; this->slot() = api_internal::CopyGlobalReference(that.slot()); M::Copy(that, this); } template <class T> bool PersistentBase<T>::IsWeak() const { using I = internal::Internals; if (this->IsEmpty()) return false; return I::GetNodeState(this->slot()) == I::kNodeStateIsWeakValue; } template <class T> void PersistentBase<T>::Reset() { if (this->IsEmpty()) return; api_internal::DisposeGlobal(this->slot()); this->Clear(); } /* * If non-empty, destroy the underlying storage cell * and create a new one with the contents of other if other is non empty / template <class T> template <class S> void PersistentBase<T>::Reset(Isolate isolate, const Local<S>& other) { static_assert(std::is_base_of<T, S>::value, "type check"); Reset(); if (other.IsEmpty()) return; this->slot() = New(isolate, other); } /* * If non-empty, destroy the underlying storage cell * and create a new one with the contents of other if other is non empty / template <class T> template <class S> void PersistentBase<T>::Reset(Isolate isolate, const PersistentBase<S>& other) { static_assert(std::is_base_of<T, S>::value, "type check"); Reset(); if (other.IsEmpty()) return; this->slot() = New(isolate, other.template value<S>()); } template <class T> template <typename P> V8_INLINE void PersistentBase<T>::SetWeak( P* parameter, typename WeakCallbackInfo<P>::Callback callback, WeakCallbackType type) { using Callback = WeakCallbackInfo<void>::Callback; #if (__GNUC__ >= 8) && !defined(__clang__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wcast-function-type" #endif api_internal::MakeWeak(this->slot(), parameter, reinterpret_cast<Callback>(callback), type); #if (__GNUC__ >= 8) && !defined(__clang__) #pragma GCC diagnostic pop #endif } template <class T> void PersistentBase<T>::SetWeak() { api_internal::MakeWeak(&this->slot()); } template <class T> template <typename P> P* PersistentBase<T>::ClearWeak() { return reinterpret_cast<P>(api_internal::ClearWeak(this->slot())); } template <class T> void PersistentBase<T>::AnnotateStrongRetainer(const char label) { api_internal::AnnotateStrongRetainer(this->slot(), label); } template <class T> void PersistentBase<T>::SetWrapperClassId(uint16_t class_id) { using I = internal::Internals; if (this->IsEmpty()) return; uint8_t* addr = reinterpret_cast<uint8_t>(slot()) + I::kNodeClassIdOffset; reinterpret_cast<uint16_t>(addr) = class_id; } template <class T> uint16_t PersistentBase<T>::WrapperClassId() const { using I = internal::Internals; if (this->IsEmpty()) return 0; uint8_t addr = reinterpret_cast<uint8_t>(slot()) + I::kNodeClassIdOffset; return reinterpret_cast<uint16_t>(addr); } template <class T> Global<T>::Global(Global&& other) : PersistentBase<T>(other.slot()) { if (!other.IsEmpty()) { api_internal::MoveGlobalReference(&other.slot(), &this->slot()); other.Clear(); } } template <class T> template <class S> Global<T>& Global<T>::operator=(Global<S>&& rhs) { static_assert(std::is_base_of<T, S>::value, "type check"); if (this != &rhs) { this->Reset(); if (!rhs.IsEmpty()) { this->slot() = rhs.slot(); api_internal::MoveGlobalReference(&rhs.slot(), &this->slot()); rhs.Clear(); } } return this; } } // namespace v8 #endif // INCLUDE_V8_PERSISTENT_HANDLE_H_	17.66 KB	2025-03-03 12:36
📄 v8-platform.h // Copyright 2013 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. #ifndef V8_V8_PLATFORM_H_ #define V8_V8_PLATFORM_H_ #include <math.h> #include <stddef.h> #include <stdint.h> #include <stdlib.h> // For abort. #include <memory> #include <string> #include "v8-source-location.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Isolate; // Valid priorities supported by the task scheduling infrastructure. enum class TaskPriority : uint8_t { /** * Best effort tasks are not critical for performance of the application. The * platform implementation should preempt such tasks if higher priority tasks * arrive. / kBestEffort, /* * User visible tasks are long running background tasks that will * improve performance and memory usage of the application upon completion. * Example: background compilation and garbage collection. / kUserVisible, /* * User blocking tasks are highest priority tasks that block the execution * thread (e.g. major garbage collection). They must be finished as soon as * possible. / kUserBlocking, kMaxPriority = kUserBlocking }; /* * A Task represents a unit of work. / class Task { public: virtual ~Task() = default; virtual void Run() = 0; }; /* * An IdleTask represents a unit of work to be performed in idle time. * The Run method is invoked with an argument that specifies the deadline in * seconds returned by MonotonicallyIncreasingTime(). * The idle task is expected to complete by this deadline. / class IdleTask { public: virtual ~IdleTask() = default; virtual void Run(double deadline_in_seconds) = 0; }; /* * A TaskRunner allows scheduling of tasks. The TaskRunner may still be used to * post tasks after the isolate gets destructed, but these tasks may not get * executed anymore. All tasks posted to a given TaskRunner will be invoked in * sequence. Tasks can be posted from any thread. / class TaskRunner { public: /* * Schedules a task to be invoked by this TaskRunner. The TaskRunner * implementation takes ownership of \|task\|. * * Embedders should override PostTaskImpl instead of this. / virtual void PostTask(std::unique_ptr<Task> task) { PostTaskImpl(std::move(task), SourceLocation::Current()); } /* * Schedules a task to be invoked by this TaskRunner. The TaskRunner * implementation takes ownership of \|task\|. The \|task\| cannot be nested * within other task executions. * * Tasks which shouldn't be interleaved with JS execution must be posted with * \|PostNonNestableTask\| or \|PostNonNestableDelayedTask\|. This is because the * embedder may process tasks in a callback which is called during JS * execution. * * In particular, tasks which execute JS must be non-nestable, since JS * execution is not allowed to nest. * * Requires that \|TaskRunner::NonNestableTasksEnabled()\| is true. * * Embedders should override PostNonNestableTaskImpl instead of this. / virtual void PostNonNestableTask(std::unique_ptr<Task> task) { PostNonNestableTaskImpl(std::move(task), SourceLocation::Current()); } /* * Schedules a task to be invoked by this TaskRunner. The task is scheduled * after the given number of seconds \|delay_in_seconds\|. The TaskRunner * implementation takes ownership of \|task\|. * * Embedders should override PostDelayedTaskImpl instead of this. / virtual void PostDelayedTask(std::unique_ptr<Task> task, double delay_in_seconds) { PostDelayedTaskImpl(std::move(task), delay_in_seconds, SourceLocation::Current()); } /* * Schedules a task to be invoked by this TaskRunner. The task is scheduled * after the given number of seconds \|delay_in_seconds\|. The TaskRunner * implementation takes ownership of \|task\|. The \|task\| cannot be nested * within other task executions. * * Tasks which shouldn't be interleaved with JS execution must be posted with * \|PostNonNestableTask\| or \|PostNonNestableDelayedTask\|. This is because the * embedder may process tasks in a callback which is called during JS * execution. * * In particular, tasks which execute JS must be non-nestable, since JS * execution is not allowed to nest. * * Requires that \|TaskRunner::NonNestableDelayedTasksEnabled()\| is true. * * Embedders should override PostNonNestableDelayedTaskImpl instead of this. / virtual void PostNonNestableDelayedTask(std::unique_ptr<Task> task, double delay_in_seconds) { PostNonNestableDelayedTaskImpl(std::move(task), delay_in_seconds, SourceLocation::Current()); } /* * Schedules an idle task to be invoked by this TaskRunner. The task is * scheduled when the embedder is idle. Requires that * \|TaskRunner::IdleTasksEnabled()\| is true. Idle tasks may be reordered * relative to other task types and may be starved for an arbitrarily long * time if no idle time is available. The TaskRunner implementation takes * ownership of \|task\|. * * Embedders should override PostIdleTaskImpl instead of this. / virtual void PostIdleTask(std::unique_ptr<IdleTask> task) { PostIdleTaskImpl(std::move(task), SourceLocation::Current()); } /* * Returns true if idle tasks are enabled for this TaskRunner. / virtual bool IdleTasksEnabled() = 0; /* * Returns true if non-nestable tasks are enabled for this TaskRunner. / virtual bool NonNestableTasksEnabled() const { return false; } /* * Returns true if non-nestable delayed tasks are enabled for this TaskRunner. / virtual bool NonNestableDelayedTasksEnabled() const { return false; } TaskRunner() = default; virtual ~TaskRunner() = default; TaskRunner(const TaskRunner&) = delete; TaskRunner& operator=(const TaskRunner&) = delete; protected: /* * Implementation of above methods with an additional `location` argument. / virtual void PostTaskImpl(std::unique_ptr<Task> task, const SourceLocation& location) {} virtual void PostNonNestableTaskImpl(std::unique_ptr<Task> task, const SourceLocation& location) {} virtual void PostDelayedTaskImpl(std::unique_ptr<Task> task, double delay_in_seconds, const SourceLocation& location) {} virtual void PostNonNestableDelayedTaskImpl(std::unique_ptr<Task> task, double delay_in_seconds, const SourceLocation& location) {} virtual void PostIdleTaskImpl(std::unique_ptr<IdleTask> task, const SourceLocation& location) {} }; /* * Delegate that's passed to Job's worker task, providing an entry point to * communicate with the scheduler. / class JobDelegate { public: /* * Returns true if this thread must return from the worker task on the * current thread ASAP. Workers should periodically invoke ShouldYield (or * YieldIfNeeded()) as often as is reasonable. * After this method returned true, ShouldYield must not be called again. / virtual bool ShouldYield() = 0; /* * Notifies the scheduler that max concurrency was increased, and the number * of worker should be adjusted accordingly. See Platform::PostJob() for more * details. / virtual void NotifyConcurrencyIncrease() = 0; /* * Returns a task_id unique among threads currently running this job, such * that GetTaskId() < worker count. To achieve this, the same task_id may be * reused by a different thread after a worker_task returns. / virtual uint8_t GetTaskId() = 0; /* * Returns true if the current task is called from the thread currently * running JobHandle::Join(). / virtual bool IsJoiningThread() const = 0; }; /* * Handle returned when posting a Job. Provides methods to control execution of * the posted Job. / class JobHandle { public: virtual ~JobHandle() = default; /* * Notifies the scheduler that max concurrency was increased, and the number * of worker should be adjusted accordingly. See Platform::PostJob() for more * details. / virtual void NotifyConcurrencyIncrease() = 0; /* * Contributes to the job on this thread. Doesn't return until all tasks have * completed and max concurrency becomes 0. When Join() is called and max * concurrency reaches 0, it should not increase again. This also promotes * this Job's priority to be at least as high as the calling thread's * priority. / virtual void Join() = 0; /* * Forces all existing workers to yield ASAP. Waits until they have all * returned from the Job's callback before returning. / virtual void Cancel() = 0; / * Forces all existing workers to yield ASAP but doesn’t wait for them. * Warning, this is dangerous if the Job's callback is bound to or has access * to state which may be deleted after this call. / virtual void CancelAndDetach() = 0; /* * Returns true if there's any work pending or any worker running. / virtual bool IsActive() = 0; /* * Returns true if associated with a Job and other methods may be called. * Returns false after Join() or Cancel() was called. This may return true * even if no workers are running and IsCompleted() returns true / virtual bool IsValid() = 0; /* * Returns true if job priority can be changed. / virtual bool UpdatePriorityEnabled() const { return false; } /* * Update this Job's priority. / virtual void UpdatePriority(TaskPriority new_priority) {} }; /* * A JobTask represents work to run in parallel from Platform::PostJob(). / class JobTask { public: virtual ~JobTask() = default; virtual void Run(JobDelegate delegate) = 0; /** * Controls the maximum number of threads calling Run() concurrently, given * the number of threads currently assigned to this job and executing Run(). * Run() is only invoked if the number of threads previously running Run() was * less than the value returned. In general, this should return the latest * number of incomplete work items (smallest unit of work) left to process, * including items that are currently in progress. \|worker_count\| is the * number of threads currently assigned to this job which some callers may * need to determine their return value. Since GetMaxConcurrency() is a leaf * function, it must not call back any JobHandle methods. / virtual size_t GetMaxConcurrency(size_t worker_count) const = 0; }; /* * A "blocking call" refers to any call that causes the calling thread to wait * off-CPU. It includes but is not limited to calls that wait on synchronous * file I/O operations: read or write a file from disk, interact with a pipe or * a socket, rename or delete a file, enumerate files in a directory, etc. * Acquiring a low contention lock is not considered a blocking call. / /* * BlockingType indicates the likelihood that a blocking call will actually * block. / enum class BlockingType { // The call might block (e.g. file I/O that might hit in memory cache). kMayBlock, // The call will definitely block (e.g. cache already checked and now pinging // server synchronously). kWillBlock }; /* * This class is instantiated with CreateBlockingScope() in every scope where a * blocking call is made and serves as a precise annotation of the scope that * may/will block. May be implemented by an embedder to adjust the thread count. * CPU usage should be minimal within that scope. ScopedBlockingCalls can be * nested. / class ScopedBlockingCall { public: virtual ~ScopedBlockingCall() = default; }; /* * The interface represents complex arguments to trace events. / class ConvertableToTraceFormat { public: virtual ~ConvertableToTraceFormat() = default; /* * Append the class info to the provided \|out\| string. The appended * data must be a valid JSON object. Strings must be properly quoted, and * escaped. There is no processing applied to the content after it is * appended. / virtual void AppendAsTraceFormat(std::string out) const = 0; }; /** * V8 Tracing controller. * * Can be implemented by an embedder to record trace events from V8. * * Will become obsolete in Perfetto SDK build (v8_use_perfetto = true). / class TracingController { public: virtual ~TracingController() = default; // In Perfetto mode, trace events are written using Perfetto's Track Event // API directly without going through the embedder. However, it is still // possible to observe tracing being enabled and disabled. #if !defined(V8_USE_PERFETTO) /* * Called by TRACE_EVENT* macros, don't call this directly. * The name parameter is a category group for example: * TRACE_EVENT0("v8,parse", "V8.Parse") * The pointer returned points to a value with zero or more of the bits * defined in CategoryGroupEnabledFlags. */ virtual const uint8_t GetCategoryGroupEnabled(const char* name) { static uint8_t no = 0; return &no; } /** * Adds a trace event to the platform tracing system. These function calls are * usually the result of a TRACE_* macro from trace_event_common.h when * tracing and the category of the particular trace are enabled. It is not * advisable to call these functions on their own; they are really only meant * to be used by the trace macros. The returned handle can be used by * UpdateTraceEventDuration to update the duration of COMPLETE events. / virtual uint64_t AddTraceEvent( char phase, const uint8_t category_enabled_flag, const char* name, const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args, const char** arg_names, const uint8_t* arg_types, const uint64_t* arg_values, std::unique_ptr<ConvertableToTraceFormat>* arg_convertables, unsigned int flags) { return 0; } virtual uint64_t AddTraceEventWithTimestamp( char phase, const uint8_t* category_enabled_flag, const char* name, const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args, const char** arg_names, const uint8_t* arg_types, const uint64_t* arg_values, std::unique_ptr<ConvertableToTraceFormat>* arg_convertables, unsigned int flags, int64_t timestamp) { return 0; } /** * Sets the duration field of a COMPLETE trace event. It must be called with * the handle returned from AddTraceEvent(). */ virtual void UpdateTraceEventDuration(const uint8_t category_enabled_flag, const char* name, uint64_t handle) {} #endif // !defined(V8_USE_PERFETTO) class TraceStateObserver { public: virtual ~TraceStateObserver() = default; virtual void OnTraceEnabled() = 0; virtual void OnTraceDisabled() = 0; }; /** * Adds tracing state change observer. * Does nothing in Perfetto SDK build (v8_use_perfetto = true). / virtual void AddTraceStateObserver(TraceStateObserver) {} /** * Removes tracing state change observer. * Does nothing in Perfetto SDK build (v8_use_perfetto = true). / virtual void RemoveTraceStateObserver(TraceStateObserver) {} }; /** * A V8 memory page allocator. * * Can be implemented by an embedder to manage large host OS allocations. / class PageAllocator { public: virtual ~PageAllocator() = default; /* * Gets the page granularity for AllocatePages and FreePages. Addresses and * lengths for those calls should be multiples of AllocatePageSize(). / virtual size_t AllocatePageSize() = 0; /* * Gets the page granularity for SetPermissions and ReleasePages. Addresses * and lengths for those calls should be multiples of CommitPageSize(). / virtual size_t CommitPageSize() = 0; /* * Sets the random seed so that GetRandomMmapAddr() will generate repeatable * sequences of random mmap addresses. / virtual void SetRandomMmapSeed(int64_t seed) = 0; /* * Returns a randomized address, suitable for memory allocation under ASLR. * The address will be aligned to AllocatePageSize. / virtual void GetRandomMmapAddr() = 0; /** * Memory permissions. / enum Permission { kNoAccess, kRead, kReadWrite, kReadWriteExecute, kReadExecute, // Set this when reserving memory that will later require kReadWriteExecute // permissions. The resulting behavior is platform-specific, currently // this is used to set the MAP_JIT flag on Apple Silicon. // TODO(jkummerow): Remove this when Wasm has a platform-independent // w^x implementation. // TODO(saelo): Remove this once all JIT pages are allocated through the // VirtualAddressSpace API. kNoAccessWillJitLater }; /* * Allocates memory in range with the given alignment and permission. / virtual void AllocatePages(void* address, size_t length, size_t alignment, Permission permissions) = 0; /** * Frees memory in a range that was allocated by a call to AllocatePages. / virtual bool FreePages(void address, size_t length) = 0; /** * Releases memory in a range that was allocated by a call to AllocatePages. / virtual bool ReleasePages(void address, size_t length, size_t new_length) = 0; /** * Sets permissions on pages in an allocated range. / virtual bool SetPermissions(void address, size_t length, Permission permissions) = 0; /** * Recommits discarded pages in the given range with given permissions. * Discarded pages must be recommitted with their original permissions * before they are used again. / virtual bool RecommitPages(void address, size_t length, Permission permissions) { // TODO(v8:12797): make it pure once it's implemented on Chromium side. return false; } /** * Frees memory in the given [address, address + size) range. address and size * should be operating system page-aligned. The next write to this * memory area brings the memory transparently back. This should be treated as * a hint to the OS that the pages are no longer needed. It does not guarantee * that the pages will be discarded immediately or at all. / virtual bool DiscardSystemPages(void address, size_t size) { return true; } /** * Decommits any wired memory pages in the given range, allowing the OS to * reclaim them, and marks the region as inacessible (kNoAccess). The address * range stays reserved and can be accessed again later by changing its * permissions. However, in that case the memory content is guaranteed to be * zero-initialized again. The memory must have been previously allocated by a * call to AllocatePages. Returns true on success, false otherwise. / virtual bool DecommitPages(void address, size_t size) = 0; /** * INTERNAL ONLY: This interface has not been stabilised and may change * without notice from one release to another without being deprecated first. / class SharedMemoryMapping { public: // Implementations are expected to free the shared memory mapping in the // destructor. virtual ~SharedMemoryMapping() = default; virtual void GetMemory() const = 0; }; /** * INTERNAL ONLY: This interface has not been stabilised and may change * without notice from one release to another without being deprecated first. / class SharedMemory { public: // Implementations are expected to free the shared memory in the destructor. virtual ~SharedMemory() = default; virtual std::unique_ptr<SharedMemoryMapping> RemapTo( void new_address) const = 0; virtual void* GetMemory() const = 0; virtual size_t GetSize() const = 0; }; /** * INTERNAL ONLY: This interface has not been stabilised and may change * without notice from one release to another without being deprecated first. * * Reserve pages at a fixed address returning whether the reservation is * possible. The reserved memory is detached from the PageAllocator and so * should not be freed by it. It's intended for use with * SharedMemory::RemapTo, where ~SharedMemoryMapping would free the memory. / virtual bool ReserveForSharedMemoryMapping(void address, size_t size) { return false; } /** * INTERNAL ONLY: This interface has not been stabilised and may change * without notice from one release to another without being deprecated first. * * Allocates shared memory pages. Not all PageAllocators need support this and * so this method need not be overridden. * Allocates a new read-only shared memory region of size \|length\| and copies * the memory at \|original_address\| into it. / virtual std::unique_ptr<SharedMemory> AllocateSharedPages( size_t length, const void original_address) { return {}; } /** * INTERNAL ONLY: This interface has not been stabilised and may change * without notice from one release to another without being deprecated first. * * If not overridden and changed to return true, V8 will not attempt to call * AllocateSharedPages or RemapSharedPages. If overridden, AllocateSharedPages * and RemapSharedPages must also be overridden. / virtual bool CanAllocateSharedPages() { return false; } }; /* * An allocator that uses per-thread permissions to protect the memory. * * The implementation is platform/hardware specific, e.g. using pkeys on x64. * * INTERNAL ONLY: This interface has not been stabilised and may change * without notice from one release to another without being deprecated first. / class ThreadIsolatedAllocator { public: virtual ~ThreadIsolatedAllocator() = default; virtual void Allocate(size_t size) = 0; virtual void Free(void* object) = 0; enum class Type { kPkey, }; virtual Type Type() const = 0; /** * Return the pkey used to implement the thread isolation if Type == kPkey. / virtual int Pkey() const { return -1; } /* * Per-thread permissions can be reset on signal handler entry. Even reading * ThreadIsolated memory will segfault in that case. * Call this function on signal handler entry to ensure that read permissions * are restored. / static void SetDefaultPermissionsForSignalHandler(); }; // Opaque type representing a handle to a shared memory region. using PlatformSharedMemoryHandle = intptr_t; static constexpr PlatformSharedMemoryHandle kInvalidSharedMemoryHandle = -1; // Conversion routines from the platform-dependent shared memory identifiers // into the opaque PlatformSharedMemoryHandle type. These use the underlying // types (e.g. unsigned int) instead of the typedef'd ones (e.g. mach_port_t) // to avoid pulling in large OS header files into this header file. Instead, // the users of these routines are expected to include the respecitve OS // headers in addition to this one. #if V8_OS_DARWIN // Convert between a shared memory handle and a mach_port_t referencing a memory // entry object. inline PlatformSharedMemoryHandle SharedMemoryHandleFromMachMemoryEntry( unsigned int port) { return static_cast<PlatformSharedMemoryHandle>(port); } inline unsigned int MachMemoryEntryFromSharedMemoryHandle( PlatformSharedMemoryHandle handle) { return static_cast<unsigned int>(handle); } #elif V8_OS_FUCHSIA // Convert between a shared memory handle and a zx_handle_t to a VMO. inline PlatformSharedMemoryHandle SharedMemoryHandleFromVMO(uint32_t handle) { return static_cast<PlatformSharedMemoryHandle>(handle); } inline uint32_t VMOFromSharedMemoryHandle(PlatformSharedMemoryHandle handle) { return static_cast<uint32_t>(handle); } #elif V8_OS_WIN // Convert between a shared memory handle and a Windows HANDLE to a file mapping // object. inline PlatformSharedMemoryHandle SharedMemoryHandleFromFileMapping( void handle) { return reinterpret_cast<PlatformSharedMemoryHandle>(handle); } inline void* FileMappingFromSharedMemoryHandle( PlatformSharedMemoryHandle handle) { return reinterpret_cast<void>(handle); } #else // Convert between a shared memory handle and a file descriptor. inline PlatformSharedMemoryHandle SharedMemoryHandleFromFileDescriptor(int fd) { return static_cast<PlatformSharedMemoryHandle>(fd); } inline int FileDescriptorFromSharedMemoryHandle( PlatformSharedMemoryHandle handle) { return static_cast<int>(handle); } #endif /* * Possible permissions for memory pages. / enum class PagePermissions { kNoAccess, kRead, kReadWrite, kReadWriteExecute, kReadExecute, }; /* * Class to manage a virtual memory address space. * * This class represents a contiguous region of virtual address space in which * sub-spaces and (private or shared) memory pages can be allocated, freed, and * modified. This interface is meant to eventually replace the PageAllocator * interface, and can be used as an alternative in the meantime. * * This API is not yet stable and may change without notice! / class VirtualAddressSpace { public: using Address = uintptr_t; VirtualAddressSpace(size_t page_size, size_t allocation_granularity, Address base, size_t size, PagePermissions max_page_permissions) : page_size_(page_size), allocation_granularity_(allocation_granularity), base_(base), size_(size), max_page_permissions_(max_page_permissions) {} virtual ~VirtualAddressSpace() = default; /* * The page size used inside this space. Guaranteed to be a power of two. * Used as granularity for all page-related operations except for allocation, * which use the allocation_granularity(), see below. * * \returns the page size in bytes. / size_t page_size() const { return page_size_; } /* * The granularity of page allocations and, by extension, of subspace * allocations. This is guaranteed to be a power of two and a multiple of the * page_size(). In practice, this is equal to the page size on most OSes, but * on Windows it is usually 64KB, while the page size is 4KB. * * \returns the allocation granularity in bytes. / size_t allocation_granularity() const { return allocation_granularity_; } /* * The base address of the address space managed by this instance. * * \returns the base address of this address space. / Address base() const { return base_; } /* * The size of the address space managed by this instance. * * \returns the size of this address space in bytes. / size_t size() const { return size_; } /* * The maximum page permissions that pages allocated inside this space can * obtain. * * \returns the maximum page permissions. / PagePermissions max_page_permissions() const { return max_page_permissions_; } /* * Whether the \|address\| is inside the address space managed by this instance. * * \returns true if it is inside the address space, false if not. / bool Contains(Address address) const { return (address >= base()) && (address < base() + size()); } /* * Sets the random seed so that GetRandomPageAddress() will generate * repeatable sequences of random addresses. * * \param The seed for the PRNG. / virtual void SetRandomSeed(int64_t seed) = 0; /* * Returns a random address inside this address space, suitable for page * allocations hints. * * \returns a random address aligned to allocation_granularity(). / virtual Address RandomPageAddress() = 0; /* * Allocates private memory pages with the given alignment and permissions. * * \param hint If nonzero, the allocation is attempted to be placed at the * given address first. If that fails, the allocation is attempted to be * placed elsewhere, possibly nearby, but that is not guaranteed. Specifying * zero for the hint always causes this function to choose a random address. * The hint, if specified, must be aligned to the specified alignment. * * \param size The size of the allocation in bytes. Must be a multiple of the * allocation_granularity(). * * \param alignment The alignment of the allocation in bytes. Must be a * multiple of the allocation_granularity() and should be a power of two. * * \param permissions The page permissions of the newly allocated pages. * * \returns the start address of the allocated pages on success, zero on * failure. / static constexpr Address kNoHint = 0; virtual V8_WARN_UNUSED_RESULT Address AllocatePages(Address hint, size_t size, size_t alignment, PagePermissions permissions) = 0; /* * Frees previously allocated pages. * * This function will terminate the process on failure as this implies a bug * in the client. As such, there is no return value. * * \param address The start address of the pages to free. This address must * have been obtained through a call to AllocatePages. * * \param size The size in bytes of the region to free. This must match the * size passed to AllocatePages when the pages were allocated. / virtual void FreePages(Address address, size_t size) = 0; /* * Sets permissions of all allocated pages in the given range. * * This operation can fail due to OOM, in which case false is returned. If * the operation fails for a reason other than OOM, this function will * terminate the process as this implies a bug in the client. * * \param address The start address of the range. Must be aligned to * page_size(). * * \param size The size in bytes of the range. Must be a multiple * of page_size(). * * \param permissions The new permissions for the range. * * \returns true on success, false on OOM. / virtual V8_WARN_UNUSED_RESULT bool SetPagePermissions( Address address, size_t size, PagePermissions permissions) = 0; /* * Creates a guard region at the specified address. * * Guard regions are guaranteed to cause a fault when accessed and generally * do not count towards any memory consumption limits. Further, allocating * guard regions can usually not fail in subspaces if the region does not * overlap with another region, subspace, or page allocation. * * \param address The start address of the guard region. Must be aligned to * the allocation_granularity(). * * \param size The size of the guard region in bytes. Must be a multiple of * the allocation_granularity(). * * \returns true on success, false otherwise. / virtual V8_WARN_UNUSED_RESULT bool AllocateGuardRegion(Address address, size_t size) = 0; /* * Frees an existing guard region. * * This function will terminate the process on failure as this implies a bug * in the client. As such, there is no return value. * * \param address The start address of the guard region to free. This address * must have previously been used as address parameter in a successful * invocation of AllocateGuardRegion. * * \param size The size in bytes of the guard region to free. This must match * the size passed to AllocateGuardRegion when the region was created. / virtual void FreeGuardRegion(Address address, size_t size) = 0; /* * Allocates shared memory pages with the given permissions. * * \param hint Placement hint. See AllocatePages. * * \param size The size of the allocation in bytes. Must be a multiple of the * allocation_granularity(). * * \param permissions The page permissions of the newly allocated pages. * * \param handle A platform-specific handle to a shared memory object. See * the SharedMemoryHandleFromX routines above for ways to obtain these. * * \param offset The offset in the shared memory object at which the mapping * should start. Must be a multiple of the allocation_granularity(). * * \returns the start address of the allocated pages on success, zero on * failure. / virtual V8_WARN_UNUSED_RESULT Address AllocateSharedPages(Address hint, size_t size, PagePermissions permissions, PlatformSharedMemoryHandle handle, uint64_t offset) = 0; /* * Frees previously allocated shared pages. * * This function will terminate the process on failure as this implies a bug * in the client. As such, there is no return value. * * \param address The start address of the pages to free. This address must * have been obtained through a call to AllocateSharedPages. * * \param size The size in bytes of the region to free. This must match the * size passed to AllocateSharedPages when the pages were allocated. / virtual void FreeSharedPages(Address address, size_t size) = 0; /* * Whether this instance can allocate subspaces or not. * * \returns true if subspaces can be allocated, false if not. / virtual bool CanAllocateSubspaces() = 0; / * Allocate a subspace. * * The address space of a subspace stays reserved in the parent space for the * lifetime of the subspace. As such, it is guaranteed that page allocations * on the parent space cannot end up inside a subspace. * * \param hint Hints where the subspace should be allocated. See * AllocatePages() for more details. * * \param size The size in bytes of the subspace. Must be a multiple of the * allocation_granularity(). * * \param alignment The alignment of the subspace in bytes. Must be a multiple * of the allocation_granularity() and should be a power of two. * * \param max_page_permissions The maximum permissions that pages allocated in * the subspace can obtain. * * \returns a new subspace or nullptr on failure. / virtual std::unique_ptr<VirtualAddressSpace> AllocateSubspace( Address hint, size_t size, size_t alignment, PagePermissions max_page_permissions) = 0; // // TODO(v8) maybe refactor the methods below before stabilizing the API. For // example by combining them into some form of page operation method that // takes a command enum as parameter. // /* * Recommits discarded pages in the given range with given permissions. * Discarded pages must be recommitted with their original permissions * before they are used again. * * \param address The start address of the range. Must be aligned to * page_size(). * * \param size The size in bytes of the range. Must be a multiple * of page_size(). * * \param permissions The permissions for the range that the pages must have. * * \returns true on success, false otherwise. / virtual V8_WARN_UNUSED_RESULT bool RecommitPages( Address address, size_t size, PagePermissions permissions) = 0; /* * Frees memory in the given [address, address + size) range. address and * size should be aligned to the page_size(). The next write to this memory * area brings the memory transparently back. This should be treated as a * hint to the OS that the pages are no longer needed. It does not guarantee * that the pages will be discarded immediately or at all. * * \returns true on success, false otherwise. Since this method is only a * hint, a successful invocation does not imply that pages have been removed. / virtual V8_WARN_UNUSED_RESULT bool DiscardSystemPages(Address address, size_t size) { return true; } /* * Decommits any wired memory pages in the given range, allowing the OS to * reclaim them, and marks the region as inacessible (kNoAccess). The address * range stays reserved and can be accessed again later by changing its * permissions. However, in that case the memory content is guaranteed to be * zero-initialized again. The memory must have been previously allocated by a * call to AllocatePages. * * \returns true on success, false otherwise. / virtual V8_WARN_UNUSED_RESULT bool DecommitPages(Address address, size_t size) = 0; private: const size_t page_size_; const size_t allocation_granularity_; const Address base_; const size_t size_; const PagePermissions max_page_permissions_; }; /* * V8 Allocator used for allocating zone backings. / class ZoneBackingAllocator { public: using MallocFn = void ()(size_t); using FreeFn = void ()(void); virtual MallocFn GetMallocFn() const { return ::malloc; } virtual FreeFn GetFreeFn() const { return ::free; } }; /* * Observer used by V8 to notify the embedder about entering/leaving sections * with high throughput of malloc/free operations. / class HighAllocationThroughputObserver { public: virtual void EnterSection() {} virtual void LeaveSection() {} }; /* * V8 Platform abstraction layer. * * The embedder has to provide an implementation of this interface before * initializing the rest of V8. / class Platform { public: virtual ~Platform() = default; /* * Allows the embedder to manage memory page allocations. * Returning nullptr will cause V8 to use the default page allocator. / virtual PageAllocator GetPageAllocator() = 0; /** * Allows the embedder to provide an allocator that uses per-thread memory * permissions to protect allocations. * Returning nullptr will cause V8 to disable protections that rely on this * feature. / virtual ThreadIsolatedAllocator GetThreadIsolatedAllocator() { return nullptr; } /** * Allows the embedder to specify a custom allocator used for zones. / virtual ZoneBackingAllocator GetZoneBackingAllocator() { static ZoneBackingAllocator default_allocator; return &default_allocator; } /** * Enables the embedder to respond in cases where V8 can't allocate large * blocks of memory. V8 retries the failed allocation once after calling this * method. On success, execution continues; otherwise V8 exits with a fatal * error. * Embedder overrides of this function must NOT call back into V8. / virtual void OnCriticalMemoryPressure() {} /* * Gets the max number of worker threads that may be used to execute * concurrent work scheduled for any single TaskPriority by * Call(BlockingTask)OnWorkerThread() or PostJob(). This can be used to * estimate the number of tasks a work package should be split into. A return * value of 0 means that there are no worker threads available. Note that a * value of 0 won't prohibit V8 from posting tasks using \|CallOnWorkerThread\|. / virtual int NumberOfWorkerThreads() = 0; /* * Returns a TaskRunner which can be used to post a task on the foreground. * The TaskRunner's NonNestableTasksEnabled() must be true. This function * should only be called from a foreground thread. * TODO(chromium:1448758): Deprecate once \|GetForegroundTaskRunner(Isolate, TaskPriority)\| is ready. / virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner( Isolate isolate) { return GetForegroundTaskRunner(isolate, TaskPriority::kUserBlocking); } /** * Returns a TaskRunner with a specific \|priority\| which can be used to post a * task on the foreground thread. The TaskRunner's NonNestableTasksEnabled() * must be true. This function should only be called from a foreground thread. * TODO(chromium:1448758): Make pure virtual once embedders implement it. / virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner( Isolate isolate, TaskPriority priority) { return nullptr; } /** * Schedules a task to be invoked on a worker thread. * Embedders should override PostTaskOnWorkerThreadImpl() instead of * CallOnWorkerThread(). / void CallOnWorkerThread( std::unique_ptr<Task> task, const SourceLocation& location = SourceLocation::Current()) { PostTaskOnWorkerThreadImpl(TaskPriority::kUserVisible, std::move(task), location); } /* * Schedules a task that blocks the main thread to be invoked with * high-priority on a worker thread. * Embedders should override PostTaskOnWorkerThreadImpl() instead of * CallBlockingTaskOnWorkerThread(). / void CallBlockingTaskOnWorkerThread( std::unique_ptr<Task> task, const SourceLocation& location = SourceLocation::Current()) { // Embedders may optionally override this to process these tasks in a high // priority pool. PostTaskOnWorkerThreadImpl(TaskPriority::kUserBlocking, std::move(task), location); } /* * Schedules a task to be invoked with low-priority on a worker thread. * Embedders should override PostTaskOnWorkerThreadImpl() instead of * CallLowPriorityTaskOnWorkerThread(). / void CallLowPriorityTaskOnWorkerThread( std::unique_ptr<Task> task, const SourceLocation& location = SourceLocation::Current()) { // Embedders may optionally override this to process these tasks in a low // priority pool. PostTaskOnWorkerThreadImpl(TaskPriority::kBestEffort, std::move(task), location); } /* * Schedules a task to be invoked on a worker thread after \|delay_in_seconds\| * expires. * Embedders should override PostDelayedTaskOnWorkerThreadImpl() instead of * CallDelayedOnWorkerThread(). / void CallDelayedOnWorkerThread( std::unique_ptr<Task> task, double delay_in_seconds, const SourceLocation& location = SourceLocation::Current()) { PostDelayedTaskOnWorkerThreadImpl(TaskPriority::kUserVisible, std::move(task), delay_in_seconds, location); } /* * Returns true if idle tasks are enabled for the given \|isolate\|. / virtual bool IdleTasksEnabled(Isolate isolate) { return false; } /** * Posts \|job_task\| to run in parallel. Returns a JobHandle associated with * the Job, which can be joined or canceled. * This avoids degenerate cases: * - Calling CallOnWorkerThread() for each work item, causing significant * overhead. * - Fixed number of CallOnWorkerThread() calls that split the work and might * run for a long time. This is problematic when many components post * "num cores" tasks and all expect to use all the cores. In these cases, * the scheduler lacks context to be fair to multiple same-priority requests * and/or ability to request lower priority work to yield when high priority * work comes in. * A canonical implementation of \|job_task\| looks like: * class MyJobTask : public JobTask { * public: * MyJobTask(...) : worker_queue_(...) {} * // JobTask: * void Run(JobDelegate* delegate) override { * while (!delegate->ShouldYield()) { * // Smallest unit of work. * auto work_item = worker_queue_.TakeWorkItem(); // Thread safe. * if (!work_item) return; * ProcessWork(work_item); * } * } * * size_t GetMaxConcurrency() const override { * return worker_queue_.GetSize(); // Thread safe. * } * }; * auto handle = PostJob(TaskPriority::kUserVisible, * std::make_unique<MyJobTask>(...)); * handle->Join(); * * PostJob() and methods of the returned JobHandle/JobDelegate, must never be * called while holding a lock that could be acquired by JobTask::Run or * JobTask::GetMaxConcurrency -- that could result in a deadlock. This is * because [1] JobTask::GetMaxConcurrency may be invoked while holding * internal lock (A), hence JobTask::GetMaxConcurrency can only use a lock (B) * if that lock is never held while calling back into JobHandle from any * thread (A=>B/B=>A deadlock) and [2] JobTask::Run or * JobTask::GetMaxConcurrency may be invoked synchronously from JobHandle * (B=>JobHandle::foo=>B deadlock). * Embedders should override CreateJobImpl() instead of PostJob(). / std::unique_ptr<JobHandle> PostJob( TaskPriority priority, std::unique_ptr<JobTask> job_task, const SourceLocation& location = SourceLocation::Current()) { auto handle = CreateJob(priority, std::move(job_task), location); handle->NotifyConcurrencyIncrease(); return handle; } /* * Creates and returns a JobHandle associated with a Job. Unlike PostJob(), * this doesn't immediately schedules \|worker_task\| to run; the Job is then * scheduled by calling either NotifyConcurrencyIncrease() or Join(). * * A sufficient CreateJob() implementation that uses the default Job provided * in libplatform looks like: * std::unique_ptr<JobHandle> CreateJob( * TaskPriority priority, std::unique_ptr<JobTask> job_task) override { * return v8::platform::NewDefaultJobHandle( * this, priority, std::move(job_task), NumberOfWorkerThreads()); * } * * Embedders should override CreateJobImpl() instead of CreateJob(). / std::unique_ptr<JobHandle> CreateJob( TaskPriority priority, std::unique_ptr<JobTask> job_task, const SourceLocation& location = SourceLocation::Current()) { return CreateJobImpl(priority, std::move(job_task), location); } /* * Instantiates a ScopedBlockingCall to annotate a scope that may/will block. / virtual std::unique_ptr<ScopedBlockingCall> CreateBlockingScope( BlockingType blocking_type) { return nullptr; } /* * Monotonically increasing time in seconds from an arbitrary fixed point in * the past. This function is expected to return at least * millisecond-precision values. For this reason, * it is recommended that the fixed point be no further in the past than * the epoch. / virtual double MonotonicallyIncreasingTime() = 0; / * Current wall-clock time in milliseconds since epoch. Use * CurrentClockTimeMillisHighResolution() when higher precision is * required. / virtual int64_t CurrentClockTimeMilliseconds() { return static_cast<int64_t>(floor(CurrentClockTimeMillis())); } /* * This function is deprecated and will be deleted. Use either * CurrentClockTimeMilliseconds() or * CurrentClockTimeMillisecondsHighResolution(). / virtual double CurrentClockTimeMillis() = 0; /* * Same as CurrentClockTimeMilliseconds(), but with more precision. / virtual double CurrentClockTimeMillisecondsHighResolution() { return CurrentClockTimeMillis(); } typedef void (StackTracePrinter)(); /** * Returns a function pointer that print a stack trace of the current stack * on invocation. Disables printing of the stack trace if nullptr. / virtual StackTracePrinter GetStackTracePrinter() { return nullptr; } /* * Returns an instance of a v8::TracingController. This must be non-nullptr. / virtual TracingController GetTracingController() = 0; /** * Tells the embedder to generate and upload a crashdump during an unexpected * but non-critical scenario. / virtual void DumpWithoutCrashing() {} /* * Allows the embedder to observe sections with high throughput allocation * operations. / virtual HighAllocationThroughputObserver GetHighAllocationThroughputObserver() { static HighAllocationThroughputObserver default_observer; return &default_observer; } protected: /** * Default implementation of current wall-clock time in milliseconds * since epoch. Useful for implementing \|CurrentClockTimeMillis\| if * nothing special needed. / V8_EXPORT static double SystemClockTimeMillis(); /* * Creates and returns a JobHandle associated with a Job. / virtual std::unique_ptr<JobHandle> CreateJobImpl( TaskPriority priority, std::unique_ptr<JobTask> job_task, const SourceLocation& location) = 0; /* * Schedules a task with \|priority\| to be invoked on a worker thread. / virtual void PostTaskOnWorkerThreadImpl(TaskPriority priority, std::unique_ptr<Task> task, const SourceLocation& location) = 0; /* * Schedules a task with \|priority\| to be invoked on a worker thread after * \|delay_in_seconds\| expires. */ virtual void PostDelayedTaskOnWorkerThreadImpl( TaskPriority priority, std::unique_ptr<Task> task, double delay_in_seconds, const SourceLocation& location) = 0; }; } // namespace v8 #endif // V8_V8_PLATFORM_H_	47.9 KB	2025-03-03 12:36
📄 v8-primitive-object.h // Copyright 2021 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. #ifndef INCLUDE_V8_PRIMITIVE_OBJECT_H_ #define INCLUDE_V8_PRIMITIVE_OBJECT_H_ #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Isolate; /** * A Number object (ECMA-262, 4.3.21). / class V8_EXPORT NumberObject : public Object { public: static Local<Value> New(Isolate isolate, double value); double ValueOf() const; V8_INLINE static NumberObject* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<NumberObject>(value); } private: static void CheckCast(Value obj); }; /** * A BigInt object (https://tc39.github.io/proposal-bigint) / class V8_EXPORT BigIntObject : public Object { public: static Local<Value> New(Isolate isolate, int64_t value); Local<BigInt> ValueOf() const; V8_INLINE static BigIntObject* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<BigIntObject>(value); } private: static void CheckCast(Value obj); }; /** * A Boolean object (ECMA-262, 4.3.15). / class V8_EXPORT BooleanObject : public Object { public: static Local<Value> New(Isolate isolate, bool value); bool ValueOf() const; V8_INLINE static BooleanObject* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<BooleanObject>(value); } private: static void CheckCast(Value obj); }; /** * A String object (ECMA-262, 4.3.18). / class V8_EXPORT StringObject : public Object { public: static Local<Value> New(Isolate isolate, Local<String> value); Local<String> ValueOf() const; V8_INLINE static StringObject* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<StringObject>(value); } private: static void CheckCast(Value obj); }; /** * A Symbol object (ECMA-262 edition 6). / class V8_EXPORT SymbolObject : public Object { public: static Local<Value> New(Isolate isolate, Local<Symbol> value); Local<Symbol> ValueOf() const; V8_INLINE static SymbolObject* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<SymbolObject>(value); } private: static void CheckCast(Value obj); }; } // namespace v8 #endif // INCLUDE_V8_PRIMITIVE_OBJECT_H_	2.53 KB	2025-03-03 12:36
📄 v8-primitive.h // Copyright 2021 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. #ifndef INCLUDE_V8_PRIMITIVE_H_ #define INCLUDE_V8_PRIMITIVE_H_ #include "v8-data.h" // NOLINT(build/include_directory) #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-value.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; class Isolate; class String; namespace internal { class ExternalString; class ScopedExternalStringLock; class StringForwardingTable; } // namespace internal /** * The superclass of primitive values. See ECMA-262 4.3.2. / class V8_EXPORT Primitive : public Value {}; /* * A primitive boolean value (ECMA-262, 4.3.14). Either the true * or false value. / class V8_EXPORT Boolean : public Primitive { public: bool Value() const; V8_INLINE static Boolean Cast(v8::Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<Boolean>(data); } V8_INLINE static Local<Boolean> New(Isolate isolate, bool value); private: static void CheckCast(v8::Data* that); }; /** * An array to hold Primitive values. This is used by the embedder to * pass host defined options to the ScriptOptions during compilation. * * This is passed back to the embedder as part of * HostImportModuleDynamicallyCallback for module loading. / class V8_EXPORT PrimitiveArray : public Data { public: static Local<PrimitiveArray> New(Isolate isolate, int length); int Length() const; void Set(Isolate* isolate, int index, Local<Primitive> item); Local<Primitive> Get(Isolate* isolate, int index); V8_INLINE static PrimitiveArray* Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return reinterpret_cast<PrimitiveArray>(data); } private: static void CheckCast(Data obj); }; /** * A superclass for symbols and strings. / class V8_EXPORT Name : public Primitive { public: /* * Returns the identity hash for this object. The current implementation * uses an inline property on the object to store the identity hash. * * The return value will never be 0. Also, it is not guaranteed to be * unique. / int GetIdentityHash(); V8_INLINE static Name Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<Name>(data); } private: static void CheckCast(Data that); }; /** * A flag describing different modes of string creation. * * Aside from performance implications there are no differences between the two * creation modes. / enum class NewStringType { /* * Create a new string, always allocating new storage memory. / kNormal, /* * Acts as a hint that the string should be created in the * old generation heap space and be deduplicated if an identical string * already exists. / kInternalized }; /* * A JavaScript string value (ECMA-262, 4.3.17). / class V8_EXPORT String : public Name { public: static constexpr int kMaxLength = internal::kApiSystemPointerSize == 4 ? (1 << 28) - 16 : (1 << 29) - 24; enum Encoding { UNKNOWN_ENCODING = 0x1, TWO_BYTE_ENCODING = 0x0, ONE_BYTE_ENCODING = 0x8 }; /* * Returns the number of characters (UTF-16 code units) in this string. / int Length() const; /* * Returns the number of bytes in the UTF-8 encoded * representation of this string. / int Utf8Length(Isolate isolate) const; /** * Returns whether this string is known to contain only one byte data, * i.e. ISO-8859-1 code points. * Does not read the string. * False negatives are possible. / bool IsOneByte() const; /* * Returns whether this string contain only one byte data, * i.e. ISO-8859-1 code points. * Will read the entire string in some cases. / bool ContainsOnlyOneByte() const; /* * Write the contents of the string to an external buffer. * If no arguments are given, expects the buffer to be large * enough to hold the entire string and NULL terminator. Copies * the contents of the string and the NULL terminator into the * buffer. * * WriteUtf8 will not write partial UTF-8 sequences, preferring to stop * before the end of the buffer. * * Copies up to length characters into the output buffer. * Only null-terminates if there is enough space in the buffer. * * \param buffer The buffer into which the string will be copied. * \param start The starting position within the string at which * copying begins. * \param length The number of characters to copy from the string. For * WriteUtf8 the number of bytes in the buffer. * \param nchars_ref The number of characters written, can be NULL. * \param options Various options that might affect performance of this or * subsequent operations. * \return The number of characters copied to the buffer excluding the null * terminator. For WriteUtf8: The number of bytes copied to the buffer * including the null terminator (if written). / enum WriteOptions { NO_OPTIONS = 0, HINT_MANY_WRITES_EXPECTED = 1, NO_NULL_TERMINATION = 2, PRESERVE_ONE_BYTE_NULL = 4, // Used by WriteUtf8 to replace orphan surrogate code units with the // unicode replacement character. Needs to be set to guarantee valid UTF-8 // output. REPLACE_INVALID_UTF8 = 8 }; // 16-bit character codes. int Write(Isolate isolate, uint16_t* buffer, int start = 0, int length = -1, int options = NO_OPTIONS) const; // One byte characters. int WriteOneByte(Isolate* isolate, uint8_t* buffer, int start = 0, int length = -1, int options = NO_OPTIONS) const; // UTF-8 encoded characters. int WriteUtf8(Isolate* isolate, char* buffer, int length = -1, int* nchars_ref = nullptr, int options = NO_OPTIONS) const; /** * A zero length string. / V8_INLINE static Local<String> Empty(Isolate isolate); /** * Returns true if the string is external. / bool IsExternal() const; /* * Returns true if the string is both external and two-byte. / bool IsExternalTwoByte() const; /* * Returns true if the string is both external and one-byte. / bool IsExternalOneByte() const; class V8_EXPORT ExternalStringResourceBase { public: virtual ~ExternalStringResourceBase() = default; /* * If a string is cacheable, the value returned by * ExternalStringResource::data() may be cached, otherwise it is not * expected to be stable beyond the current top-level task. / virtual bool IsCacheable() const { return true; } // Disallow copying and assigning. ExternalStringResourceBase(const ExternalStringResourceBase&) = delete; void operator=(const ExternalStringResourceBase&) = delete; protected: ExternalStringResourceBase() = default; /* * Internally V8 will call this Dispose method when the external string * resource is no longer needed. The default implementation will use the * delete operator. This method can be overridden in subclasses to * control how allocated external string resources are disposed. / virtual void Dispose() { delete this; } /* * For a non-cacheable string, the value returned by * \|ExternalStringResource::data()\| has to be stable between \|Lock()\| and * \|Unlock()\|, that is the string must behave as is \|IsCacheable()\| returned * true. * * These two functions must be thread-safe, and can be called from anywhere. * They also must handle lock depth, in the sense that each can be called * several times, from different threads, and unlocking should only happen * when the balance of Lock() and Unlock() calls is 0. / virtual void Lock() const {} /* * Unlocks the string. / virtual void Unlock() const {} private: friend class internal::ExternalString; friend class v8::String; friend class internal::StringForwardingTable; friend class internal::ScopedExternalStringLock; }; /* * An ExternalStringResource is a wrapper around a two-byte string * buffer that resides outside V8's heap. Implement an * ExternalStringResource to manage the life cycle of the underlying * buffer. Note that the string data must be immutable. / class V8_EXPORT ExternalStringResource : public ExternalStringResourceBase { public: /* * Override the destructor to manage the life cycle of the underlying * buffer. / ~ExternalStringResource() override = default; /* * The string data from the underlying buffer. If the resource is cacheable * then data() must return the same value for all invocations. / virtual const uint16_t data() const = 0; /** * The length of the string. That is, the number of two-byte characters. / virtual size_t length() const = 0; /* * Returns the cached data from the underlying buffer. This method can be * called only for cacheable resources (i.e. IsCacheable() == true) and only * after UpdateDataCache() was called. / const uint16_t cached_data() const { CheckCachedDataInvariants(); return cached_data_; } /** * Update {cached_data_} with the data from the underlying buffer. This can * be called only for cacheable resources. / void UpdateDataCache(); protected: ExternalStringResource() = default; private: void CheckCachedDataInvariants() const; const uint16_t cached_data_ = nullptr; }; /** * An ExternalOneByteStringResource is a wrapper around an one-byte * string buffer that resides outside V8's heap. Implement an * ExternalOneByteStringResource to manage the life cycle of the * underlying buffer. Note that the string data must be immutable * and that the data must be Latin-1 and not UTF-8, which would require * special treatment internally in the engine and do not allow efficient * indexing. Use String::New or convert to 16 bit data for non-Latin1. / class V8_EXPORT ExternalOneByteStringResource : public ExternalStringResourceBase { public: /* * Override the destructor to manage the life cycle of the underlying * buffer. / ~ExternalOneByteStringResource() override = default; /* * The string data from the underlying buffer. If the resource is cacheable * then data() must return the same value for all invocations. / virtual const char data() const = 0; /** The number of Latin-1 characters in the string./ virtual size_t length() const = 0; /* * Returns the cached data from the underlying buffer. If the resource is * uncacheable or if UpdateDataCache() was not called before, it has * undefined behaviour. / const char cached_data() const { CheckCachedDataInvariants(); return cached_data_; } /** * Update {cached_data_} with the data from the underlying buffer. This can * be called only for cacheable resources. / void UpdateDataCache(); protected: ExternalOneByteStringResource() = default; private: void CheckCachedDataInvariants() const; const char cached_data_ = nullptr; }; /** * If the string is an external string, return the ExternalStringResourceBase * regardless of the encoding, otherwise return NULL. The encoding of the * string is returned in encoding_out. / V8_INLINE ExternalStringResourceBase GetExternalStringResourceBase( Encoding* encoding_out) const; /** * Get the ExternalStringResource for an external string. Returns * NULL if IsExternal() doesn't return true. / V8_INLINE ExternalStringResource GetExternalStringResource() const; /** * Get the ExternalOneByteStringResource for an external one-byte string. * Returns NULL if IsExternalOneByte() doesn't return true. / const ExternalOneByteStringResource GetExternalOneByteStringResource() const; V8_INLINE static String* Cast(v8::Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<String>(data); } /* * Allocates a new string from a UTF-8 literal. This is equivalent to calling * String::NewFromUtf(isolate, "...").ToLocalChecked(), but without the check * overhead. * * When called on a string literal containing '\0', the inferred length is the * length of the input array minus 1 (for the final '\0') and not the value * returned by strlen. */ template <int N> static V8_WARN_UNUSED_RESULT Local<String> NewFromUtf8Literal( Isolate isolate, const char (&literal)[N], NewStringType type = NewStringType::kNormal) { static_assert(N <= kMaxLength, "String is too long"); return NewFromUtf8Literal(isolate, literal, type, N - 1); } /** Allocates a new string from UTF-8 data. Only returns an empty value when * length > kMaxLength. */ static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewFromUtf8( Isolate isolate, const char* data, NewStringType type = NewStringType::kNormal, int length = -1); /** Allocates a new string from Latin-1 data. Only returns an empty value * when length > kMaxLength. */ static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewFromOneByte( Isolate isolate, const uint8_t* data, NewStringType type = NewStringType::kNormal, int length = -1); /** Allocates a new string from UTF-16 data. Only returns an empty value when * length > kMaxLength. */ static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewFromTwoByte( Isolate isolate, const uint16_t* data, NewStringType type = NewStringType::kNormal, int length = -1); /** * Creates a new string by concatenating the left and the right strings * passed in as parameters. / static Local<String> Concat(Isolate isolate, Local<String> left, Local<String> right); /** * Creates a new external string using the data defined in the given * resource. When the external string is no longer live on V8's heap the * resource will be disposed by calling its Dispose method. The caller of * this function should not otherwise delete or modify the resource. Neither * should the underlying buffer be deallocated or modified except through the * destructor of the external string resource. / static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewExternalTwoByte( Isolate isolate, ExternalStringResource* resource); /** * Associate an external string resource with this string by transforming it * in place so that existing references to this string in the JavaScript heap * will use the external string resource. The external string resource's * character contents need to be equivalent to this string. * Returns true if the string has been changed to be an external string. * The string is not modified if the operation fails. See NewExternal for * information on the lifetime of the resource. / bool MakeExternal(ExternalStringResource resource); /** * Creates a new external string using the one-byte data defined in the given * resource. When the external string is no longer live on V8's heap the * resource will be disposed by calling its Dispose method. The caller of * this function should not otherwise delete or modify the resource. Neither * should the underlying buffer be deallocated or modified except through the * destructor of the external string resource. / static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewExternalOneByte( Isolate isolate, ExternalOneByteStringResource* resource); /** * Associate an external string resource with this string by transforming it * in place so that existing references to this string in the JavaScript heap * will use the external string resource. The external string resource's * character contents need to be equivalent to this string. * Returns true if the string has been changed to be an external string. * The string is not modified if the operation fails. See NewExternal for * information on the lifetime of the resource. / bool MakeExternal(ExternalOneByteStringResource resource); /** * Returns true if this string can be made external, given the encoding for * the external string resource. / bool CanMakeExternal(Encoding encoding) const; /* * Returns true if the strings values are equal. Same as JS ==/===. / bool StringEquals(Local<String> str) const; /* * Converts an object to a UTF-8-encoded character array. Useful if * you want to print the object. If conversion to a string fails * (e.g. due to an exception in the toString() method of the object) * then the length() method returns 0 and the * operator returns * NULL. / class V8_EXPORT Utf8Value { public: Utf8Value(Isolate isolate, Local<v8::Value> obj); ~Utf8Value(); char* operator() { return str_; } const char operator() const { return str_; } int length() const { return length_; } // Disallow copying and assigning. Utf8Value(const Utf8Value&) = delete; void operator=(const Utf8Value&) = delete; private: char str_; int length_; }; /** * Converts an object to a two-byte (UTF-16-encoded) string. * If conversion to a string fails (eg. due to an exception in the toString() * method of the object) then the length() method returns 0 and the * operator * returns NULL. / class V8_EXPORT Value { public: Value(Isolate isolate, Local<v8::Value> obj); ~Value(); uint16_t* operator() { return str_; } const uint16_t operator() const { return str_; } int length() const { return length_; } // Disallow copying and assigning. Value(const Value&) = delete; void operator=(const Value&) = delete; private: uint16_t str_; int length_; }; private: void VerifyExternalStringResourceBase(ExternalStringResourceBase* v, Encoding encoding) const; void VerifyExternalStringResource(ExternalStringResource* val) const; ExternalStringResource* GetExternalStringResourceSlow() const; ExternalStringResourceBase* GetExternalStringResourceBaseSlow( String::Encoding* encoding_out) const; static Local<v8::String> NewFromUtf8Literal(Isolate* isolate, const char* literal, NewStringType type, int length); static void CheckCast(v8::Data* that); }; // Zero-length string specialization (templated string size includes // terminator). template <> inline V8_WARN_UNUSED_RESULT Local<String> String::NewFromUtf8Literal( Isolate* isolate, const char (&literal)[1], NewStringType type) { return String::Empty(isolate); } /** * Interface for iterating through all external resources in the heap. / class V8_EXPORT ExternalResourceVisitor { public: virtual ~ExternalResourceVisitor() = default; virtual void VisitExternalString(Local<String> string) {} }; /* * A JavaScript symbol (ECMA-262 edition 6) / class V8_EXPORT Symbol : public Name { public: /* * Returns the description string of the symbol, or undefined if none. / Local<Value> Description(Isolate isolate) const; /** * Create a symbol. If description is not empty, it will be used as the * description. / static Local<Symbol> New(Isolate isolate, Local<String> description = Local<String>()); /** * Access global symbol registry. * Note that symbols created this way are never collected, so * they should only be used for statically fixed properties. * Also, there is only one global name space for the descriptions used as * keys. * To minimize the potential for clashes, use qualified names as keys. / static Local<Symbol> For(Isolate isolate, Local<String> description); /** * Retrieve a global symbol. Similar to \|For\|, but using a separate * registry that is not accessible by (and cannot clash with) JavaScript code. / static Local<Symbol> ForApi(Isolate isolate, Local<String> description); // Well-known symbols static Local<Symbol> GetAsyncIterator(Isolate* isolate); static Local<Symbol> GetHasInstance(Isolate* isolate); static Local<Symbol> GetIsConcatSpreadable(Isolate* isolate); static Local<Symbol> GetIterator(Isolate* isolate); static Local<Symbol> GetMatch(Isolate* isolate); static Local<Symbol> GetReplace(Isolate* isolate); static Local<Symbol> GetSearch(Isolate* isolate); static Local<Symbol> GetSplit(Isolate* isolate); static Local<Symbol> GetToPrimitive(Isolate* isolate); static Local<Symbol> GetToStringTag(Isolate* isolate); static Local<Symbol> GetUnscopables(Isolate* isolate); V8_INLINE static Symbol* Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<Symbol>(data); } private: Symbol(); static void CheckCast(Data that); }; /** * A JavaScript numeric value (either Number or BigInt). * https://tc39.es/ecma262/#sec-numeric-types / class V8_EXPORT Numeric : public Primitive { private: Numeric(); static void CheckCast(v8::Data that); }; /** * A JavaScript number value (ECMA-262, 4.3.20) / class V8_EXPORT Number : public Numeric { public: double Value() const; static Local<Number> New(Isolate isolate, double value); V8_INLINE static Number* Cast(v8::Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<Number>(data); } private: Number(); static void CheckCast(v8::Data that); }; /** * A JavaScript value representing a signed integer. / class V8_EXPORT Integer : public Number { public: static Local<Integer> New(Isolate isolate, int32_t value); static Local<Integer> NewFromUnsigned(Isolate* isolate, uint32_t value); int64_t Value() const; V8_INLINE static Integer* Cast(v8::Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<Integer>(data); } private: Integer(); static void CheckCast(v8::Data that); }; /** * A JavaScript value representing a 32-bit signed integer. / class V8_EXPORT Int32 : public Integer { public: int32_t Value() const; V8_INLINE static Int32 Cast(v8::Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<Int32>(data); } private: Int32(); static void CheckCast(v8::Data that); }; /** * A JavaScript value representing a 32-bit unsigned integer. / class V8_EXPORT Uint32 : public Integer { public: uint32_t Value() const; V8_INLINE static Uint32 Cast(v8::Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<Uint32>(data); } private: Uint32(); static void CheckCast(v8::Data that); }; /** * A JavaScript BigInt value (https://tc39.github.io/proposal-bigint) / class V8_EXPORT BigInt : public Numeric { public: static Local<BigInt> New(Isolate isolate, int64_t value); static Local<BigInt> NewFromUnsigned(Isolate* isolate, uint64_t value); /** * Creates a new BigInt object using a specified sign bit and a * specified list of digits/words. * The resulting number is calculated as: * * (-1)^sign_bit * (words[0] * (2^64)^0 + words[1] * (2^64)^1 + ...) / static MaybeLocal<BigInt> NewFromWords(Local<Context> context, int sign_bit, int word_count, const uint64_t words); /** * Returns the value of this BigInt as an unsigned 64-bit integer. * If `lossless` is provided, it will reflect whether the return value was * truncated or wrapped around. In particular, it is set to `false` if this * BigInt is negative. / uint64_t Uint64Value(bool lossless = nullptr) const; /** * Returns the value of this BigInt as a signed 64-bit integer. * If `lossless` is provided, it will reflect whether this BigInt was * truncated or not. / int64_t Int64Value(bool lossless = nullptr) const; /** * Returns the number of 64-bit words needed to store the result of * ToWordsArray(). / int WordCount() const; /* * Writes the contents of this BigInt to a specified memory location. * `sign_bit` must be provided and will be set to 1 if this BigInt is * negative. * `word_count` has to be initialized to the length of the `words` array. Upon return, it will be set to the actual number of words that would * be needed to store this BigInt (i.e. the return value of `WordCount()`). / void ToWordsArray(int sign_bit, int* word_count, uint64_t* words) const; V8_INLINE static BigInt* Cast(v8::Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return static_cast<BigInt>(data); } private: BigInt(); static void CheckCast(v8::Data that); }; Local<String> String::Empty(Isolate* isolate) { using S = internal::Address; using I = internal::Internals; I::CheckInitialized(isolate); S* slot = I::GetRootSlot(isolate, I::kEmptyStringRootIndex); return Local<String>::FromSlot(slot); } String::ExternalStringResource* String::GetExternalStringResource() const { using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); ExternalStringResource* result; if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) { Isolate* isolate = I::GetIsolateForSandbox(obj); A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>( isolate, obj, I::kStringResourceOffset); result = reinterpret_cast<String::ExternalStringResource>(value); } else { result = GetExternalStringResourceSlow(); } #ifdef V8_ENABLE_CHECKS VerifyExternalStringResource(result); #endif return result; } String::ExternalStringResourceBase String::GetExternalStringResourceBase( String::Encoding* encoding_out) const { using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); int type = I::GetInstanceType(obj) & I::kStringRepresentationAndEncodingMask; encoding_out = static_cast<Encoding>(type & I::kStringEncodingMask); ExternalStringResourceBase resource; if (type == I::kExternalOneByteRepresentationTag \|\| type == I::kExternalTwoByteRepresentationTag) { Isolate* isolate = I::GetIsolateForSandbox(obj); A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>( isolate, obj, I::kStringResourceOffset); resource = reinterpret_cast<ExternalStringResourceBase>(value); } else { resource = GetExternalStringResourceBaseSlow(encoding_out); } #ifdef V8_ENABLE_CHECKS VerifyExternalStringResourceBase(resource, encoding_out); #endif return resource; } // --- Statics --- V8_INLINE Local<Primitive> Undefined(Isolate* isolate) { using S = internal::Address; using I = internal::Internals; I::CheckInitialized(isolate); S* slot = I::GetRootSlot(isolate, I::kUndefinedValueRootIndex); return Local<Primitive>::FromSlot(slot); } V8_INLINE Local<Primitive> Null(Isolate* isolate) { using S = internal::Address; using I = internal::Internals; I::CheckInitialized(isolate); S* slot = I::GetRootSlot(isolate, I::kNullValueRootIndex); return Local<Primitive>::FromSlot(slot); } V8_INLINE Local<Boolean> True(Isolate* isolate) { using S = internal::Address; using I = internal::Internals; I::CheckInitialized(isolate); S* slot = I::GetRootSlot(isolate, I::kTrueValueRootIndex); return Local<Boolean>::FromSlot(slot); } V8_INLINE Local<Boolean> False(Isolate* isolate) { using S = internal::Address; using I = internal::Internals; I::CheckInitialized(isolate); S* slot = I::GetRootSlot(isolate, I::kFalseValueRootIndex); return Local<Boolean>::FromSlot(slot); } Local<Boolean> Boolean::New(Isolate* isolate, bool value) { return value ? True(isolate) : False(isolate); } } // namespace v8 #endif // INCLUDE_V8_PRIMITIVE_H_	27.69 KB	2025-03-03 12:36
📄 v8-profiler.h // Copyright 2010 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. #ifndef V8_V8_PROFILER_H_ #define V8_V8_PROFILER_H_ #include <limits.h> #include <memory> #include <unordered_set> #include <vector> #include "cppgc/common.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-message.h" // NOLINT(build/include_directory) #include "v8-persistent-handle.h" // NOLINT(build/include_directory) /** * Profiler support for the V8 JavaScript engine. / namespace v8 { enum class EmbedderStateTag : uint8_t; class HeapGraphNode; struct HeapStatsUpdate; class Object; enum StateTag : uint16_t; using NativeObject = void; using SnapshotObjectId = uint32_t; using ProfilerId = uint32_t; struct CpuProfileDeoptFrame { int script_id; size_t position; }; namespace internal { class CpuProfile; } // namespace internal } // namespace v8 #ifdef V8_OS_WIN template class V8_EXPORT std::vector<v8::CpuProfileDeoptFrame>; #endif namespace v8 { struct V8_EXPORT CpuProfileDeoptInfo { /** A pointer to a static string owned by v8. / const char deopt_reason; std::vector<CpuProfileDeoptFrame> stack; }; } // namespace v8 #ifdef V8_OS_WIN template class V8_EXPORT std::vector<v8::CpuProfileDeoptInfo>; #endif namespace v8 { /** * CpuProfileNode represents a node in a call graph. / class V8_EXPORT CpuProfileNode { public: struct LineTick { /* The 1-based number of the source line where the function originates. / int line; /* The count of samples associated with the source line. / unsigned int hit_count; }; // An annotation hinting at the source of a CpuProfileNode. enum SourceType { // User-supplied script with associated resource information. kScript = 0, // Native scripts and provided builtins. kBuiltin = 1, // Callbacks into native code. kCallback = 2, // VM-internal functions or state. kInternal = 3, // A node that failed to symbolize. kUnresolved = 4, }; /* Returns function name (empty string for anonymous functions.) / Local<String> GetFunctionName() const; /* * Returns function name (empty string for anonymous functions.) * The string ownership is not passed to the caller. It stays valid until * profile is deleted. The function is thread safe. / const char GetFunctionNameStr() const; /** Returns id of the script where function is located. / int GetScriptId() const; /* Returns resource name for script from where the function originates. / Local<String> GetScriptResourceName() const; /* * Returns resource name for script from where the function originates. * The string ownership is not passed to the caller. It stays valid until * profile is deleted. The function is thread safe. / const char GetScriptResourceNameStr() const; /** * Return true if the script from where the function originates is flagged as * being shared cross-origin. / bool IsScriptSharedCrossOrigin() const; /* * Returns the number, 1-based, of the line where the function originates. * kNoLineNumberInfo if no line number information is available. / int GetLineNumber() const; /* * Returns 1-based number of the column where the function originates. * kNoColumnNumberInfo if no column number information is available. / int GetColumnNumber() const; /* * Returns the number of the function's source lines that collect the samples. / unsigned int GetHitLineCount() const; /* Returns the set of source lines that collect the samples. * The caller allocates buffer and responsible for releasing it. * True if all available entries are copied, otherwise false. * The function copies nothing if buffer is not large enough. / bool GetLineTicks(LineTick entries, unsigned int length) const; /** Returns bailout reason for the function * if the optimization was disabled for it. / const char GetBailoutReason() const; /** * Returns the count of samples where the function was currently executing. / unsigned GetHitCount() const; /* Returns id of the node. The id is unique within the tree / unsigned GetNodeId() const; /* * Gets the type of the source which the node was captured from. / SourceType GetSourceType() const; /* Returns child nodes count of the node. / int GetChildrenCount() const; /* Retrieves a child node by index. / const CpuProfileNode GetChild(int index) const; /** Retrieves the ancestor node, or null if the root. / const CpuProfileNode GetParent() const; /** Retrieves deopt infos for the node. / const std::vector<CpuProfileDeoptInfo>& GetDeoptInfos() const; static const int kNoLineNumberInfo = Message::kNoLineNumberInfo; static const int kNoColumnNumberInfo = Message::kNoColumnInfo; }; /* * An interface for exporting data from V8, using "push" model. / class V8_EXPORT OutputStream { public: enum WriteResult { kContinue = 0, kAbort = 1 }; virtual ~OutputStream() = default; /* Notify about the end of stream. / virtual void EndOfStream() = 0; /* Get preferred output chunk size. Called only once. / virtual int GetChunkSize() { return 1024; } /* * Writes the next chunk of snapshot data into the stream. Writing * can be stopped by returning kAbort as function result. EndOfStream * will not be called in case writing was aborted. / virtual WriteResult WriteAsciiChunk(char data, int size) = 0; /** * Writes the next chunk of heap stats data into the stream. Writing * can be stopped by returning kAbort as function result. EndOfStream * will not be called in case writing was aborted. / virtual WriteResult WriteHeapStatsChunk(HeapStatsUpdate data, int count) { return kAbort; } }; /** * CpuProfile contains a CPU profile in a form of top-down call tree * (from main() down to functions that do all the work). / class V8_EXPORT CpuProfile { public: enum SerializationFormat { kJSON = 0 // See format description near 'Serialize' method. }; /* Returns CPU profile title. / Local<String> GetTitle() const; /* Returns the root node of the top down call tree. / const CpuProfileNode GetTopDownRoot() const; /** * Returns number of samples recorded. The samples are not recorded unless * \|record_samples\| parameter of CpuProfiler::StartCpuProfiling is true. / int GetSamplesCount() const; /* * Returns profile node corresponding to the top frame the sample at * the given index. / const CpuProfileNode GetSample(int index) const; /** * Returns the timestamp of the sample. The timestamp is the number of * microseconds since some unspecified starting point. * The point is equal to the starting point used by GetStartTime. / int64_t GetSampleTimestamp(int index) const; /* * Returns time when the profile recording was started (in microseconds) * since some unspecified starting point. / int64_t GetStartTime() const; /* * Returns state of the vm when sample was captured. / StateTag GetSampleState(int index) const; /* * Returns state of the embedder when sample was captured. / EmbedderStateTag GetSampleEmbedderState(int index) const; /* * Returns time when the profile recording was stopped (in microseconds) * since some unspecified starting point. * The point is equal to the starting point used by GetStartTime. / int64_t GetEndTime() const; /* * Deletes the profile and removes it from CpuProfiler's list. * All pointers to nodes previously returned become invalid. / void Delete(); /* * Prepare a serialized representation of the profile. The result * is written into the stream provided in chunks of specified size. * * For the JSON format, heap contents are represented as an object * with the following structure: * * { * nodes: [nodes array], * startTime: number, * endTime: number * samples: [strings array] * timeDeltas: [numbers array] * } * / void Serialize(OutputStream stream, SerializationFormat format = kJSON) const; }; enum CpuProfilingMode { // In the resulting CpuProfile tree, intermediate nodes in a stack trace // (from the root to a leaf) will have line numbers that point to the start // line of the function, rather than the line of the callsite of the child. kLeafNodeLineNumbers, // In the resulting CpuProfile tree, nodes are separated based on the line // number of their callsite in their parent. kCallerLineNumbers, }; // Determines how names are derived for functions sampled. enum CpuProfilingNamingMode { // Use the immediate name of functions at compilation time. kStandardNaming, // Use more verbose naming for functions without names, inferred from scope // where possible. kDebugNaming, }; enum CpuProfilingLoggingMode { // Enables logging when a profile is active, and disables logging when all // profiles are detached. kLazyLogging, // Enables logging for the lifetime of the CpuProfiler. Calls to // StartRecording are faster, at the expense of runtime overhead. kEagerLogging, }; // Enum for returning profiling status. Once StartProfiling is called, // we want to return to clients whether the profiling was able to start // correctly, or return a descriptive error. enum class CpuProfilingStatus { kStarted, kAlreadyStarted, kErrorTooManyProfilers }; /** * Result from StartProfiling returning the Profiling Status, and * id of the started profiler, or 0 if profiler is not started / struct CpuProfilingResult { const ProfilerId id; const CpuProfilingStatus status; }; /* * Delegate for when max samples reached and samples are discarded. / class V8_EXPORT DiscardedSamplesDelegate { public: DiscardedSamplesDelegate() = default; virtual ~DiscardedSamplesDelegate() = default; virtual void Notify() = 0; ProfilerId GetId() const { return profiler_id_; } private: friend internal::CpuProfile; void SetId(ProfilerId id) { profiler_id_ = id; } ProfilerId profiler_id_; }; /* * Optional profiling attributes. / class V8_EXPORT CpuProfilingOptions { public: // Indicates that the sample buffer size should not be explicitly limited. static const unsigned kNoSampleLimit = UINT_MAX; /* * \param mode Type of computation of stack frame line numbers. * \param max_samples The maximum number of samples that should be recorded by * the profiler. Samples obtained after this limit will be * discarded. * \param sampling_interval_us controls the profile-specific target * sampling interval. The provided sampling * interval will be snapped to the next lowest * non-zero multiple of the profiler's sampling * interval, set via SetSamplingInterval(). If * zero, the sampling interval will be equal to * the profiler's sampling interval. * \param filter_context If specified, profiles will only contain frames * using this context. Other frames will be elided. / CpuProfilingOptions( CpuProfilingMode mode = kLeafNodeLineNumbers, unsigned max_samples = kNoSampleLimit, int sampling_interval_us = 0, MaybeLocal<Context> filter_context = MaybeLocal<Context>()); CpuProfilingOptions(CpuProfilingOptions&&) = default; CpuProfilingOptions& operator=(CpuProfilingOptions&&) = default; CpuProfilingMode mode() const { return mode_; } unsigned max_samples() const { return max_samples_; } int sampling_interval_us() const { return sampling_interval_us_; } private: friend class internal::CpuProfile; bool has_filter_context() const { return !filter_context_.IsEmpty(); } void raw_filter_context() const; CpuProfilingMode mode_; unsigned max_samples_; int sampling_interval_us_; Global<Context> filter_context_; }; /** * Interface for controlling CPU profiling. Instance of the * profiler can be created using v8::CpuProfiler::New method. / class V8_EXPORT CpuProfiler { public: /* * Creates a new CPU profiler for the \|isolate\|. The isolate must be * initialized. The profiler object must be disposed after use by calling * \|Dispose\| method. / static CpuProfiler New(Isolate* isolate, CpuProfilingNamingMode = kDebugNaming, CpuProfilingLoggingMode = kLazyLogging); /** * Synchronously collect current stack sample in all profilers attached to * the \|isolate\|. The call does not affect number of ticks recorded for * the current top node. / static void CollectSample(Isolate isolate); /** * Disposes the CPU profiler object. / void Dispose(); /* * Changes default CPU profiler sampling interval to the specified number * of microseconds. Default interval is 1000us. This method must be called * when there are no profiles being recorded. / void SetSamplingInterval(int us); /* * Sets whether or not the profiler should prioritize consistency of sample * periodicity on Windows. Disabling this can greatly reduce CPU usage, but * may result in greater variance in sample timings from the platform's * scheduler. Defaults to enabled. This method must be called when there are * no profiles being recorded. / void SetUsePreciseSampling(bool); /* * Starts collecting a CPU profile. Several profiles may be collected at once. * Generates an anonymous profiler, without a String identifier. / CpuProfilingResult Start( CpuProfilingOptions options, std::unique_ptr<DiscardedSamplesDelegate> delegate = nullptr); /* * Starts collecting a CPU profile. Title may be an empty string. Several * profiles may be collected at once. Attempts to start collecting several * profiles with the same title are silently ignored. / CpuProfilingResult Start( Local<String> title, CpuProfilingOptions options, std::unique_ptr<DiscardedSamplesDelegate> delegate = nullptr); /* * Starts profiling with the same semantics as above, except with expanded * parameters. * * \|record_samples\| parameter controls whether individual samples should * be recorded in addition to the aggregated tree. * * \|max_samples\| controls the maximum number of samples that should be * recorded by the profiler. Samples obtained after this limit will be * discarded. / CpuProfilingResult Start( Local<String> title, CpuProfilingMode mode, bool record_samples = false, unsigned max_samples = CpuProfilingOptions::kNoSampleLimit); /* * The same as StartProfiling above, but the CpuProfilingMode defaults to * kLeafNodeLineNumbers mode, which was the previous default behavior of the * profiler. / CpuProfilingResult Start(Local<String> title, bool record_samples = false); /* * Starts collecting a CPU profile. Title may be an empty string. Several * profiles may be collected at once. Attempts to start collecting several * profiles with the same title are silently ignored. / CpuProfilingStatus StartProfiling( Local<String> title, CpuProfilingOptions options, std::unique_ptr<DiscardedSamplesDelegate> delegate = nullptr); /* * Starts profiling with the same semantics as above, except with expanded * parameters. * * \|record_samples\| parameter controls whether individual samples should * be recorded in addition to the aggregated tree. * * \|max_samples\| controls the maximum number of samples that should be * recorded by the profiler. Samples obtained after this limit will be * discarded. / CpuProfilingStatus StartProfiling( Local<String> title, CpuProfilingMode mode, bool record_samples = false, unsigned max_samples = CpuProfilingOptions::kNoSampleLimit); /* * The same as StartProfiling above, but the CpuProfilingMode defaults to * kLeafNodeLineNumbers mode, which was the previous default behavior of the * profiler. / CpuProfilingStatus StartProfiling(Local<String> title, bool record_samples = false); /* * Stops collecting CPU profile with a given id and returns it. / CpuProfile Stop(ProfilerId id); /** * Stops collecting CPU profile with a given title and returns it. * If the title given is empty, finishes the last profile started. / CpuProfile StopProfiling(Local<String> title); /** * Generate more detailed source positions to code objects. This results in * better results when mapping profiling samples to script source. / static void UseDetailedSourcePositionsForProfiling(Isolate isolate); private: CpuProfiler(); ~CpuProfiler(); CpuProfiler(const CpuProfiler&); CpuProfiler& operator=(const CpuProfiler&); }; /** * HeapSnapshotEdge represents a directed connection between heap * graph nodes: from retainers to retained nodes. / class V8_EXPORT HeapGraphEdge { public: enum Type { kContextVariable = 0, // A variable from a function context. kElement = 1, // An element of an array. kProperty = 2, // A named object property. kInternal = 3, // A link that can't be accessed from JS, // thus, its name isn't a real property name // (e.g. parts of a ConsString). kHidden = 4, // A link that is needed for proper sizes // calculation, but may be hidden from user. kShortcut = 5, // A link that must not be followed during // sizes calculation. kWeak = 6 // A weak reference (ignored by the GC). }; /* Returns edge type (see HeapGraphEdge::Type). / Type GetType() const; /* * Returns edge name. This can be a variable name, an element index, or * a property name. / Local<Value> GetName() const; /* Returns origin node. / const HeapGraphNode GetFromNode() const; /** Returns destination node. / const HeapGraphNode GetToNode() const; }; /** * HeapGraphNode represents a node in a heap graph. / class V8_EXPORT HeapGraphNode { public: enum Type { kHidden = 0, // Hidden node, may be filtered when shown to user. kArray = 1, // An array of elements. kString = 2, // A string. kObject = 3, // A JS object (except for arrays and strings). kCode = 4, // Compiled code. kClosure = 5, // Function closure. kRegExp = 6, // RegExp. kHeapNumber = 7, // Number stored in the heap. kNative = 8, // Native object (not from V8 heap). kSynthetic = 9, // Synthetic object, usually used for grouping // snapshot items together. kConsString = 10, // Concatenated string. A pair of pointers to strings. kSlicedString = 11, // Sliced string. A fragment of another string. kSymbol = 12, // A Symbol (ES6). kBigInt = 13, // BigInt. kObjectShape = 14, // Internal data used for tracking the shapes (or // "hidden classes") of JS objects. }; /* Returns node type (see HeapGraphNode::Type). / Type GetType() const; /* * Returns node name. Depending on node's type this can be the name * of the constructor (for objects), the name of the function (for * closures), string value, or an empty string (for compiled code). / Local<String> GetName() const; /* * Returns node id. For the same heap object, the id remains the same * across all snapshots. / SnapshotObjectId GetId() const; /* Returns node's own size, in bytes. / size_t GetShallowSize() const; /* Returns child nodes count of the node. / int GetChildrenCount() const; /* Retrieves a child by index. / const HeapGraphEdge GetChild(int index) const; }; /** * HeapSnapshots record the state of the JS heap at some moment. / class V8_EXPORT HeapSnapshot { public: enum SerializationFormat { kJSON = 0 // See format description near 'Serialize' method. }; /* Returns the root node of the heap graph. / const HeapGraphNode GetRoot() const; /** Returns a node by its id. / const HeapGraphNode GetNodeById(SnapshotObjectId id) const; /** Returns total nodes count in the snapshot. / int GetNodesCount() const; /* Returns a node by index. / const HeapGraphNode GetNode(int index) const; /** Returns a max seen JS object Id. / SnapshotObjectId GetMaxSnapshotJSObjectId() const; /* * Deletes the snapshot and removes it from HeapProfiler's list. * All pointers to nodes, edges and paths previously returned become * invalid. / void Delete(); /* * Prepare a serialized representation of the snapshot. The result * is written into the stream provided in chunks of specified size. * The total length of the serialized snapshot is unknown in * advance, it can be roughly equal to JS heap size (that means, * it can be really big - tens of megabytes). * * For the JSON format, heap contents are represented as an object * with the following structure: * * { * snapshot: { * title: "...", * uid: nnn, * meta: { meta-info }, * node_count: nnn, * edge_count: nnn * }, * nodes: [nodes array], * edges: [edges array], * strings: [strings array] * } * * Nodes reference strings, other nodes, and edges by their indexes * in corresponding arrays. / void Serialize(OutputStream stream, SerializationFormat format = kJSON) const; }; /** * An interface for reporting progress and controlling long-running * activities. / class V8_EXPORT ActivityControl { public: enum ControlOption { kContinue = 0, kAbort = 1 }; virtual ~ActivityControl() = default; /* * Notify about current progress. The activity can be stopped by * returning kAbort as the callback result. / virtual ControlOption ReportProgressValue(uint32_t done, uint32_t total) = 0; }; /* * AllocationProfile is a sampled profile of allocations done by the program. * This is structured as a call-graph. / class V8_EXPORT AllocationProfile { public: struct Allocation { /* * Size of the sampled allocation object. / size_t size; /* * The number of objects of such size that were sampled. / unsigned int count; }; /* * Represents a node in the call-graph. / struct Node { /* * Name of the function. May be empty for anonymous functions or if the * script corresponding to this function has been unloaded. / Local<String> name; /* * Name of the script containing the function. May be empty if the script * name is not available, or if the script has been unloaded. / Local<String> script_name; /* * id of the script where the function is located. May be equal to * v8::UnboundScript::kNoScriptId in cases where the script doesn't exist. / int script_id; /* * Start position of the function in the script. / int start_position; /* * 1-indexed line number where the function starts. May be * kNoLineNumberInfo if no line number information is available. / int line_number; /* * 1-indexed column number where the function starts. May be * kNoColumnNumberInfo if no line number information is available. / int column_number; /* * Unique id of the node. / uint32_t node_id; /* * List of callees called from this node for which we have sampled * allocations. The lifetime of the children is scoped to the containing * AllocationProfile. / std::vector<Node> children; /** * List of self allocations done by this node in the call-graph. / std::vector<Allocation> allocations; }; /* * Represent a single sample recorded for an allocation. / struct Sample { /* * id of the node in the profile tree. / uint32_t node_id; /* * Size of the sampled allocation object. / size_t size; /* * The number of objects of such size that were sampled. / unsigned int count; /* * Unique time-ordered id of the allocation sample. Can be used to track * what samples were added or removed between two snapshots. / uint64_t sample_id; }; /* * Returns the root node of the call-graph. The root node corresponds to an * empty JS call-stack. The lifetime of the returned Node* is scoped to the * containing AllocationProfile. / virtual Node GetRootNode() = 0; virtual const std::vector<Sample>& GetSamples() = 0; virtual ~AllocationProfile() = default; static const int kNoLineNumberInfo = Message::kNoLineNumberInfo; static const int kNoColumnNumberInfo = Message::kNoColumnInfo; }; /** * An object graph consisting of embedder objects and V8 objects. * Edges of the graph are strong references between the objects. * The embedder can build this graph during heap snapshot generation * to include the embedder objects in the heap snapshot. * Usage: * 1) Define derived class of EmbedderGraph::Node for embedder objects. * 2) Set the build embedder graph callback on the heap profiler using * HeapProfiler::AddBuildEmbedderGraphCallback. * 3) In the callback use graph->AddEdge(node1, node2) to add an edge from * node1 to node2. * 4) To represent references from/to V8 object, construct V8 nodes using * graph->V8Node(value). / class V8_EXPORT EmbedderGraph { public: class Node { public: /* * Detachedness specifies whether an object is attached or detached from the * main application state. While unkown in general, there may be objects * that specifically know their state. V8 passes this information along in * the snapshot. Users of the snapshot may use it to annotate the object * graph. / enum class Detachedness : uint8_t { kUnknown = 0, kAttached = 1, kDetached = 2, }; Node() = default; virtual ~Node() = default; virtual const char Name() = 0; virtual size_t SizeInBytes() = 0; /** * The corresponding V8 wrapper node if not null. * During heap snapshot generation the embedder node and the V8 wrapper * node will be merged into one node to simplify retaining paths. / virtual Node WrapperNode() { return nullptr; } virtual bool IsRootNode() { return false; } /** Must return true for non-V8 nodes. / virtual bool IsEmbedderNode() { return true; } /* * Optional name prefix. It is used in Chrome for tagging detached nodes. / virtual const char NamePrefix() { return nullptr; } /** * Returns the NativeObject that can be used for querying the * \|HeapSnapshot\|. / virtual NativeObject GetNativeObject() { return nullptr; } /* * Detachedness state of a given object. While unkown in general, there may * be objects that specifically know their state. V8 passes this information * along in the snapshot. Users of the snapshot may use it to annotate the * object graph. / virtual Detachedness GetDetachedness() { return Detachedness::kUnknown; } /* * Returns the address of the object in the embedder heap, or nullptr to not * specify the address. If this address is provided, then V8 can generate * consistent IDs for objects across subsequent heap snapshots, which allows * devtools to determine which objects were retained from one snapshot to * the next. This value is used only if GetNativeObject returns nullptr. / virtual const void GetAddress() { return nullptr; } Node(const Node&) = delete; Node& operator=(const Node&) = delete; }; /** * Returns a node corresponding to the given V8 value. Ownership is not * transferred. The result pointer is valid while the graph is alive. / virtual Node V8Node(const v8::Local<v8::Value>& value) = 0; /** * Adds the given node to the graph and takes ownership of the node. * Returns a raw pointer to the node that is valid while the graph is alive. / virtual Node AddNode(std::unique_ptr<Node> node) = 0; /** * Adds an edge that represents a strong reference from the given * node \|from\| to the given node \|to\|. The nodes must be added to the graph * before calling this function. * * If name is nullptr, the edge will have auto-increment indexes, otherwise * it will be named accordingly. / virtual void AddEdge(Node from, Node* to, const char* name = nullptr) = 0; virtual ~EmbedderGraph() = default; }; class QueryObjectPredicate { public: virtual ~QueryObjectPredicate() = default; virtual bool Filter(v8::Local<v8::Object> object) = 0; }; /** * Interface for controlling heap profiling. Instance of the * profiler can be retrieved using v8::Isolate::GetHeapProfiler. / class V8_EXPORT HeapProfiler { public: void QueryObjects(v8::Local<v8::Context> context, QueryObjectPredicate predicate, std::vector<v8::Global<v8::Object>>* objects); enum SamplingFlags { kSamplingNoFlags = 0, kSamplingForceGC = 1 << 0, kSamplingIncludeObjectsCollectedByMajorGC = 1 << 1, kSamplingIncludeObjectsCollectedByMinorGC = 1 << 2, }; /** * Callback function invoked during heap snapshot generation to retrieve * the embedder object graph. The callback should use graph->AddEdge(..) to * add references between the objects. * The callback must not trigger garbage collection in V8. / typedef void (BuildEmbedderGraphCallback)(v8::Isolate* isolate, v8::EmbedderGraph* graph, void* data); /** * Callback function invoked during heap snapshot generation to retrieve * the detachedness state of an object referenced by a TracedReference. * * The callback takes Local<Value> as parameter to allow the embedder to * unpack the TracedReference into a Local and reuse that Local for different * purposes. / using GetDetachednessCallback = EmbedderGraph::Node::Detachedness ()( v8::Isolate* isolate, const v8::Local<v8::Value>& v8_value, uint16_t class_id, void* data); /** Returns the number of snapshots taken. / int GetSnapshotCount(); /* Returns a snapshot by index. / const HeapSnapshot GetHeapSnapshot(int index); /** * Returns SnapshotObjectId for a heap object referenced by \|value\| if * it has been seen by the heap profiler, kUnknownObjectId otherwise. / SnapshotObjectId GetObjectId(Local<Value> value); /* * Returns SnapshotObjectId for a native object referenced by \|value\| if it * has been seen by the heap profiler, kUnknownObjectId otherwise. / SnapshotObjectId GetObjectId(NativeObject value); /* * Returns heap object with given SnapshotObjectId if the object is alive, * otherwise empty handle is returned. / Local<Value> FindObjectById(SnapshotObjectId id); /* * Clears internal map from SnapshotObjectId to heap object. The new objects * will not be added into it unless a heap snapshot is taken or heap object * tracking is kicked off. / void ClearObjectIds(); /* * A constant for invalid SnapshotObjectId. GetSnapshotObjectId will return * it in case heap profiler cannot find id for the object passed as * parameter. HeapSnapshot::GetNodeById will always return NULL for such id. / static const SnapshotObjectId kUnknownObjectId = 0; /* * Callback interface for retrieving user friendly names of global objects. / class ObjectNameResolver { public: /* * Returns name to be used in the heap snapshot for given node. Returned * string must stay alive until snapshot collection is completed. / virtual const char GetName(Local<Object> object) = 0; protected: virtual ~ObjectNameResolver() = default; }; enum class HeapSnapshotMode { /** * Heap snapshot for regular developers. / kRegular, /* * Heap snapshot is exposing internals that may be useful for experts. / kExposeInternals, }; enum class NumericsMode { /* * Numeric values are hidden as they are values of the corresponding * objects. / kHideNumericValues, /* * Numeric values are exposed in artificial fields. / kExposeNumericValues }; struct HeapSnapshotOptions final { // Manually define default constructor here to be able to use it in // `TakeSnapshot()` below. // NOLINTNEXTLINE HeapSnapshotOptions() {} /* * The control used to report intermediate progress to. / ActivityControl control = nullptr; /** * The resolver used by the snapshot generator to get names for V8 objects. / ObjectNameResolver global_object_name_resolver = nullptr; /** * Mode for taking the snapshot, see `HeapSnapshotMode`. / HeapSnapshotMode snapshot_mode = HeapSnapshotMode::kRegular; /* * Mode for dealing with numeric values, see `NumericsMode`. / NumericsMode numerics_mode = NumericsMode::kHideNumericValues; /* * Whether stack is considered as a root set. / cppgc::EmbedderStackState stack_state = cppgc::EmbedderStackState::kMayContainHeapPointers; }; /* * Takes a heap snapshot. * * \returns the snapshot. / const HeapSnapshot TakeHeapSnapshot( const HeapSnapshotOptions& options = HeapSnapshotOptions()); /** * Takes a heap snapshot. See `HeapSnapshotOptions` for details on the * parameters. * * \returns the snapshot. / const HeapSnapshot TakeHeapSnapshot( ActivityControl* control, ObjectNameResolver* global_object_name_resolver = nullptr, bool hide_internals = true, bool capture_numeric_value = false); /** * Starts tracking of heap objects population statistics. After calling * this method, all heap objects relocations done by the garbage collector * are being registered. * * \|track_allocations\| parameter controls whether stack trace of each * allocation in the heap will be recorded and reported as part of * HeapSnapshot. / void StartTrackingHeapObjects(bool track_allocations = false); /* * Adds a new time interval entry to the aggregated statistics array. The * time interval entry contains information on the current heap objects * population size. The method also updates aggregated statistics and * reports updates for all previous time intervals via the OutputStream * object. Updates on each time interval are provided as a stream of the * HeapStatsUpdate structure instances. * If \|timestamp_us\| is supplied, timestamp of the new entry will be written * into it. The return value of the function is the last seen heap object Id. * * StartTrackingHeapObjects must be called before the first call to this * method. / SnapshotObjectId GetHeapStats(OutputStream stream, int64_t* timestamp_us = nullptr); /** * Stops tracking of heap objects population statistics, cleans up all * collected data. StartHeapObjectsTracking must be called again prior to * calling GetHeapStats next time. / void StopTrackingHeapObjects(); /* * Starts gathering a sampling heap profile. A sampling heap profile is * similar to tcmalloc's heap profiler and Go's mprof. It samples object * allocations and builds an online 'sampling' heap profile. At any point in * time, this profile is expected to be a representative sample of objects * currently live in the system. Each sampled allocation includes the stack * trace at the time of allocation, which makes this really useful for memory * leak detection. * * This mechanism is intended to be cheap enough that it can be used in * production with minimal performance overhead. * * Allocations are sampled using a randomized Poisson process. On average, one * allocation will be sampled every \|sample_interval\| bytes allocated. The * \|stack_depth\| parameter controls the maximum number of stack frames to be * captured on each allocation. * * NOTE: Support for native allocations doesn't exist yet, but is anticipated * in the future. * * Objects allocated before the sampling is started will not be included in * the profile. * * Returns false if a sampling heap profiler is already running. / bool StartSamplingHeapProfiler(uint64_t sample_interval = 512 1024, int stack_depth = 16, SamplingFlags flags = kSamplingNoFlags); /** * Stops the sampling heap profile and discards the current profile. / void StopSamplingHeapProfiler(); /* * Returns the sampled profile of allocations allocated (and still live) since * StartSamplingHeapProfiler was called. The ownership of the pointer is * transferred to the caller. Returns nullptr if sampling heap profiler is not * active. / AllocationProfile GetAllocationProfile(); /** * Deletes all snapshots taken. All previously returned pointers to * snapshots and their contents become invalid after this call. / void DeleteAllHeapSnapshots(); void AddBuildEmbedderGraphCallback(BuildEmbedderGraphCallback callback, void data); void RemoveBuildEmbedderGraphCallback(BuildEmbedderGraphCallback callback, void* data); void SetGetDetachednessCallback(GetDetachednessCallback callback, void* data); /** * Default value of persistent handle class ID. Must not be used to * define a class. Can be used to reset a class of a persistent * handle. / static const uint16_t kPersistentHandleNoClassId = 0; private: HeapProfiler(); ~HeapProfiler(); HeapProfiler(const HeapProfiler&); HeapProfiler& operator=(const HeapProfiler&); }; /* * A struct for exporting HeapStats data from V8, using "push" model. * See HeapProfiler::GetHeapStats. / struct HeapStatsUpdate { HeapStatsUpdate(uint32_t index, uint32_t count, uint32_t size) : index(index), count(count), size(size) { } uint32_t index; // Index of the time interval that was changed. uint32_t count; // New value of count field for the interval with this index. uint32_t size; // New value of size field for the interval with this index. }; #define CODE_EVENTS_LIST(V) \ V(Builtin) \ V(Callback) \ V(Eval) \ V(Function) \ V(InterpretedFunction) \ V(Handler) \ V(BytecodeHandler) \ V(LazyCompile) / Unused, use kFunction instead / \ V(RegExp) \ V(Script) \ V(Stub) \ V(Relocation) /* * Note that this enum may be extended in the future. Please include a default * case if this enum is used in a switch statement. / enum CodeEventType { kUnknownType = 0 #define V(Name) , k##Name##Type CODE_EVENTS_LIST(V) #undef V }; /* * Representation of a code creation event / class V8_EXPORT CodeEvent { public: uintptr_t GetCodeStartAddress(); size_t GetCodeSize(); Local<String> GetFunctionName(); Local<String> GetScriptName(); int GetScriptLine(); int GetScriptColumn(); /* * NOTE (mmarchini): We can't allocate objects in the heap when we collect * existing code, and both the code type and the comment are not stored in the * heap, so we return those as const char. / CodeEventType GetCodeType(); const char* GetComment(); static const char* GetCodeEventTypeName(CodeEventType code_event_type); uintptr_t GetPreviousCodeStartAddress(); }; /** * Interface to listen to code creation and code relocation events. / class V8_EXPORT CodeEventHandler { public: /* * Creates a new listener for the \|isolate\|. The isolate must be initialized. * The listener object must be disposed after use by calling \|Dispose\| method. * Multiple listeners can be created for the same isolate. / explicit CodeEventHandler(Isolate isolate); virtual ~CodeEventHandler(); /** * Handle is called every time a code object is created or moved. Information * about each code event will be available through the `code_event` * parameter. * * When the CodeEventType is kRelocationType, the code for this CodeEvent has * moved from `GetPreviousCodeStartAddress()` to `GetCodeStartAddress()`. / virtual void Handle(CodeEvent code_event) = 0; /** * Call `Enable()` to starts listening to code creation and code relocation * events. These events will be handled by `Handle()`. / void Enable(); /* * Call `Disable()` to stop listening to code creation and code relocation * events. / void Disable(); private: CodeEventHandler(); CodeEventHandler(const CodeEventHandler&); CodeEventHandler& operator=(const CodeEventHandler&); void internal_listener_; }; } // namespace v8 #endif // V8_V8_PROFILER_H_	41.11 KB	2025-03-03 12:36
📄 v8-promise.h // Copyright 2021 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. #ifndef INCLUDE_V8_PROMISE_H_ #define INCLUDE_V8_PROMISE_H_ #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; #ifndef V8_PROMISE_INTERNAL_FIELD_COUNT // The number of required internal fields can be defined by embedder. #define V8_PROMISE_INTERNAL_FIELD_COUNT 0 #endif /** * An instance of the built-in Promise constructor (ES6 draft). / class V8_EXPORT Promise : public Object { public: /* * State of the promise. Each value corresponds to one of the possible values * of the [[PromiseState]] field. / enum PromiseState { kPending, kFulfilled, kRejected }; class V8_EXPORT Resolver : public Object { public: /* * Create a new resolver, along with an associated promise in pending state. / static V8_WARN_UNUSED_RESULT MaybeLocal<Resolver> New( Local<Context> context); /* * Extract the associated promise. / Local<Promise> GetPromise(); /* * Resolve/reject the associated promise with a given value. * Ignored if the promise is no longer pending. / V8_WARN_UNUSED_RESULT Maybe<bool> Resolve(Local<Context> context, Local<Value> value); V8_WARN_UNUSED_RESULT Maybe<bool> Reject(Local<Context> context, Local<Value> value); V8_INLINE static Resolver Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Promise::Resolver>(value); } private: Resolver(); static void CheckCast(Value obj); }; /** * Register a resolution/rejection handler with a promise. * The handler is given the respective resolution/rejection value as * an argument. If the promise is already resolved/rejected, the handler is * invoked at the end of turn. / V8_WARN_UNUSED_RESULT MaybeLocal<Promise> Catch(Local<Context> context, Local<Function> handler); V8_WARN_UNUSED_RESULT MaybeLocal<Promise> Then(Local<Context> context, Local<Function> handler); V8_WARN_UNUSED_RESULT MaybeLocal<Promise> Then(Local<Context> context, Local<Function> on_fulfilled, Local<Function> on_rejected); /* * Returns true if the promise has at least one derived promise, and * therefore resolve/reject handlers (including default handler). / bool HasHandler() const; /* * Returns the content of the [[PromiseResult]] field. The Promise must not * be pending. / Local<Value> Result(); /* * Returns the value of the [[PromiseState]] field. / PromiseState State(); /* * Marks this promise as handled to avoid reporting unhandled rejections. / void MarkAsHandled(); /* * Marks this promise as silent to prevent pausing the debugger when the * promise is rejected. / void MarkAsSilent(); V8_INLINE static Promise Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Promise>(value); } static const int kEmbedderFieldCount = V8_PROMISE_INTERNAL_FIELD_COUNT; private: Promise(); static void CheckCast(Value obj); }; /** * PromiseHook with type kInit is called when a new promise is * created. When a new promise is created as part of the chain in the * case of Promise.then or in the intermediate promises created by * Promise.{race, all}/AsyncFunctionAwait, we pass the parent promise * otherwise we pass undefined. * * PromiseHook with type kResolve is called at the beginning of * resolve or reject function defined by CreateResolvingFunctions. * * PromiseHook with type kBefore is called at the beginning of the * PromiseReactionJob. * * PromiseHook with type kAfter is called right at the end of the * PromiseReactionJob. / enum class PromiseHookType { kInit, kResolve, kBefore, kAfter }; using PromiseHook = void ()(PromiseHookType type, Local<Promise> promise, Local<Value> parent); // --- Promise Reject Callback --- enum PromiseRejectEvent { kPromiseRejectWithNoHandler = 0, kPromiseHandlerAddedAfterReject = 1, kPromiseRejectAfterResolved = 2, kPromiseResolveAfterResolved = 3, }; class PromiseRejectMessage { public: PromiseRejectMessage(Local<Promise> promise, PromiseRejectEvent event, Local<Value> value) : promise_(promise), event_(event), value_(value) {} V8_INLINE Local<Promise> GetPromise() const { return promise_; } V8_INLINE PromiseRejectEvent GetEvent() const { return event_; } V8_INLINE Local<Value> GetValue() const { return value_; } private: Local<Promise> promise_; PromiseRejectEvent event_; Local<Value> value_; }; using PromiseRejectCallback = void (*)(PromiseRejectMessage message); } // namespace v8 #endif // INCLUDE_V8_PROMISE_H_	5.17 KB	2025-03-03 12:36
📄 v8-proxy.h // Copyright 2021 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. #ifndef INCLUDE_V8_PROXY_H_ #define INCLUDE_V8_PROXY_H_ #include "v8-context.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; /** * An instance of the built-in Proxy constructor (ECMA-262, 6th Edition, * 26.2.1). / class V8_EXPORT Proxy : public Object { public: Local<Value> GetTarget(); Local<Value> GetHandler(); bool IsRevoked() const; void Revoke(); /* * Creates a new Proxy for the target object. / static MaybeLocal<Proxy> New(Local<Context> context, Local<Object> local_target, Local<Object> local_handler); V8_INLINE static Proxy Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Proxy>(value); } private: Proxy(); static void CheckCast(Value obj); }; } // namespace v8 #endif // INCLUDE_V8_PROXY_H_	1.23 KB	2025-03-03 12:36
📄 v8-regexp.h // Copyright 2021 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. #ifndef INCLUDE_V8_REGEXP_H_ #define INCLUDE_V8_REGEXP_H_ #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; /** * An instance of the built-in RegExp constructor (ECMA-262, 15.10). / class V8_EXPORT RegExp : public Object { public: /* * Regular expression flag bits. They can be or'ed to enable a set * of flags. * The kLinear value ('l') is experimental and can only be used with * --enable-experimental-regexp-engine. RegExps with kLinear flag are * guaranteed to be executed in asymptotic linear time wrt. the length of * the subject string. / enum Flags { kNone = 0, kGlobal = 1 << 0, kIgnoreCase = 1 << 1, kMultiline = 1 << 2, kSticky = 1 << 3, kUnicode = 1 << 4, kDotAll = 1 << 5, kLinear = 1 << 6, kHasIndices = 1 << 7, kUnicodeSets = 1 << 8, }; static constexpr int kFlagCount = 9; /* * Creates a regular expression from the given pattern string and * the flags bit field. May throw a JavaScript exception as * described in ECMA-262, 15.10.4.1. * * For example, * RegExp::New(v8::String::New("foo"), * static_cast<RegExp::Flags>(kGlobal \| kMultiline)) * is equivalent to evaluating "/foo/gm". / static V8_WARN_UNUSED_RESULT MaybeLocal<RegExp> New(Local<Context> context, Local<String> pattern, Flags flags); /* * Like New, but additionally specifies a backtrack limit. If the number of * backtracks done in one Exec call hits the limit, a match failure is * immediately returned. / static V8_WARN_UNUSED_RESULT MaybeLocal<RegExp> NewWithBacktrackLimit( Local<Context> context, Local<String> pattern, Flags flags, uint32_t backtrack_limit); /* * Executes the current RegExp instance on the given subject string. * Equivalent to RegExp.prototype.exec as described in * * https://tc39.es/ecma262/#sec-regexp.prototype.exec * * On success, an Array containing the matched strings is returned. On * failure, returns Null. * * Note: modifies global context state, accessible e.g. through RegExp.input. / V8_WARN_UNUSED_RESULT MaybeLocal<Object> Exec(Local<Context> context, Local<String> subject); /* * Returns the value of the source property: a string representing * the regular expression. / Local<String> GetSource() const; /* * Returns the flags bit field. / Flags GetFlags() const; V8_INLINE static RegExp Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<RegExp>(value); } private: static void CheckCast(Value obj); }; } // namespace v8 #endif // INCLUDE_V8_REGEXP_H_	3.1 KB	2025-03-03 12:36
📄 v8-script.h // Copyright 2021 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. #ifndef INCLUDE_V8_SCRIPT_H_ #define INCLUDE_V8_SCRIPT_H_ #include <stddef.h> #include <stdint.h> #include <memory> #include <tuple> #include <vector> #include "v8-callbacks.h" // NOLINT(build/include_directory) #include "v8-data.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-maybe.h" // NOLINT(build/include_directory) #include "v8-memory-span.h" // NOLINT(build/include_directory) #include "v8-message.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Function; class Message; class Object; class PrimitiveArray; class Script; namespace internal { class BackgroundDeserializeTask; struct ScriptStreamingData; } // namespace internal /** * A container type that holds relevant metadata for module loading. * * This is passed back to the embedder as part of * HostImportModuleDynamicallyCallback for module loading. / class V8_EXPORT ScriptOrModule { public: /* * The name that was passed by the embedder as ResourceName to the * ScriptOrigin. This can be either a v8::String or v8::Undefined. / Local<Value> GetResourceName(); /* * The options that were passed by the embedder as HostDefinedOptions to * the ScriptOrigin. / Local<Data> HostDefinedOptions(); }; /* * A compiled JavaScript script, not yet tied to a Context. / class V8_EXPORT UnboundScript : public Data { public: /* * Binds the script to the currently entered context. / Local<Script> BindToCurrentContext(); int GetId() const; Local<Value> GetScriptName(); /* * Data read from magic sourceURL comments. / Local<Value> GetSourceURL(); /* * Data read from magic sourceMappingURL comments. / Local<Value> GetSourceMappingURL(); /* * Returns zero based line number of the code_pos location in the script. * -1 will be returned if no information available. / int GetLineNumber(int code_pos = 0); /* * Returns zero based column number of the code_pos location in the script. * -1 will be returned if no information available. / int GetColumnNumber(int code_pos = 0); static const int kNoScriptId = 0; }; /* * A compiled JavaScript module, not yet tied to a Context. / class V8_EXPORT UnboundModuleScript : public Data { public: /* * Data read from magic sourceURL comments. / Local<Value> GetSourceURL(); /* * Data read from magic sourceMappingURL comments. / Local<Value> GetSourceMappingURL(); }; /* * A location in JavaScript source. / class V8_EXPORT Location { public: int GetLineNumber() { return line_number_; } int GetColumnNumber() { return column_number_; } Location(int line_number, int column_number) : line_number_(line_number), column_number_(column_number) {} private: int line_number_; int column_number_; }; class V8_EXPORT ModuleRequest : public Data { public: /* * Returns the module specifier for this ModuleRequest. / Local<String> GetSpecifier() const; /* * Returns the source code offset of this module request. * Use Module::SourceOffsetToLocation to convert this to line/column numbers. / int GetSourceOffset() const; /* * Contains the import attributes for this request in the form: * [key1, value1, source_offset1, key2, value2, source_offset2, ...]. * The keys and values are of type v8::String, and the source offsets are of * type Int32. Use Module::SourceOffsetToLocation to convert the source * offsets to Locations with line/column numbers. * * All attributes present in the module request will be supplied in this * list, regardless of whether they are supported by the host. Per * https://tc39.es/proposal-import-attributes/#sec-hostgetsupportedimportattributes, * hosts are expected to throw for attributes that they do not support (as * opposed to, for example, ignoring them). / Local<FixedArray> GetImportAttributes() const; V8_DEPRECATE_SOON("Use GetImportAttributes instead") Local<FixedArray> GetImportAssertions() const { return GetImportAttributes(); } V8_INLINE static ModuleRequest Cast(Data* data); private: static void CheckCast(Data* obj); }; /** * A compiled JavaScript module. / class V8_EXPORT Module : public Data { public: /* * The different states a module can be in. * * This corresponds to the states used in ECMAScript except that "evaluated" * is split into kEvaluated and kErrored, indicating success and failure, * respectively. / enum Status { kUninstantiated, kInstantiating, kInstantiated, kEvaluating, kEvaluated, kErrored }; /* * Returns the module's current status. / Status GetStatus() const; /* * For a module in kErrored status, this returns the corresponding exception. / Local<Value> GetException() const; /* * Returns the ModuleRequests for this module. / Local<FixedArray> GetModuleRequests() const; /* * For the given source text offset in this module, returns the corresponding * Location with line and column numbers. / Location SourceOffsetToLocation(int offset) const; /* * Returns the identity hash for this object. / int GetIdentityHash() const; using ResolveModuleCallback = MaybeLocal<Module> ()( Local<Context> context, Local<String> specifier, Local<FixedArray> import_assertions, Local<Module> referrer); /** * Instantiates the module and its dependencies. * * Returns an empty Maybe<bool> if an exception occurred during * instantiation. (In the case where the callback throws an exception, that * exception is propagated.) / V8_WARN_UNUSED_RESULT Maybe<bool> InstantiateModule( Local<Context> context, ResolveModuleCallback callback); /* * Evaluates the module and its dependencies. * * If status is kInstantiated, run the module's code and return a Promise * object. On success, set status to kEvaluated and resolve the Promise with * the completion value; on failure, set status to kErrored and reject the * Promise with the error. * * If IsGraphAsync() is false, the returned Promise is settled. / V8_WARN_UNUSED_RESULT MaybeLocal<Value> Evaluate(Local<Context> context); /* * Returns the namespace object of this module. * * The module's status must be at least kInstantiated. / Local<Value> GetModuleNamespace(); /* * Returns the corresponding context-unbound module script. * * The module must be unevaluated, i.e. its status must not be kEvaluating, * kEvaluated or kErrored. / Local<UnboundModuleScript> GetUnboundModuleScript(); /* * Returns the underlying script's id. * * The module must be a SourceTextModule and must not have a kErrored status. / int ScriptId() const; /* * Returns whether this module or any of its requested modules is async, * i.e. contains top-level await. * * The module's status must be at least kInstantiated. / bool IsGraphAsync() const; /* * Returns whether the module is a SourceTextModule. / bool IsSourceTextModule() const; /* * Returns whether the module is a SyntheticModule. / bool IsSyntheticModule() const; / * Callback defined in the embedder. This is responsible for setting * the module's exported values with calls to SetSyntheticModuleExport(). * The callback must return a resolved Promise to indicate success (where no * exception was thrown) and return an empy MaybeLocal to indicate falure * (where an exception was thrown). / using SyntheticModuleEvaluationSteps = MaybeLocal<Value> ()(Local<Context> context, Local<Module> module); /** * Creates a new SyntheticModule with the specified export names, where * evaluation_steps will be executed upon module evaluation. * export_names must not contain duplicates. * module_name is used solely for logging/debugging and doesn't affect module * behavior. / static Local<Module> CreateSyntheticModule( Isolate isolate, Local<String> module_name, const MemorySpan<const Local<String>>& export_names, SyntheticModuleEvaluationSteps evaluation_steps); /** * Set this module's exported value for the name export_name to the specified * export_value. This method must be called only on Modules created via * CreateSyntheticModule. An error will be thrown if export_name is not one * of the export_names that were passed in that CreateSyntheticModule call. * Returns Just(true) on success, Nothing<bool>() if an error was thrown. / V8_WARN_UNUSED_RESULT Maybe<bool> SetSyntheticModuleExport( Isolate isolate, Local<String> export_name, Local<Value> export_value); /** * Search the modules requested directly or indirectly by the module for * any top-level await that has not yet resolved. If there is any, the * returned pair of vectors (of equal size) contain the unresolved module * and corresponding message with the pending top-level await. * An embedder may call this before exiting to improve error messages. / std::pair<LocalVector<Module>, LocalVector<Message>> GetStalledTopLevelAwaitMessages(Isolate isolate); V8_INLINE static Module* Cast(Data* data); private: static void CheckCast(Data* obj); }; /** * A compiled JavaScript script, tied to a Context which was active when the * script was compiled. / class V8_EXPORT Script : public Data { public: /* * A shorthand for ScriptCompiler::Compile(). / static V8_WARN_UNUSED_RESULT MaybeLocal<Script> Compile( Local<Context> context, Local<String> source, ScriptOrigin origin = nullptr); /** * Runs the script returning the resulting value. It will be run in the * context in which it was created (ScriptCompiler::CompileBound or * UnboundScript::BindToCurrentContext()). / V8_WARN_UNUSED_RESULT MaybeLocal<Value> Run(Local<Context> context); V8_WARN_UNUSED_RESULT MaybeLocal<Value> Run(Local<Context> context, Local<Data> host_defined_options); /* * Returns the corresponding context-unbound script. / Local<UnboundScript> GetUnboundScript(); /* * The name that was passed by the embedder as ResourceName to the * ScriptOrigin. This can be either a v8::String or v8::Undefined. / Local<Value> GetResourceName(); /* * If the script was compiled, returns the positions of lazy functions which * were eventually compiled and executed. / std::vector<int> GetProducedCompileHints() const; }; enum class ScriptType { kClassic, kModule }; /* * For compiling scripts. / class V8_EXPORT ScriptCompiler { public: class ConsumeCodeCacheTask; /* * Compilation data that the embedder can cache and pass back to speed up * future compilations. The data is produced if the CompilerOptions passed to * the compilation functions in ScriptCompiler contains produce_data_to_cache * = true. The data to cache can then can be retrieved from * UnboundScript. / struct V8_EXPORT CachedData { enum BufferPolicy { BufferNotOwned, BufferOwned }; CachedData() : data(nullptr), length(0), rejected(false), buffer_policy(BufferNotOwned) {} // If buffer_policy is BufferNotOwned, the caller keeps the ownership of // data and guarantees that it stays alive until the CachedData object is // destroyed. If the policy is BufferOwned, the given data will be deleted // (with delete[]) when the CachedData object is destroyed. CachedData(const uint8_t data, int length, BufferPolicy buffer_policy = BufferNotOwned); ~CachedData(); enum CompatibilityCheckResult { // Don't change order/existing values of this enum since it keys into the // `code_cache_reject_reason` histogram. Append-only! kSuccess = 0, kMagicNumberMismatch = 1, kVersionMismatch = 2, kSourceMismatch = 3, kFlagsMismatch = 5, kChecksumMismatch = 6, kInvalidHeader = 7, kLengthMismatch = 8, kReadOnlySnapshotChecksumMismatch = 9, // This should always point at the last real enum value. kLast = kReadOnlySnapshotChecksumMismatch }; // Check if the CachedData can be loaded in the given isolate. CompatibilityCheckResult CompatibilityCheck(Isolate* isolate); // TODO(marja): Async compilation; add constructors which take a callback // which will be called when V8 no longer needs the data. const uint8_t* data; int length; bool rejected; BufferPolicy buffer_policy; // Prevent copying. CachedData(const CachedData&) = delete; CachedData& operator=(const CachedData&) = delete; }; enum class InMemoryCacheResult { // V8 did not attempt to find this script in its in-memory cache. kNotAttempted, // V8 found a previously compiled copy of this script in its in-memory // cache. Any data generated by a streaming compilation or background // deserialization was abandoned. kHit, // V8 didn't have any previously compiled data for this script. kMiss, // V8 had some previously compiled data for an identical script, but the // data was incomplete. kPartial, }; // Details about what happened during a compilation. struct CompilationDetails { InMemoryCacheResult in_memory_cache_result = InMemoryCacheResult::kNotAttempted; static constexpr int64_t kTimeNotMeasured = -1; int64_t foreground_time_in_microseconds = kTimeNotMeasured; int64_t background_time_in_microseconds = kTimeNotMeasured; }; /** * Source code which can be then compiled to a UnboundScript or Script. / class Source { public: // Source takes ownership of both CachedData and CodeCacheConsumeTask. // The caller must* ensure that the cached data is from a trusted source. V8_INLINE Source(Local<String> source_string, const ScriptOrigin& origin, CachedData* cached_data = nullptr, ConsumeCodeCacheTask* consume_cache_task = nullptr); // Source takes ownership of both CachedData and CodeCacheConsumeTask. V8_INLINE explicit Source( Local<String> source_string, CachedData* cached_data = nullptr, ConsumeCodeCacheTask* consume_cache_task = nullptr); V8_INLINE Source(Local<String> source_string, const ScriptOrigin& origin, CompileHintCallback callback, void* callback_data); V8_INLINE ~Source() = default; // Ownership of the CachedData or its buffers is not transferred to the // caller. The CachedData object is alive as long as the Source object is // alive. V8_INLINE const CachedData* GetCachedData() const; V8_INLINE const ScriptOriginOptions& GetResourceOptions() const; V8_INLINE const CompilationDetails& GetCompilationDetails() const; private: friend class ScriptCompiler; Local<String> source_string; // Origin information Local<Value> resource_name; int resource_line_offset = -1; int resource_column_offset = -1; ScriptOriginOptions resource_options; Local<Value> source_map_url; Local<Data> host_defined_options; // Cached data from previous compilation (if a kConsumeCache flag is // set), or hold newly generated cache data (kProduceCache flags) are // set when calling a compile method. std::unique_ptr<CachedData> cached_data; std::unique_ptr<ConsumeCodeCacheTask> consume_cache_task; // For requesting compile hints from the embedder. CompileHintCallback compile_hint_callback = nullptr; void* compile_hint_callback_data = nullptr; // V8 writes this data and never reads it. It exists only to be informative // to the embedder. CompilationDetails compilation_details; }; /** * For streaming incomplete script data to V8. The embedder should implement a * subclass of this class. / class V8_EXPORT ExternalSourceStream { public: virtual ~ExternalSourceStream() = default; /* * V8 calls this to request the next chunk of data from the embedder. This * function will be called on a background thread, so it's OK to block and * wait for the data, if the embedder doesn't have data yet. Returns the * length of the data returned. When the data ends, GetMoreData should * return 0. Caller takes ownership of the data. * * When streaming UTF-8 data, V8 handles multi-byte characters split between * two data chunks, but doesn't handle multi-byte characters split between * more than two data chunks. The embedder can avoid this problem by always * returning at least 2 bytes of data. * * When streaming UTF-16 data, V8 does not handle characters split between * two data chunks. The embedder has to make sure that chunks have an even * length. * * If the embedder wants to cancel the streaming, they should make the next * GetMoreData call return 0. V8 will interpret it as end of data (and most * probably, parsing will fail). The streaming task will return as soon as * V8 has parsed the data it received so far. / virtual size_t GetMoreData(const uint8_t* src) = 0; }; /** * Source code which can be streamed into V8 in pieces. It will be parsed * while streaming and compiled after parsing has completed. StreamedSource * must be kept alive while the streaming task is run (see ScriptStreamingTask * below). / class V8_EXPORT StreamedSource { public: enum Encoding { ONE_BYTE, TWO_BYTE, UTF8, WINDOWS_1252 }; StreamedSource(std::unique_ptr<ExternalSourceStream> source_stream, Encoding encoding); ~StreamedSource(); internal::ScriptStreamingData impl() const { return impl_.get(); } // Prevent copying. StreamedSource(const StreamedSource&) = delete; StreamedSource& operator=(const StreamedSource&) = delete; CompilationDetails& compilation_details() { return compilation_details_; } private: std::unique_ptr<internal::ScriptStreamingData> impl_; // V8 writes this data and never reads it. It exists only to be informative // to the embedder. CompilationDetails compilation_details_; }; /** * A streaming task which the embedder must run on a background thread to * stream scripts into V8. Returned by ScriptCompiler::StartStreaming. / class V8_EXPORT ScriptStreamingTask final { public: void Run(); private: friend class ScriptCompiler; explicit ScriptStreamingTask(internal::ScriptStreamingData data) : data_(data) {} internal::ScriptStreamingData* data_; }; /** * A task which the embedder must run on a background thread to * consume a V8 code cache. Returned by * ScriptCompiler::StartConsumingCodeCache. / class V8_EXPORT ConsumeCodeCacheTask final { public: ~ConsumeCodeCacheTask(); void Run(); /* * Provides the source text string and origin information to the consumption * task. May be called before, during, or after Run(). This step checks * whether the script matches an existing script in the Isolate's * compilation cache. To check whether such a script was found, call * ShouldMergeWithExistingScript. * * The Isolate provided must be the same one used during * StartConsumingCodeCache and must be currently entered on the thread that * calls this function. The source text and origin provided in this step * must precisely match those used later in the ScriptCompiler::Source that * will contain this ConsumeCodeCacheTask. / void SourceTextAvailable(Isolate isolate, Local<String> source_text, const ScriptOrigin& origin); /** * Returns whether the embedder should call MergeWithExistingScript. This * function may be called from any thread, any number of times, but its * return value is only meaningful after SourceTextAvailable has completed. / bool ShouldMergeWithExistingScript() const; /* * Merges newly deserialized data into an existing script which was found * during SourceTextAvailable. May be called only after Run() has completed. * Can execute on any thread, like Run(). / void MergeWithExistingScript(); private: friend class ScriptCompiler; explicit ConsumeCodeCacheTask( std::unique_ptr<internal::BackgroundDeserializeTask> impl); std::unique_ptr<internal::BackgroundDeserializeTask> impl_; }; enum CompileOptions { kNoCompileOptions = 0, kConsumeCodeCache, kEagerCompile, kProduceCompileHints, kConsumeCompileHints }; /* * The reason for which we are not requesting or providing a code cache. / enum NoCacheReason { kNoCacheNoReason = 0, kNoCacheBecauseCachingDisabled, kNoCacheBecauseNoResource, kNoCacheBecauseInlineScript, kNoCacheBecauseModule, kNoCacheBecauseStreamingSource, kNoCacheBecauseInspector, kNoCacheBecauseScriptTooSmall, kNoCacheBecauseCacheTooCold, kNoCacheBecauseV8Extension, kNoCacheBecauseExtensionModule, kNoCacheBecausePacScript, kNoCacheBecauseInDocumentWrite, kNoCacheBecauseResourceWithNoCacheHandler, kNoCacheBecauseDeferredProduceCodeCache }; /* * Compiles the specified script (context-independent). * Cached data as part of the source object can be optionally produced to be * consumed later to speed up compilation of identical source scripts. * * Note that when producing cached data, the source must point to NULL for * cached data. When consuming cached data, the cached data must have been * produced by the same version of V8, and the embedder needs to ensure the * cached data is the correct one for the given script. * * \param source Script source code. * \return Compiled script object (context independent; for running it must be * bound to a context). / static V8_WARN_UNUSED_RESULT MaybeLocal<UnboundScript> CompileUnboundScript( Isolate isolate, Source* source, CompileOptions options = kNoCompileOptions, NoCacheReason no_cache_reason = kNoCacheNoReason); /** * Compiles the specified script (bound to current context). * * \param source Script source code. * \param pre_data Pre-parsing data, as obtained by ScriptData::PreCompile() * using pre_data speeds compilation if it's done multiple times. * Owned by caller, no references are kept when this function returns. * \return Compiled script object, bound to the context that was active * when this function was called. When run it will always use this * context. / static V8_WARN_UNUSED_RESULT MaybeLocal<Script> Compile( Local<Context> context, Source source, CompileOptions options = kNoCompileOptions, NoCacheReason no_cache_reason = kNoCacheNoReason); /** * Returns a task which streams script data into V8, or NULL if the script * cannot be streamed. The user is responsible for running the task on a * background thread and deleting it. When ran, the task starts parsing the * script, and it will request data from the StreamedSource as needed. When * ScriptStreamingTask::Run exits, all data has been streamed and the script * can be compiled (see Compile below). * * This API allows to start the streaming with as little data as possible, and * the remaining data (for example, the ScriptOrigin) is passed to Compile. / static ScriptStreamingTask StartStreaming( Isolate* isolate, StreamedSource* source, ScriptType type = ScriptType::kClassic, CompileOptions options = kNoCompileOptions, CompileHintCallback compile_hint_callback = nullptr, void* compile_hint_callback_data = nullptr); static ConsumeCodeCacheTask* StartConsumingCodeCache( Isolate* isolate, std::unique_ptr<CachedData> source); /** * Compiles a streamed script (bound to current context). * * This can only be called after the streaming has finished * (ScriptStreamingTask has been run). V8 doesn't construct the source string * during streaming, so the embedder needs to pass the full source here. / static V8_WARN_UNUSED_RESULT MaybeLocal<Script> Compile( Local<Context> context, StreamedSource source, Local<String> full_source_string, const ScriptOrigin& origin); /** * Return a version tag for CachedData for the current V8 version & flags. * * This value is meant only for determining whether a previously generated * CachedData instance is still valid; the tag has no other meaing. * * Background: The data carried by CachedData may depend on the exact * V8 version number or current compiler flags. This means that when * persisting CachedData, the embedder must take care to not pass in * data from another V8 version, or the same version with different * features enabled. * * The easiest way to do so is to clear the embedder's cache on any * such change. * * Alternatively, this tag can be stored alongside the cached data and * compared when it is being used. / static uint32_t CachedDataVersionTag(); /* * Compile an ES module, returning a Module that encapsulates * the compiled code. * * Corresponds to the ParseModule abstract operation in the * ECMAScript specification. / static V8_WARN_UNUSED_RESULT MaybeLocal<Module> CompileModule( Isolate isolate, Source* source, CompileOptions options = kNoCompileOptions, NoCacheReason no_cache_reason = kNoCacheNoReason); /** * Compiles a streamed module script. * * This can only be called after the streaming has finished * (ScriptStreamingTask has been run). V8 doesn't construct the source string * during streaming, so the embedder needs to pass the full source here. / static V8_WARN_UNUSED_RESULT MaybeLocal<Module> CompileModule( Local<Context> context, StreamedSource v8_source, Local<String> full_source_string, const ScriptOrigin& origin); /** * Compile a function for a given context. This is equivalent to running * * with (obj) { * return function(args) { ... } * } * * It is possible to specify multiple context extensions (obj in the above * example). / V8_DEPRECATED("Use CompileFunction") static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunctionInContext( Local<Context> context, Source source, size_t arguments_count, Local<String> arguments[], size_t context_extension_count, Local<Object> context_extensions[], CompileOptions options = kNoCompileOptions, NoCacheReason no_cache_reason = kNoCacheNoReason, Local<ScriptOrModule>* script_or_module_out = nullptr); static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunction( Local<Context> context, Source* source, size_t arguments_count = 0, Local<String> arguments[] = nullptr, size_t context_extension_count = 0, Local<Object> context_extensions[] = nullptr, CompileOptions options = kNoCompileOptions, NoCacheReason no_cache_reason = kNoCacheNoReason); /** * Creates and returns code cache for the specified unbound_script. * This will return nullptr if the script cannot be serialized. The * CachedData returned by this function should be owned by the caller. / static CachedData CreateCodeCache(Local<UnboundScript> unbound_script); /** * Creates and returns code cache for the specified unbound_module_script. * This will return nullptr if the script cannot be serialized. The * CachedData returned by this function should be owned by the caller. / static CachedData CreateCodeCache( Local<UnboundModuleScript> unbound_module_script); /** * Creates and returns code cache for the specified function that was * previously produced by CompileFunction. * This will return nullptr if the script cannot be serialized. The * CachedData returned by this function should be owned by the caller. / static CachedData CreateCodeCacheForFunction(Local<Function> function); private: static V8_WARN_UNUSED_RESULT MaybeLocal<UnboundScript> CompileUnboundInternal( Isolate* isolate, Source* source, CompileOptions options, NoCacheReason no_cache_reason); static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunctionInternal( Local<Context> context, Source* source, size_t arguments_count, Local<String> arguments[], size_t context_extension_count, Local<Object> context_extensions[], CompileOptions options, NoCacheReason no_cache_reason, Local<ScriptOrModule>* script_or_module_out); }; ScriptCompiler::Source::Source(Local<String> string, const ScriptOrigin& origin, CachedData* data, ConsumeCodeCacheTask* consume_cache_task) : source_string(string), resource_name(origin.ResourceName()), resource_line_offset(origin.LineOffset()), resource_column_offset(origin.ColumnOffset()), resource_options(origin.Options()), source_map_url(origin.SourceMapUrl()), host_defined_options(origin.GetHostDefinedOptions()), cached_data(data), consume_cache_task(consume_cache_task) {} ScriptCompiler::Source::Source(Local<String> string, CachedData* data, ConsumeCodeCacheTask* consume_cache_task) : source_string(string), cached_data(data), consume_cache_task(consume_cache_task) {} ScriptCompiler::Source::Source(Local<String> string, const ScriptOrigin& origin, CompileHintCallback callback, void* callback_data) : source_string(string), resource_name(origin.ResourceName()), resource_line_offset(origin.LineOffset()), resource_column_offset(origin.ColumnOffset()), resource_options(origin.Options()), source_map_url(origin.SourceMapUrl()), host_defined_options(origin.GetHostDefinedOptions()), compile_hint_callback(callback), compile_hint_callback_data(callback_data) {} const ScriptCompiler::CachedData* ScriptCompiler::Source::GetCachedData() const { return cached_data.get(); } const ScriptOriginOptions& ScriptCompiler::Source::GetResourceOptions() const { return resource_options; } const ScriptCompiler::CompilationDetails& ScriptCompiler::Source::GetCompilationDetails() const { return compilation_details; } ModuleRequest* ModuleRequest::Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return reinterpret_cast<ModuleRequest>(data); } Module Module::Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return reinterpret_cast<Module*>(data); } } // namespace v8 #endif // INCLUDE_V8_SCRIPT_H_	30.59 KB	2025-03-03 12:36
📄 v8-snapshot.h // Copyright 2021 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. #ifndef INCLUDE_V8_SNAPSHOT_H_ #define INCLUDE_V8_SNAPSHOT_H_ #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-isolate.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Object; namespace internal { class SnapshotCreatorImpl; } // namespace internal class V8_EXPORT StartupData { public: /** * Whether the data created can be rehashed and and the hash seed can be * recomputed when deserialized. * Only valid for StartupData returned by SnapshotCreator::CreateBlob(). / bool CanBeRehashed() const; /* * Allows embedders to verify whether the data is valid for the current * V8 instance. / bool IsValid() const; const char data; int raw_size; }; /** * Callback and supporting data used in SnapshotCreator to implement embedder * logic to serialize internal fields of v8::Objects. * Internal fields that directly reference V8 objects are serialized without * calling this callback. Internal fields that contain aligned pointers are * serialized by this callback if it returns non-zero result. Otherwise it is * serialized verbatim. / struct SerializeInternalFieldsCallback { using CallbackFunction = StartupData ()(Local<Object> holder, int index, void* data); SerializeInternalFieldsCallback(CallbackFunction function = nullptr, void* data_arg = nullptr) : callback(function), data(data_arg) {} CallbackFunction callback; void* data; }; /** * Similar to SerializeInternalFieldsCallback, but works with the embedder data * in a v8::Context. / struct SerializeContextDataCallback { using CallbackFunction = StartupData ()(Local<Context> holder, int index, void* data); SerializeContextDataCallback(CallbackFunction function = nullptr, void* data_arg = nullptr) : callback(function), data(data_arg) {} CallbackFunction callback; void* data; }; /** * Callback and supporting data used to implement embedder logic to deserialize * internal fields of v8::Objects. / struct DeserializeInternalFieldsCallback { using CallbackFunction = void ()(Local<Object> holder, int index, StartupData payload, void* data); DeserializeInternalFieldsCallback(CallbackFunction function = nullptr, void* data_arg = nullptr) : callback(function), data(data_arg) {} CallbackFunction callback; void* data; }; /** * Similar to DeserializeInternalFieldsCallback, but works with the embedder * data in a v8::Context. / struct DeserializeContextDataCallback { using CallbackFunction = void ()(Local<Context> holder, int index, StartupData payload, void* data); DeserializeContextDataCallback(CallbackFunction function = nullptr, void* data_arg = nullptr) : callback(function), data(data_arg) {} CallbackFunction callback; void* data; }; /** * Helper class to create a snapshot data blob. * * The Isolate used by a SnapshotCreator is owned by it, and will be entered * and exited by the constructor and destructor, respectively; The destructor * will also destroy the Isolate. Experimental language features, including * those available by default, are not available while creating a snapshot. / class V8_EXPORT SnapshotCreator { public: enum class FunctionCodeHandling { kClear, kKeep }; /* * Initialize and enter an isolate, and set it up for serialization. * The isolate is either created from scratch or from an existing snapshot. * The caller keeps ownership of the argument snapshot. * \param existing_blob existing snapshot from which to create this one. * \param external_references a null-terminated array of external references * that must be equivalent to CreateParams::external_references. * \param owns_isolate whether this SnapshotCreator should call * v8::Isolate::Dispose() during its destructor. / V8_DEPRECATE_SOON("Use the version that passes CreateParams instead.") explicit SnapshotCreator(Isolate isolate, const intptr_t* external_references = nullptr, const StartupData* existing_blob = nullptr, bool owns_isolate = true); /** * Create and enter an isolate, and set it up for serialization. * The isolate is either created from scratch or from an existing snapshot. * The caller keeps ownership of the argument snapshot. * \param existing_blob existing snapshot from which to create this one. * \param external_references a null-terminated array of external references * that must be equivalent to CreateParams::external_references. / V8_DEPRECATE_SOON("Use the version that passes CreateParams instead.") explicit SnapshotCreator(const intptr_t external_references = nullptr, const StartupData* existing_blob = nullptr); /** * Creates an Isolate for serialization and enters it. The creator fully owns * the Isolate and will invoke `v8::Isolate::Dispose()` during destruction. * * \param params The parameters to initialize the Isolate for. Details: * - `params.external_references` are expected to be a * null-terminated array of external references. * - `params.existing_blob` is an optional snapshot blob from * which can be used to initialize the new blob. / explicit SnapshotCreator(const v8::Isolate::CreateParams& params); /* * Initializes an Isolate for serialization and enters it. The creator does * not own the Isolate but merely initialize it properly. * * \param isolate The isolate that was allocated by `Isolate::Allocate()~. * \param params The parameters to initialize the Isolate for. Details: * - `params.external_references` are expected to be a * null-terminated array of external references. * - `params.existing_blob` is an optional snapshot blob from * which can be used to initialize the new blob. / SnapshotCreator(v8::Isolate isolate, const v8::Isolate::CreateParams& params); /** * Destroy the snapshot creator, and exit and dispose of the Isolate * associated with it. / ~SnapshotCreator(); /* * \returns the isolate prepared by the snapshot creator. / Isolate GetIsolate(); /** * Set the default context to be included in the snapshot blob. * The snapshot will not contain the global proxy, and we expect one or a * global object template to create one, to be provided upon deserialization. * * \param internal_fields_serializer An optional callback used to serialize * internal pointer fields set by * v8::Object::SetAlignedPointerInInternalField(). * * \param context_data_serializer An optional callback used to serialize * context embedder data set by * v8::Context::SetAlignedPointerInEmbedderData(). * / void SetDefaultContext( Local<Context> context, SerializeInternalFieldsCallback internal_fields_serializer = SerializeInternalFieldsCallback(), SerializeContextDataCallback context_data_serializer = SerializeContextDataCallback()); /* * Add additional context to be included in the snapshot blob. * The snapshot will include the global proxy. * * \param internal_fields_serializer Similar to internal_fields_serializer * in SetDefaultContext() but only applies to the context being added. * * \param context_data_serializer Similar to context_data_serializer * in SetDefaultContext() but only applies to the context being added. / size_t AddContext(Local<Context> context, SerializeInternalFieldsCallback internal_fields_serializer = SerializeInternalFieldsCallback(), SerializeContextDataCallback context_data_serializer = SerializeContextDataCallback()); /* * Attach arbitrary V8::Data to the context snapshot, which can be retrieved * via Context::GetDataFromSnapshotOnce after deserialization. This data does * not survive when a new snapshot is created from an existing snapshot. * \returns the index for retrieval. / template <class T> V8_INLINE size_t AddData(Local<Context> context, Local<T> object); /* * Attach arbitrary V8::Data to the isolate snapshot, which can be retrieved * via Isolate::GetDataFromSnapshotOnce after deserialization. This data does * not survive when a new snapshot is created from an existing snapshot. * \returns the index for retrieval. / template <class T> V8_INLINE size_t AddData(Local<T> object); /* * Created a snapshot data blob. * This must not be called from within a handle scope. * \param function_code_handling whether to include compiled function code * in the snapshot. * \returns { nullptr, 0 } on failure, and a startup snapshot on success. The * caller acquires ownership of the data array in the return value. / StartupData CreateBlob(FunctionCodeHandling function_code_handling); // Disallow copying and assigning. SnapshotCreator(const SnapshotCreator&) = delete; void operator=(const SnapshotCreator&) = delete; private: size_t AddData(Local<Context> context, internal::Address object); size_t AddData(internal::Address object); internal::SnapshotCreatorImpl impl_; friend class internal::SnapshotCreatorImpl; }; template <class T> size_t SnapshotCreator::AddData(Local<Context> context, Local<T> object) { return AddData(context, internal::ValueHelper::ValueAsAddress(object)); } template <class T> size_t SnapshotCreator::AddData(Local<T> object) { return AddData(internal::ValueHelper::ValueAsAddress(object)); } } // namespace v8 #endif // INCLUDE_V8_SNAPSHOT_H_	10.15 KB	2025-03-03 12:36
📄 v8-source-location.h // Copyright 2020 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. #ifndef INCLUDE_SOURCE_LOCATION_H_ #define INCLUDE_SOURCE_LOCATION_H_ #include <cstddef> #include <string> #include "v8config.h" // NOLINT(build/include_directory) #if defined(__has_builtin) #define V8_SUPPORTS_SOURCE_LOCATION \ (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) && \ __has_builtin(__builtin_LINE)) // NOLINT #elif defined(V8_CC_GNU) && __GNUC__ >= 7 #define V8_SUPPORTS_SOURCE_LOCATION 1 #elif defined(V8_CC_INTEL) && __ICC >= 1800 #define V8_SUPPORTS_SOURCE_LOCATION 1 #else #define V8_SUPPORTS_SOURCE_LOCATION 0 #endif namespace v8 { /** * Encapsulates source location information. Mimics C++20's * `std::source_location`. / class V8_EXPORT SourceLocation final { public: /* * Construct source location information corresponding to the location of the * call site. / #if V8_SUPPORTS_SOURCE_LOCATION static constexpr SourceLocation Current( const char function = __builtin_FUNCTION(), const char* file = __builtin_FILE(), size_t line = __builtin_LINE()) { return SourceLocation(function, file, line); } #else static constexpr SourceLocation Current() { return SourceLocation(); } #endif // V8_SUPPORTS_SOURCE_LOCATION /** * Constructs unspecified source location information. / constexpr SourceLocation() = default; /* * Returns the name of the function associated with the position represented * by this object, if any. * * \returns the function name as cstring. / constexpr const char Function() const { return function_; } /** * Returns the name of the current source file represented by this object. * * \returns the file name as cstring. / constexpr const char FileName() const { return file_; } /** * Returns the line number represented by this object. * * \returns the line number. / constexpr size_t Line() const { return line_; } /* * Returns a human-readable string representing this object. * * \returns a human-readable string representing source location information. / std::string ToString() const; private: constexpr SourceLocation(const char function, const char* file, size_t line) : function_(function), file_(file), line_(line) {} const char* function_ = nullptr; const char* file_ = nullptr; size_t line_ = 0u; }; } // namespace v8 #endif // INCLUDE_SOURCE_LOCATION_H_	2.54 KB	2025-03-03 12:36
📄 v8-statistics.h // Copyright 2021 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. #ifndef INCLUDE_V8_STATISTICS_H_ #define INCLUDE_V8_STATISTICS_H_ #include <stddef.h> #include <stdint.h> #include <memory> #include <utility> #include <vector> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-memory-span.h" // NOLINT(build/include_directory) #include "v8-promise.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Context; class Isolate; namespace internal { class ReadOnlyHeap; } // namespace internal /** * Controls how the default MeasureMemoryDelegate reports the result of * the memory measurement to JS. With kSummary only the total size is reported. * With kDetailed the result includes the size of each native context. / enum class MeasureMemoryMode { kSummary, kDetailed }; /* * Controls how promptly a memory measurement request is executed. * By default the measurement is folded with the next scheduled GC which may * happen after a while and is forced after some timeout. * The kEager mode starts incremental GC right away and is useful for testing. * The kLazy mode does not force GC. / enum class MeasureMemoryExecution { kDefault, kEager, kLazy }; /* * The delegate is used in Isolate::MeasureMemory API. * * It specifies the contexts that need to be measured and gets called when * the measurement is completed to report the results. * * Both MeasurementComplete() callbacks will be invoked on completion. * Each implementation of this class should hence implement only one of them, * and leave the other empty. / class V8_EXPORT MeasureMemoryDelegate { public: virtual ~MeasureMemoryDelegate() = default; /* * Returns true if the size of the given context needs to be measured. / virtual bool ShouldMeasure(Local<Context> context) = 0; /* Holds the result of a memory measurement request. / struct Result { /* * Two spans of equal length: the first includes each context for which * ShouldMeasure returned true and that was not garbage collected while * the memory measurement was in progress; the second includes the size * of the respective context. / const MemorySpan<const Local<Context>>& contexts; const MemorySpan<const size_t>& sizes_in_bytes; /* * Total size of objects that were not attributed to any context (i.e. are * likely shared objects). / size_t unattributed_size_in_bytes; /* Total size of generated code for Wasm (shared across contexts). / size_t wasm_code_size_in_bytes; /* Total size of Wasm metadata (except code; shared across contexts). / size_t wasm_metadata_size_in_bytes; }; /* * This function is called when memory measurement finishes. * * \param result the result of the measurement. / virtual void MeasurementComplete(Result result) {} /* * Returns a default delegate that resolves the given promise when * the memory measurement completes. * * \param isolate the current isolate * \param context the current context * \param promise_resolver the promise resolver that is given the * result of the memory measurement. * \param mode the detail level of the result. / static std::unique_ptr<MeasureMemoryDelegate> Default( Isolate isolate, Local<Context> context, Local<Promise::Resolver> promise_resolver, MeasureMemoryMode mode); }; /** * Collection of shared per-process V8 memory information. * * Instances of this class can be passed to * v8::V8::GetSharedMemoryStatistics to get shared memory statistics from V8. / class V8_EXPORT SharedMemoryStatistics { public: SharedMemoryStatistics(); size_t read_only_space_size() { return read_only_space_size_; } size_t read_only_space_used_size() { return read_only_space_used_size_; } size_t read_only_space_physical_size() { return read_only_space_physical_size_; } private: size_t read_only_space_size_; size_t read_only_space_used_size_; size_t read_only_space_physical_size_; friend class V8; friend class internal::ReadOnlyHeap; }; /* * Collection of V8 heap information. * * Instances of this class can be passed to v8::Isolate::GetHeapStatistics to * get heap statistics from V8. / class V8_EXPORT HeapStatistics { public: HeapStatistics(); size_t total_heap_size() { return total_heap_size_; } size_t total_heap_size_executable() { return total_heap_size_executable_; } size_t total_physical_size() { return total_physical_size_; } size_t total_available_size() { return total_available_size_; } size_t total_global_handles_size() { return total_global_handles_size_; } size_t used_global_handles_size() { return used_global_handles_size_; } size_t used_heap_size() { return used_heap_size_; } size_t heap_size_limit() { return heap_size_limit_; } size_t malloced_memory() { return malloced_memory_; } size_t external_memory() { return external_memory_; } size_t peak_malloced_memory() { return peak_malloced_memory_; } size_t number_of_native_contexts() { return number_of_native_contexts_; } size_t number_of_detached_contexts() { return number_of_detached_contexts_; } /* * Returns a 0/1 boolean, which signifies whether the V8 overwrite heap * garbage with a bit pattern. / size_t does_zap_garbage() { return does_zap_garbage_; } private: size_t total_heap_size_; size_t total_heap_size_executable_; size_t total_physical_size_; size_t total_available_size_; size_t used_heap_size_; size_t heap_size_limit_; size_t malloced_memory_; size_t external_memory_; size_t peak_malloced_memory_; bool does_zap_garbage_; size_t number_of_native_contexts_; size_t number_of_detached_contexts_; size_t total_global_handles_size_; size_t used_global_handles_size_; friend class V8; friend class Isolate; }; class V8_EXPORT HeapSpaceStatistics { public: HeapSpaceStatistics(); const char space_name() { return space_name_; } size_t space_size() { return space_size_; } size_t space_used_size() { return space_used_size_; } size_t space_available_size() { return space_available_size_; } size_t physical_space_size() { return physical_space_size_; } private: const char* space_name_; size_t space_size_; size_t space_used_size_; size_t space_available_size_; size_t physical_space_size_; friend class Isolate; }; class V8_EXPORT HeapObjectStatistics { public: HeapObjectStatistics(); const char* object_type() { return object_type_; } const char* object_sub_type() { return object_sub_type_; } size_t object_count() { return object_count_; } size_t object_size() { return object_size_; } private: const char* object_type_; const char* object_sub_type_; size_t object_count_; size_t object_size_; friend class Isolate; }; class V8_EXPORT HeapCodeStatistics { public: HeapCodeStatistics(); size_t code_and_metadata_size() { return code_and_metadata_size_; } size_t bytecode_and_metadata_size() { return bytecode_and_metadata_size_; } size_t external_script_source_size() { return external_script_source_size_; } size_t cpu_profiler_metadata_size() { return cpu_profiler_metadata_size_; } private: size_t code_and_metadata_size_; size_t bytecode_and_metadata_size_; size_t external_script_source_size_; size_t cpu_profiler_metadata_size_; friend class Isolate; }; } // namespace v8 #endif // INCLUDE_V8_STATISTICS_H_	7.45 KB	2025-03-03 12:36
📄 v8-template.h // Copyright 2021 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. #ifndef INCLUDE_V8_TEMPLATE_H_ #define INCLUDE_V8_TEMPLATE_H_ #include <cstddef> #include <string_view> #include "v8-data.h" // NOLINT(build/include_directory) #include "v8-function-callback.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-memory-span.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class CFunction; class FunctionTemplate; class ObjectTemplate; class Signature; // --- Templates --- #define V8_INTRINSICS_LIST(F) \ F(ArrayProto_entries, array_entries_iterator) \ F(ArrayProto_forEach, array_for_each_iterator) \ F(ArrayProto_keys, array_keys_iterator) \ F(ArrayProto_values, array_values_iterator) \ F(ArrayPrototype, initial_array_prototype) \ F(AsyncIteratorPrototype, initial_async_iterator_prototype) \ F(ErrorPrototype, initial_error_prototype) \ F(IteratorPrototype, initial_iterator_prototype) \ F(MapIteratorPrototype, initial_map_iterator_prototype) \ F(ObjProto_valueOf, object_value_of_function) \ F(SetIteratorPrototype, initial_set_iterator_prototype) enum Intrinsic { #define V8_DECL_INTRINSIC(name, iname) k##name, V8_INTRINSICS_LIST(V8_DECL_INTRINSIC) #undef V8_DECL_INTRINSIC }; /** * The superclass of object and function templates. / class V8_EXPORT Template : public Data { public: /* * Adds a property to each instance created by this template. * * The property must be defined either as a primitive value, or a template. / void Set(Local<Name> name, Local<Data> value, PropertyAttribute attributes = None); void SetPrivate(Local<Private> name, Local<Data> value, PropertyAttribute attributes = None); V8_INLINE void Set(Isolate isolate, const char* name, Local<Data> value, PropertyAttribute attributes = None); void SetAccessorProperty( Local<Name> name, Local<FunctionTemplate> getter = Local<FunctionTemplate>(), Local<FunctionTemplate> setter = Local<FunctionTemplate>(), PropertyAttribute attribute = None); /** * Whenever the property with the given name is accessed on objects * created from this Template the getter and setter callbacks * are called instead of getting and setting the property directly * on the JavaScript object. * * \param name The name of the property for which an accessor is added. * \param getter The callback to invoke when getting the property. * \param setter The callback to invoke when setting the property. * \param data A piece of data that will be passed to the getter and setter * callbacks whenever they are invoked. * \param attribute The attributes of the property for which an accessor * is added. / V8_DEPRECATE_SOON("Use SetNativeDataProperty without AccessControl instead") void SetNativeDataProperty( Local<String> name, AccessorGetterCallback getter, AccessorSetterCallback setter, Local<Value> data, PropertyAttribute attribute, AccessControl settings, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); V8_DEPRECATE_SOON("Use SetNativeDataProperty without AccessControl instead") void SetNativeDataProperty( Local<Name> name, AccessorNameGetterCallback getter, AccessorNameSetterCallback setter, Local<Value> data, PropertyAttribute attribute, AccessControl settings, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); V8_DEPRECATE_SOON("Use SetNativeDataProperty with Local<Name> instead") void SetNativeDataProperty( Local<String> name, AccessorGetterCallback getter, AccessorSetterCallback setter = nullptr, Local<Value> data = Local<Value>(), PropertyAttribute attribute = None, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); void SetNativeDataProperty( Local<Name> name, AccessorNameGetterCallback getter, AccessorNameSetterCallback setter = nullptr, Local<Value> data = Local<Value>(), PropertyAttribute attribute = None, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); /* * Like SetNativeDataProperty, but V8 will replace the native data property * with a real data property on first access. / void SetLazyDataProperty( Local<Name> name, AccessorNameGetterCallback getter, Local<Value> data = Local<Value>(), PropertyAttribute attribute = None, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); /* * During template instantiation, sets the value with the intrinsic property * from the correct context. / void SetIntrinsicDataProperty(Local<Name> name, Intrinsic intrinsic, PropertyAttribute attribute = None); private: Template(); friend class ObjectTemplate; friend class FunctionTemplate; }; /* * Interceptor callbacks use this value to indicate whether the request was * intercepted or not. / enum class Intercepted : uint8_t { kNo = 0, kYes = 1 }; /* * Interceptor for get requests on an object. * * If the interceptor handles the request (i.e. the property should not be * looked up beyond the interceptor) it should * - (optionally) use info.GetReturnValue().Set()` to set the return value * (by default the result is set to v8::Undefined), * - return `Intercepted::kYes`. * If the interceptor does not handle the request it must return * `Intercepted::kNo` and it must not produce side effects. * * \param property The name of the property for which the request was * intercepted. * \param info Information about the intercepted request, such as * isolate, receiver, return value, or whether running in `'use strict'` mode. * See `PropertyCallbackInfo`. * * \code * Intercepted GetterCallback( * Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { * if (!IsKnownProperty(info.GetIsolate(), name)) return Intercepted::kNo; * info.GetReturnValue().Set(v8_num(42)); * return Intercepted::kYes; * } * * v8::Local<v8::FunctionTemplate> templ = * v8::FunctionTemplate::New(isolate); * templ->InstanceTemplate()->SetHandler( * v8::NamedPropertyHandlerConfiguration(GetterCallback)); * LocalContext env; * env->Global() * ->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local()) * .ToLocalChecked() * ->NewInstance(env.local()) * .ToLocalChecked()) * .FromJust(); * v8::Local<v8::Value> result = CompileRun("obj.a = 17; obj.a"); * CHECK(v8_num(42)->Equals(env.local(), result).FromJust()); * \endcode * * See also `ObjectTemplate::SetHandler`. / using NamedPropertyGetterCallback = Intercepted ()( Local<Name> property, const PropertyCallbackInfo<Value>& info); // This variant will be deprecated soon. // // Use `info.GetReturnValue().Set()` to set the return value of the // intercepted get request. If the property does not exist the callback should // not set the result and must not produce side effects. using GenericNamedPropertyGetterCallback = void ()(Local<Name> property, const PropertyCallbackInfo<Value>& info); /* * Interceptor for set requests on an object. * * If the interceptor handles the request (i.e. the property should not be * looked up beyond the interceptor) it should return `Intercepted::kYes`. * If the interceptor does not handle the request it must return * `Intercepted::kNo` and it must not produce side effects. * * \param property The name of the property for which the request was * intercepted. * \param value The value which the property will have if the request * is not intercepted. * \param info Information about the intercepted request, such as * isolate, receiver, return value, or whether running in `'use strict'` mode. * See `PropertyCallbackInfo`. * * See also `ObjectTemplate::SetHandler.` / using NamedPropertySetterCallback = Intercepted ()(Local<Name> property, Local<Value> value, const PropertyCallbackInfo<void>& info); // This variant will be deprecated soon. // // Use `info.GetReturnValue()` to indicate whether the request was intercepted // or not. If the setter successfully intercepts the request, i.e., if the // request should not be further executed, call // `info.GetReturnValue().Set(value)`. If the setter did not intercept the // request, i.e., if the request should be handled as if no interceptor is // present, do not not call `Set()` and do not produce side effects. using GenericNamedPropertySetterCallback = void ()(Local<Name> property, Local<Value> value, const PropertyCallbackInfo<Value>& info); /* * Intercepts all requests that query the attributes of the * property, e.g., getOwnPropertyDescriptor(), propertyIsEnumerable(), and * defineProperty(). * * If the interceptor handles the request (i.e. the property should not be * looked up beyond the interceptor) it should * - use `info.GetReturnValue().Set()` to set to an Integer value encoding * a `v8::PropertyAttribute` bits, * - return `Intercepted::kYes`. * If the interceptor does not handle the request it must return * `Intercepted::kNo` and it must not produce side effects. * * \param property The name of the property for which the request was * intercepted. * \param info Information about the intercepted request, such as * isolate, receiver, return value, or whether running in `'use strict'` mode. * See `PropertyCallbackInfo`. * * \note Some functions query the property attributes internally, even though * they do not return the attributes. For example, `hasOwnProperty()` can * trigger this interceptor depending on the state of the object. * * See also `ObjectTemplate::SetHandler.` / using NamedPropertyQueryCallback = Intercepted ()( Local<Name> property, const PropertyCallbackInfo<Integer>& info); // This variant will be deprecated soon. // // Use `info.GetReturnValue().Set(value)` to set the property attributes. The // value is an integer encoding a `v8::PropertyAttribute`. If the property does // not exist the callback should not set the result and must not produce side // effects. using GenericNamedPropertyQueryCallback = void ()(Local<Name> property, const PropertyCallbackInfo<Integer>& info); /* * Interceptor for delete requests on an object. * * If the interceptor handles the request (i.e. the property should not be * looked up beyond the interceptor) it should * - use `info.GetReturnValue().Set()` to set to a Boolean value indicating * whether the property deletion was successful or not, * - return `Intercepted::kYes`. * If the interceptor does not handle the request it must return * `Intercepted::kNo` and it must not produce side effects. * * \param property The name of the property for which the request was * intercepted. * \param info Information about the intercepted request, such as * isolate, receiver, return value, or whether running in `'use strict'` mode. * See `PropertyCallbackInfo`. * * \note If you need to mimic the behavior of `delete`, i.e., throw in strict * mode instead of returning false, use `info.ShouldThrowOnError()` to determine * if you are in strict mode. * * See also `ObjectTemplate::SetHandler.` / using NamedPropertyDeleterCallback = Intercepted ()( Local<Name> property, const PropertyCallbackInfo<Boolean>& info); // This variant will be deprecated soon. // // Use `info.GetReturnValue()` to indicate whether the request was intercepted // or not. If the deleter successfully intercepts the request, i.e., if the // request should not be further executed, call // `info.GetReturnValue().Set(value)` with a boolean `value`. The `value` is // used as the return value of `delete`. If the deleter does not intercept the // request then it should not set the result and must not produce side effects. using GenericNamedPropertyDeleterCallback = void ()(Local<Name> property, const PropertyCallbackInfo<Boolean>& info); /* * Returns an array containing the names of the properties the named * property getter intercepts. * * Note: The values in the array must be of type v8::Name. / using NamedPropertyEnumeratorCallback = void ()(const PropertyCallbackInfo<Array>& info); // This variant will be deprecated soon. // This is just a renaming of the typedef. using GenericNamedPropertyEnumeratorCallback = NamedPropertyEnumeratorCallback; /** * Interceptor for defineProperty requests on an object. * * If the interceptor handles the request (i.e. the property should not be * looked up beyond the interceptor) it should return `Intercepted::kYes`. * If the interceptor does not handle the request it must return * `Intercepted::kNo` and it must not produce side effects. * * \param property The name of the property for which the request was * intercepted. * \param desc The property descriptor which is used to define the * property if the request is not intercepted. * \param info Information about the intercepted request, such as * isolate, receiver, return value, or whether running in `'use strict'` mode. * See `PropertyCallbackInfo`. * * See also `ObjectTemplate::SetHandler`. / using NamedPropertyDefinerCallback = Intercepted ()(Local<Name> property, const PropertyDescriptor& desc, const PropertyCallbackInfo<void>& info); // This variant will be deprecated soon. // // Use `info.GetReturnValue()` to indicate whether the request was intercepted // or not. If the definer successfully intercepts the request, i.e., if the // request should not be further executed, call // `info.GetReturnValue().Set(value)`. If the definer did not intercept the // request, i.e., if the request should be handled as if no interceptor is // present, do not not call `Set()` and do not produce side effects. using GenericNamedPropertyDefinerCallback = void ()(Local<Name> property, const PropertyDescriptor& desc, const PropertyCallbackInfo<Value>& info); /* * Interceptor for getOwnPropertyDescriptor requests on an object. * * If the interceptor handles the request (i.e. the property should not be * looked up beyond the interceptor) it should * - use `info.GetReturnValue().Set()` to set the return value which must be * object that can be converted to a PropertyDescriptor (for example, * a value returned by `v8::Object::getOwnPropertyDescriptor`), * - return `Intercepted::kYes`. * If the interceptor does not handle the request it must return * `Intercepted::kNo` and it must not produce side effects. * * \param property The name of the property for which the request was * intercepted. * \info Information about the intercepted request, such as * isolate, receiver, return value, or whether running in `'use strict'` mode. * See `PropertyCallbackInfo`. * * \note If GetOwnPropertyDescriptor is intercepted, it will * always return true, i.e., indicate that the property was found. * * See also `ObjectTemplate::SetHandler`. / using NamedPropertyDescriptorCallback = Intercepted ()( Local<Name> property, const PropertyCallbackInfo<Value>& info); // This variant will be deprecated soon. // // Use `info.GetReturnValue().Set()` to set the return value of the // intercepted request. The return value must be an object that // can be converted to a PropertyDescriptor, e.g., a `v8::Value` returned from // `v8::Object::getOwnPropertyDescriptor`. using GenericNamedPropertyDescriptorCallback = void ()(Local<Name> property, const PropertyCallbackInfo<Value>& info); // TODO(ishell): Rename IndexedPropertyXxxCallbackV2 back to // IndexedPropertyXxxCallback once the old IndexedPropertyXxxCallback is // removed. /* * See `v8::GenericNamedPropertyGetterCallback`. / using IndexedPropertyGetterCallbackV2 = Intercepted ()(uint32_t index, const PropertyCallbackInfo<Value>& info); // This variant will be deprecated soon. using IndexedPropertyGetterCallback = void ()(uint32_t index, const PropertyCallbackInfo<Value>& info); /* * See `v8::GenericNamedPropertySetterCallback`. / using IndexedPropertySetterCallbackV2 = Intercepted ()( uint32_t index, Local<Value> value, const PropertyCallbackInfo<void>& info); // This variant will be deprecated soon. using IndexedPropertySetterCallback = void ()(uint32_t index, Local<Value> value, const PropertyCallbackInfo<Value>& info); /* * See `v8::GenericNamedPropertyQueryCallback`. / using IndexedPropertyQueryCallbackV2 = Intercepted ()(uint32_t index, const PropertyCallbackInfo<Integer>& info); // This variant will be deprecated soon. using IndexedPropertyQueryCallback = void ()(uint32_t index, const PropertyCallbackInfo<Integer>& info); /* * See `v8::GenericNamedPropertyDeleterCallback`. / using IndexedPropertyDeleterCallbackV2 = Intercepted ()(uint32_t index, const PropertyCallbackInfo<Boolean>& info); // This variant will be deprecated soon. using IndexedPropertyDeleterCallback = void ()(uint32_t index, const PropertyCallbackInfo<Boolean>& info); /* * Returns an array containing the indices of the properties the indexed * property getter intercepts. * * Note: The values in the array must be uint32_t. / using IndexedPropertyEnumeratorCallback = void ()(const PropertyCallbackInfo<Array>& info); /** * See `v8::GenericNamedPropertyDefinerCallback`. / using IndexedPropertyDefinerCallbackV2 = Intercepted ()(uint32_t index, const PropertyDescriptor& desc, const PropertyCallbackInfo<void>& info); // This variant will be deprecated soon. using IndexedPropertyDefinerCallback = void ()(uint32_t index, const PropertyDescriptor& desc, const PropertyCallbackInfo<Value>& info); /* * See `v8::GenericNamedPropertyDescriptorCallback`. / using IndexedPropertyDescriptorCallbackV2 = Intercepted ()(uint32_t index, const PropertyCallbackInfo<Value>& info); // This variant will be deprecated soon. using IndexedPropertyDescriptorCallback = void ()(uint32_t index, const PropertyCallbackInfo<Value>& info); /* * Returns true if the given context should be allowed to access the given * object. / using AccessCheckCallback = bool ()(Local<Context> accessing_context, Local<Object> accessed_object, Local<Value> data); enum class ConstructorBehavior { kThrow, kAllow }; /** * A FunctionTemplate is used to create functions at runtime. There * can only be one function created from a FunctionTemplate in a * context. The lifetime of the created function is equal to the * lifetime of the context. So in case the embedder needs to create * temporary functions that can be collected using Scripts is * preferred. * * Any modification of a FunctionTemplate after first instantiation will trigger * a crash. * * A FunctionTemplate can have properties, these properties are added to the * function object when it is created. * * A FunctionTemplate has a corresponding instance template which is * used to create object instances when the function is used as a * constructor. Properties added to the instance template are added to * each object instance. * * A FunctionTemplate can have a prototype template. The prototype template * is used to create the prototype object of the function. * * The following example shows how to use a FunctionTemplate: * * \code * v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate); * t->Set(isolate, "func_property", v8::Number::New(isolate, 1)); * * v8::Local<v8::Template> proto_t = t->PrototypeTemplate(); * proto_t->Set(isolate, * "proto_method", * v8::FunctionTemplate::New(isolate, InvokeCallback)); * proto_t->Set(isolate, "proto_const", v8::Number::New(isolate, 2)); * * v8::Local<v8::ObjectTemplate> instance_t = t->InstanceTemplate(); * instance_t->SetAccessor( String::NewFromUtf8Literal(isolate, "instance_accessor"), * InstanceAccessorCallback); * instance_t->SetHandler( * NamedPropertyHandlerConfiguration(PropertyHandlerCallback)); * instance_t->Set(String::NewFromUtf8Literal(isolate, "instance_property"), * Number::New(isolate, 3)); * * v8::Local<v8::Function> function = t->GetFunction(); * v8::Local<v8::Object> instance = function->NewInstance(); * \endcode * * Let's use "function" as the JS variable name of the function object * and "instance" for the instance object created above. The function * and the instance will have the following properties: * * \code * func_property in function == true; * function.func_property == 1; * * function.prototype.proto_method() invokes 'InvokeCallback' * function.prototype.proto_const == 2; * * instance instanceof function == true; * instance.instance_accessor calls 'InstanceAccessorCallback' * instance.instance_property == 3; * \endcode * * A FunctionTemplate can inherit from another one by calling the * FunctionTemplate::Inherit method. The following graph illustrates * the semantics of inheritance: * * \code * FunctionTemplate Parent -> Parent() . prototype -> { } * ^ ^ * \| Inherit(Parent) \| .__proto__ * \| \| * FunctionTemplate Child -> Child() . prototype -> { } * \endcode * * A FunctionTemplate 'Child' inherits from 'Parent', the prototype * object of the Child() function has __proto__ pointing to the * Parent() function's prototype object. An instance of the Child * function has all properties on Parent's instance templates. * * Let Parent be the FunctionTemplate initialized in the previous * section and create a Child FunctionTemplate by: * * \code * Local<FunctionTemplate> parent = t; * Local<FunctionTemplate> child = FunctionTemplate::New(); * child->Inherit(parent); * * Local<Function> child_function = child->GetFunction(); * Local<Object> child_instance = child_function->NewInstance(); * \endcode * * The Child function and Child instance will have the following * properties: * * \code * child_func.prototype.__proto__ == function.prototype; * child_instance.instance_accessor calls 'InstanceAccessorCallback' * child_instance.instance_property == 3; * \endcode * * The additional 'c_function' parameter refers to a fast API call, which * must not trigger GC or JavaScript execution, or call into V8 in other * ways. For more information how to define them, see * include/v8-fast-api-calls.h. Please note that this feature is still * experimental. / class V8_EXPORT FunctionTemplate : public Template { public: /* Creates a function template./ static Local<FunctionTemplate> New( Isolate isolate, FunctionCallback callback = nullptr, Local<Value> data = Local<Value>(), Local<Signature> signature = Local<Signature>(), int length = 0, ConstructorBehavior behavior = ConstructorBehavior::kAllow, SideEffectType side_effect_type = SideEffectType::kHasSideEffect, const CFunction* c_function = nullptr, uint16_t instance_type = 0, uint16_t allowed_receiver_instance_type_range_start = 0, uint16_t allowed_receiver_instance_type_range_end = 0); /** Creates a function template for multiple overloaded fast API calls./ static Local<FunctionTemplate> NewWithCFunctionOverloads( Isolate isolate, FunctionCallback callback = nullptr, Local<Value> data = Local<Value>(), Local<Signature> signature = Local<Signature>(), int length = 0, ConstructorBehavior behavior = ConstructorBehavior::kAllow, SideEffectType side_effect_type = SideEffectType::kHasSideEffect, const MemorySpan<const CFunction>& c_function_overloads = {}); /** * Creates a function template backed/cached by a private property. / static Local<FunctionTemplate> NewWithCache( Isolate isolate, FunctionCallback callback, Local<Private> cache_property, Local<Value> data = Local<Value>(), Local<Signature> signature = Local<Signature>(), int length = 0, SideEffectType side_effect_type = SideEffectType::kHasSideEffect); /** Returns the unique function instance in the current execution context./ V8_WARN_UNUSED_RESULT MaybeLocal<Function> GetFunction( Local<Context> context); /* * Similar to Context::NewRemoteContext, this creates an instance that * isn't backed by an actual object. * * The InstanceTemplate of this FunctionTemplate must have access checks with * handlers installed. / V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewRemoteInstance(); /* * Set the call-handler callback for a FunctionTemplate. This * callback is called whenever the function created from this * FunctionTemplate is called. The 'c_function' represents a fast * API call, see the comment above the class declaration. / void SetCallHandler( FunctionCallback callback, Local<Value> data = Local<Value>(), SideEffectType side_effect_type = SideEffectType::kHasSideEffect, const MemorySpan<const CFunction>& c_function_overloads = {}); /* Set the predefined length property for the FunctionTemplate. / void SetLength(int length); /* Get the InstanceTemplate. / Local<ObjectTemplate> InstanceTemplate(); /* * Causes the function template to inherit from a parent function template. * This means the function's prototype.__proto__ is set to the parent * function's prototype. / void Inherit(Local<FunctionTemplate> parent); / * A PrototypeTemplate is the template used to create the prototype object * of the function created by this template. / Local<ObjectTemplate> PrototypeTemplate(); /* * A PrototypeProviderTemplate is another function template whose prototype * property is used for this template. This is mutually exclusive with setting * a prototype template indirectly by calling PrototypeTemplate() or using * Inherit(). / void SetPrototypeProviderTemplate(Local<FunctionTemplate> prototype_provider); / * Set the class name of the FunctionTemplate. This is used for * printing objects created with the function created from the * FunctionTemplate as its constructor. / void SetClassName(Local<String> name); /* * When set to true, no access check will be performed on the receiver of a * function call. Currently defaults to true, but this is subject to change. / void SetAcceptAnyReceiver(bool value); /* * Sets the ReadOnly flag in the attributes of the 'prototype' property * of functions created from this FunctionTemplate to true. / void ReadOnlyPrototype(); /* * Removes the prototype property from functions created from this * FunctionTemplate. / void RemovePrototype(); /* * Returns true if the given object is an instance of this function * template. / bool HasInstance(Local<Value> object); /* * Returns true if the given value is an API object that was constructed by an * instance of this function template (without checking for inheriting * function templates). * * This is an experimental feature and may still change significantly. / bool IsLeafTemplateForApiObject(v8::Local<v8::Value> value) const; V8_INLINE static FunctionTemplate Cast(Data* data); private: FunctionTemplate(); static void CheckCast(Data* that); friend class Context; friend class ObjectTemplate; }; /** * Configuration flags for v8::NamedPropertyHandlerConfiguration or * v8::IndexedPropertyHandlerConfiguration. / enum class PropertyHandlerFlags { /* * None. / kNone = 0, /* * Will not call into interceptor for properties on the receiver or prototype * chain, i.e., only call into interceptor for properties that do not exist. * Currently only valid for named interceptors. / kNonMasking = 1, /* * Will not call into interceptor for symbol lookup. Only meaningful for * named interceptors. / kOnlyInterceptStrings = 1 << 1, /* * The getter, query, enumerator callbacks do not produce side effects. / kHasNoSideEffect = 1 << 2, /* * This flag is used to distinguish which callbacks were provided - * GenericNamedPropertyXXXCallback (old signature) or * NamedPropertyXXXCallback (new signature). * DO NOT use this flag, it'll be removed once embedders migrate to new * callbacks signatures. / kInternalNewCallbacksSignatures = 1 << 10, }; struct NamedPropertyHandlerConfiguration { private: static constexpr PropertyHandlerFlags WithNewSignatureFlag( PropertyHandlerFlags flags) { return static_cast<PropertyHandlerFlags>( static_cast<int>(flags) \| static_cast<int>( PropertyHandlerFlags::kInternalNewCallbacksSignatures)); } public: NamedPropertyHandlerConfiguration( NamedPropertyGetterCallback getter, // NamedPropertySetterCallback setter, // NamedPropertyQueryCallback query, // NamedPropertyDeleterCallback deleter, // NamedPropertyEnumeratorCallback enumerator, // NamedPropertyDefinerCallback definer, // NamedPropertyDescriptorCallback descriptor, // Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(reinterpret_cast<void>(query)), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(reinterpret_cast<void>(definer)), descriptor(reinterpret_cast<void>(descriptor)), data(data), flags(WithNewSignatureFlag(flags)) {} // This variant will be deprecated soon. NamedPropertyHandlerConfiguration( GenericNamedPropertyGetterCallback getter, GenericNamedPropertySetterCallback setter, GenericNamedPropertyQueryCallback query, GenericNamedPropertyDeleterCallback deleter, GenericNamedPropertyEnumeratorCallback enumerator, GenericNamedPropertyDefinerCallback definer, GenericNamedPropertyDescriptorCallback descriptor, Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(reinterpret_cast<void>(query)), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(reinterpret_cast<void>(definer)), descriptor(reinterpret_cast<void>(descriptor)), data(data), flags(flags) {} explicit NamedPropertyHandlerConfiguration( NamedPropertyGetterCallback getter, NamedPropertySetterCallback setter = nullptr, NamedPropertyQueryCallback query = nullptr, NamedPropertyDeleterCallback deleter = nullptr, NamedPropertyEnumeratorCallback enumerator = nullptr, Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(reinterpret_cast<void>(query)), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(nullptr), descriptor(nullptr), data(data), flags(WithNewSignatureFlag(flags)) {} // This variant will be deprecated soon. explicit NamedPropertyHandlerConfiguration( GenericNamedPropertyGetterCallback getter, GenericNamedPropertySetterCallback setter = nullptr, GenericNamedPropertyQueryCallback query = nullptr, GenericNamedPropertyDeleterCallback deleter = nullptr, GenericNamedPropertyEnumeratorCallback enumerator = nullptr, Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(reinterpret_cast<void>(query)), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(nullptr), descriptor(nullptr), data(data), flags(flags) {} NamedPropertyHandlerConfiguration( NamedPropertyGetterCallback getter, // NamedPropertySetterCallback setter, // NamedPropertyDescriptorCallback descriptor, // NamedPropertyDeleterCallback deleter, // NamedPropertyEnumeratorCallback enumerator, // NamedPropertyDefinerCallback definer, // Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(nullptr), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(reinterpret_cast<void>(definer)), descriptor(reinterpret_cast<void>(descriptor)), data(data), flags(WithNewSignatureFlag(flags)) {} // This variant will be deprecated soon. NamedPropertyHandlerConfiguration( GenericNamedPropertyGetterCallback getter, GenericNamedPropertySetterCallback setter, GenericNamedPropertyDescriptorCallback descriptor, GenericNamedPropertyDeleterCallback deleter, GenericNamedPropertyEnumeratorCallback enumerator, GenericNamedPropertyDefinerCallback definer, Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(nullptr), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(reinterpret_cast<void>(definer)), descriptor(reinterpret_cast<void>(descriptor)), data(data), flags(flags) {} void getter; // [Generic]NamedPropertyGetterCallback void* setter; // [Generic]NamedPropertySetterCallback void* query; // [Generic]NamedPropertyQueryCallback void* deleter; // [Generic]NamedPropertyDeleterCallback NamedPropertyEnumeratorCallback enumerator; void* definer; // [Generic]NamedPropertyDefinerCallback void* descriptor; // [Generic]NamedPropertyDescriptorCallback Local<Value> data; PropertyHandlerFlags flags; }; struct IndexedPropertyHandlerConfiguration { private: static constexpr PropertyHandlerFlags WithNewSignatureFlag( PropertyHandlerFlags flags) { return static_cast<PropertyHandlerFlags>( static_cast<int>(flags) \| static_cast<int>( PropertyHandlerFlags::kInternalNewCallbacksSignatures)); } public: IndexedPropertyHandlerConfiguration( IndexedPropertyGetterCallbackV2 getter, // IndexedPropertySetterCallbackV2 setter, // IndexedPropertyQueryCallbackV2 query, // IndexedPropertyDeleterCallbackV2 deleter, // IndexedPropertyEnumeratorCallback enumerator, // IndexedPropertyDefinerCallbackV2 definer, // IndexedPropertyDescriptorCallbackV2 descriptor, // Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(reinterpret_cast<void>(query)), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(reinterpret_cast<void>(definer)), descriptor(reinterpret_cast<void>(descriptor)), data(data), flags(WithNewSignatureFlag(flags)) {} // This variant will be deprecated soon. IndexedPropertyHandlerConfiguration( IndexedPropertyGetterCallback getter, // IndexedPropertySetterCallback setter, // IndexedPropertyQueryCallback query, // IndexedPropertyDeleterCallback deleter, // IndexedPropertyEnumeratorCallback enumerator, // IndexedPropertyDefinerCallback definer, // IndexedPropertyDescriptorCallback descriptor, // Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(reinterpret_cast<void>(query)), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(reinterpret_cast<void>(definer)), descriptor(reinterpret_cast<void>(descriptor)), data(data), flags(flags) {} explicit IndexedPropertyHandlerConfiguration( IndexedPropertyGetterCallbackV2 getter = nullptr, IndexedPropertySetterCallbackV2 setter = nullptr, IndexedPropertyQueryCallbackV2 query = nullptr, IndexedPropertyDeleterCallbackV2 deleter = nullptr, IndexedPropertyEnumeratorCallback enumerator = nullptr, Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(reinterpret_cast<void>(query)), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(nullptr), descriptor(nullptr), data(data), flags(WithNewSignatureFlag(flags)) {} // This variant will be deprecated soon. explicit IndexedPropertyHandlerConfiguration( IndexedPropertyGetterCallback getter, IndexedPropertySetterCallback setter = nullptr, IndexedPropertyQueryCallback query = nullptr, IndexedPropertyDeleterCallback deleter = nullptr, IndexedPropertyEnumeratorCallback enumerator = nullptr, Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(reinterpret_cast<void>(query)), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(nullptr), descriptor(nullptr), data(data), flags(flags) {} IndexedPropertyHandlerConfiguration( IndexedPropertyGetterCallbackV2 getter, IndexedPropertySetterCallbackV2 setter, IndexedPropertyDescriptorCallbackV2 descriptor, IndexedPropertyDeleterCallbackV2 deleter, IndexedPropertyEnumeratorCallback enumerator, IndexedPropertyDefinerCallbackV2 definer, Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(nullptr), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(reinterpret_cast<void>(definer)), descriptor(reinterpret_cast<void>(descriptor)), data(data), flags(WithNewSignatureFlag(flags)) {} // This variant will be deprecated soon. IndexedPropertyHandlerConfiguration( IndexedPropertyGetterCallback getter, IndexedPropertySetterCallback setter, IndexedPropertyDescriptorCallback descriptor, IndexedPropertyDeleterCallback deleter, IndexedPropertyEnumeratorCallback enumerator, IndexedPropertyDefinerCallback definer, Local<Value> data = Local<Value>(), PropertyHandlerFlags flags = PropertyHandlerFlags::kNone) : getter(reinterpret_cast<void>(getter)), setter(reinterpret_cast<void>(setter)), query(nullptr), deleter(reinterpret_cast<void>(deleter)), enumerator(enumerator), definer(reinterpret_cast<void>(definer)), descriptor(reinterpret_cast<void>(descriptor)), data(data), flags(flags) {} void* getter; // IndexedPropertyGetterCallback[V2] void* setter; // IndexedPropertySetterCallback[V2] void* query; // IndexedPropertyQueryCallback[V2] void* deleter; // IndexedPropertyDeleterCallback[V2] IndexedPropertyEnumeratorCallback enumerator; void* definer; // IndexedPropertyDefinerCallback[V2] void* descriptor; // IndexedPropertyDescriptorCallback[V2] Local<Value> data; PropertyHandlerFlags flags; }; /** * An ObjectTemplate is used to create objects at runtime. * * Properties added to an ObjectTemplate are added to each object * created from the ObjectTemplate. / class V8_EXPORT ObjectTemplate : public Template { public: /* Creates an ObjectTemplate. / static Local<ObjectTemplate> New( Isolate isolate, Local<FunctionTemplate> constructor = Local<FunctionTemplate>()); /** * Creates a new instance of this template. * * \param context The context in which the instance is created. / V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstance(Local<Context> context); /* * Sets an accessor on the object template. * * Whenever the property with the given name is accessed on objects * created from this ObjectTemplate the getter and setter callbacks * are called instead of getting and setting the property directly * on the JavaScript object. * * \param name The name of the property for which an accessor is added. * \param getter The callback to invoke when getting the property. * \param setter The callback to invoke when setting the property. * \param data A piece of data that will be passed to the getter and setter * callbacks whenever they are invoked. * \param attribute The attributes of the property for which an accessor * is added. / V8_DEPRECATE_SOON("Use SetAccessor with Local<Name> instead") void SetAccessor( Local<String> name, AccessorGetterCallback getter, AccessorSetterCallback setter = nullptr, Local<Value> data = Local<Value>(), PropertyAttribute attribute = None, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); void SetAccessor( Local<Name> name, AccessorNameGetterCallback getter, AccessorNameSetterCallback setter = nullptr, Local<Value> data = Local<Value>(), PropertyAttribute attribute = None, SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect, SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect); /* * Sets a named property handler on the object template. * * Whenever a property whose name is a string or a symbol is accessed on * objects created from this object template, the provided callback is * invoked instead of accessing the property directly on the JavaScript * object. * * @param configuration The NamedPropertyHandlerConfiguration that defines the * callbacks to invoke when accessing a property. / void SetHandler(const NamedPropertyHandlerConfiguration& configuration); /* * Sets an indexed property handler on the object template. * * Whenever an indexed property is accessed on objects created from * this object template, the provided callback is invoked instead of * accessing the property directly on the JavaScript object. * * \param getter The callback to invoke when getting a property. * \param setter The callback to invoke when setting a property. * \param query The callback to invoke to check if an object has a property. * \param deleter The callback to invoke when deleting a property. * \param enumerator The callback to invoke to enumerate all the indexed * properties of an object. * \param data A piece of data that will be passed to the callbacks * whenever they are invoked. / V8_DEPRECATE_SOON("Use SetHandler instead") void SetIndexedPropertyHandler( IndexedPropertyGetterCallback getter, IndexedPropertySetterCallback setter = nullptr, IndexedPropertyQueryCallback query = nullptr, IndexedPropertyDeleterCallback deleter = nullptr, IndexedPropertyEnumeratorCallback enumerator = nullptr, Local<Value> data = Local<Value>()) { SetHandler(IndexedPropertyHandlerConfiguration(getter, setter, query, deleter, enumerator, data)); } /* * Sets an indexed property handler on the object template. * * Whenever an indexed property is accessed on objects created from * this object template, the provided callback is invoked instead of * accessing the property directly on the JavaScript object. * * @param configuration The IndexedPropertyHandlerConfiguration that defines * the callbacks to invoke when accessing a property. / void SetHandler(const IndexedPropertyHandlerConfiguration& configuration); /* * Sets the callback to be used when calling instances created from * this template as a function. If no callback is set, instances * behave like normal JavaScript objects that cannot be called as a * function. / void SetCallAsFunctionHandler(FunctionCallback callback, Local<Value> data = Local<Value>()); /* * Mark object instances of the template as undetectable. * * In many ways, undetectable objects behave as though they are not * there. They behave like 'undefined' in conditionals and when * printed. However, properties can be accessed and called as on * normal objects. / void MarkAsUndetectable(); /* * Sets access check callback on the object template and enables access * checks. * * When accessing properties on instances of this object template, * the access check callback will be called to determine whether or * not to allow cross-context access to the properties. / void SetAccessCheckCallback(AccessCheckCallback callback, Local<Value> data = Local<Value>()); /* * Like SetAccessCheckCallback but invokes an interceptor on failed access * checks instead of looking up all-can-read properties. You can only use * either this method or SetAccessCheckCallback, but not both at the same * time. / void SetAccessCheckCallbackAndHandler( AccessCheckCallback callback, const NamedPropertyHandlerConfiguration& named_handler, const IndexedPropertyHandlerConfiguration& indexed_handler, Local<Value> data = Local<Value>()); /* * Gets the number of internal fields for objects generated from * this template. / int InternalFieldCount() const; /* * Sets the number of internal fields for objects generated from * this template. / void SetInternalFieldCount(int value); /* * Returns true if the object will be an immutable prototype exotic object. / bool IsImmutableProto() const; /* * Makes the ObjectTemplate for an immutable prototype exotic object, with an * immutable __proto__. / void SetImmutableProto(); /* * Support for TC39 "dynamic code brand checks" proposal. * * This API allows to mark (& query) objects as "code like", which causes * them to be treated like Strings in the context of eval and function * constructor. * * Reference: https://github.com/tc39/proposal-dynamic-code-brand-checks / void SetCodeLike(); bool IsCodeLike() const; V8_INLINE static ObjectTemplate Cast(Data* data); private: ObjectTemplate(); static void CheckCast(Data* that); friend class FunctionTemplate; }; /** * A template to create dictionary objects at runtime. / class V8_EXPORT DictionaryTemplate final { public: /* Creates a new template. Also declares data properties that can be passed * on instantiation of the template. Properties can only be declared on * construction and are then immutable. The values are passed on creating the * object via `NewInstance()`. * * \param names the keys that can be passed on instantiation. / static Local<DictionaryTemplate> New( Isolate isolate, MemorySpan<const std::string_view> names); /** * Creates a new instance of this template. * * \param context The context used to create the dictionary object. * \param property_values Values of properties that were declared using * `DeclareDataProperties()`. The span only passes values and expectes the * order to match the declaration. Non-existent properties are signaled via * empty `MaybeLocal`s. / V8_WARN_UNUSED_RESULT Local<Object> NewInstance( Local<Context> context, MemorySpan<MaybeLocal<Value>> property_values); V8_INLINE static DictionaryTemplate Cast(Data* data); private: static void CheckCast(Data* that); DictionaryTemplate(); }; /** * A Signature specifies which receiver is valid for a function. * * A receiver matches a given signature if the receiver (or any of its * hidden prototypes) was created from the signature's FunctionTemplate, or * from a FunctionTemplate that inherits directly or indirectly from the * signature's FunctionTemplate. / class V8_EXPORT Signature : public Data { public: static Local<Signature> New( Isolate isolate, Local<FunctionTemplate> receiver = Local<FunctionTemplate>()); V8_INLINE static Signature* Cast(Data* data); private: Signature(); static void CheckCast(Data* that); }; // --- Implementation --- void Template::Set(Isolate* isolate, const char* name, Local<Data> value, PropertyAttribute attributes) { Set(String::NewFromUtf8(isolate, name, NewStringType::kInternalized) .ToLocalChecked(), value, attributes); } FunctionTemplate* FunctionTemplate::Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return reinterpret_cast<FunctionTemplate>(data); } ObjectTemplate ObjectTemplate::Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return reinterpret_cast<ObjectTemplate>(data); } DictionaryTemplate DictionaryTemplate::Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return reinterpret_cast<DictionaryTemplate>(data); } Signature Signature::Cast(Data* data) { #ifdef V8_ENABLE_CHECKS CheckCast(data); #endif return reinterpret_cast<Signature*>(data); } } // namespace v8 #endif // INCLUDE_V8_TEMPLATE_H_	50.36 KB	2025-03-03 12:36
📄 v8-traced-handle.h // Copyright 2021 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. #ifndef INCLUDE_V8_TRACED_HANDLE_H_ #define INCLUDE_V8_TRACED_HANDLE_H_ #include <stddef.h> #include <stdint.h> #include <stdio.h> #include <atomic> #include <memory> #include <type_traits> #include <utility> #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-weak-callback-info.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Value; namespace internal { class BasicTracedReferenceExtractor; enum class TracedReferenceStoreMode { kInitializingStore, kAssigningStore, }; enum class TracedReferenceHandling { kDefault, // See EmbedderRootsHandler::IsRoot(). kDroppable }; V8_EXPORT internal::Address* GlobalizeTracedReference( internal::Isolate* isolate, internal::Address value, internal::Address* slot, TracedReferenceStoreMode store_mode, internal::TracedReferenceHandling reference_handling); V8_EXPORT void MoveTracedReference(internal::Address from, internal::Address to); V8_EXPORT void CopyTracedReference(const internal::Address* const* from, internal::Address** to); V8_EXPORT void DisposeTracedReference(internal::Address* global_handle); } // namespace internal /** * An indirect handle, where the indirect pointer points to a GlobalHandles * node. / class TracedReferenceBase : public api_internal::IndirectHandleBase { public: /* * If non-empty, destroy the underlying storage cell. \|IsEmpty\| will return * true after this call. / V8_INLINE void Reset(); /* * Construct a Local<Value> from this handle. / V8_INLINE Local<Value> Get(Isolate isolate) const { if (IsEmpty()) return Local<Value>(); return Local<Value>::New(isolate, this->value<Value>()); } /** * Returns true if this TracedReference is empty, i.e., has not been * assigned an object. This version of IsEmpty is thread-safe. / bool IsEmptyThreadSafe() const { return this->GetSlotThreadSafe() == nullptr; } protected: V8_INLINE TracedReferenceBase() = default; /* * Update this reference in a thread-safe way. / void SetSlotThreadSafe(void new_val) { reinterpret_cast<std::atomic<void>>(&slot())->store( new_val, std::memory_order_relaxed); } /** * Get this reference in a thread-safe way / const void GetSlotThreadSafe() const { return reinterpret_cast<std::atomic<const void> const>(&slot())->load( std::memory_order_relaxed); } V8_EXPORT void CheckValue() const; friend class internal::BasicTracedReferenceExtractor; template <typename F> friend class Local; template <typename U> friend bool operator==(const TracedReferenceBase&, const Local<U>&); friend bool operator==(const TracedReferenceBase&, const TracedReferenceBase&); }; /** * A traced handle with copy and move semantics. The handle is to be used * together as part of GarbageCollected objects (see v8-cppgc.h) or from stack * and specifies edges from C++ objects to JavaScript. * * The exact semantics are: * - Tracing garbage collections using CppHeap. * - Non-tracing garbage collections refer to * \|v8::EmbedderRootsHandler::IsRoot()\| whether the handle should * be treated as root or not. * * Note that the base class cannot be instantiated itself, use \|TracedReference\| * instead. / template <typename T> class BasicTracedReference : public TracedReferenceBase { public: /* * Construct a Local<T> from this handle. / Local<T> Get(Isolate isolate) const { return Local<T>::New(isolate, this); } template <class S> V8_INLINE BasicTracedReference<S>& As() const { return reinterpret_cast<BasicTracedReference<S>&>( const_cast<BasicTracedReference<T>&>(this)); } V8_DEPRECATE_SOON("Use Get to convert to Local instead") V8_INLINE T* operator->() const { #ifdef V8_ENABLE_CHECKS CheckValue(); #endif // V8_ENABLE_CHECKS return this->template value<T>(); } V8_DEPRECATE_SOON("Use Get to convert to Local instead") V8_INLINE T* operator() const { return this->operator->(); } private: /* * An empty BasicTracedReference without storage cell. / BasicTracedReference() = default; V8_INLINE static internal::Address NewFromNonEmptyValue( Isolate* isolate, T* that, internal::Address slot, internal::TracedReferenceStoreMode store_mode, internal::TracedReferenceHandling reference_handling); template <typename F> friend class Local; friend class Object; template <typename F> friend class TracedReference; template <typename F> friend class BasicTracedReference; template <typename F> friend class ReturnValue; }; / * A traced handle without destructor that clears the handle. The embedder needs * to ensure that the handle is not accessed once the V8 object has been * reclaimed. For more details see BasicTracedReference. / template <typename T> class TracedReference : public BasicTracedReference<T> { public: struct IsDroppable {}; using BasicTracedReference<T>::Reset; /* * An empty TracedReference without storage cell. / V8_INLINE TracedReference() = default; /* * Construct a TracedReference from a Local. * * When the Local is non-empty, a new storage cell is created * pointing to the same object. / template <class S> TracedReference(Isolate isolate, Local<S> that) : BasicTracedReference<T>() { static_assert(std::is_base_of<T, S>::value, "type check"); if (V8_UNLIKELY(that.IsEmpty())) { return; } this->slot() = this->NewFromNonEmptyValue( isolate, that, &this->slot(), internal::TracedReferenceStoreMode::kInitializingStore, internal::TracedReferenceHandling::kDefault); } /* * Construct a droppable TracedReference from a Local. Droppable means that V8 * is free to reclaim the pointee if it is unmodified and otherwise * unreachable * * When the Local is non-empty, a new storage cell is created * pointing to the same object. / template <class S> TracedReference(Isolate isolate, Local<S> that, IsDroppable) : BasicTracedReference<T>() { static_assert(std::is_base_of<T, S>::value, "type check"); if (V8_UNLIKELY(that.IsEmpty())) { return; } this->slot() = this->NewFromNonEmptyValue( isolate, that, &this->slot(), internal::TracedReferenceStoreMode::kInitializingStore, internal::TracedReferenceHandling::kDroppable); } /* * Move constructor initializing TracedReference from an * existing one. / V8_INLINE TracedReference(TracedReference&& other) noexcept { // Forward to operator=. this = std::move(other); } /** * Move constructor initializing TracedReference from an * existing one. / template <typename S> V8_INLINE TracedReference(TracedReference<S>&& other) noexcept { // Forward to operator=. this = std::move(other); } /** * Copy constructor initializing TracedReference from an * existing one. / V8_INLINE TracedReference(const TracedReference& other) { // Forward to operator=; this = other; } /** * Copy constructor initializing TracedReference from an * existing one. / template <typename S> V8_INLINE TracedReference(const TracedReference<S>& other) { // Forward to operator=; this = other; } /** * Move assignment operator initializing TracedReference from an existing one. / V8_INLINE TracedReference& operator=(TracedReference&& rhs) noexcept; /* * Move assignment operator initializing TracedReference from an existing one. / template <class S> V8_INLINE TracedReference& operator=(TracedReference<S>&& rhs) noexcept; /* * Copy assignment operator initializing TracedReference from an existing one. / V8_INLINE TracedReference& operator=(const TracedReference& rhs); /* * Copy assignment operator initializing TracedReference from an existing one. / template <class S> V8_INLINE TracedReference& operator=(const TracedReference<S>& rhs); /* * Always resets the reference. Creates a new reference from `other` if it is * non-empty. / template <class S> V8_INLINE void Reset(Isolate isolate, const Local<S>& other); /** * Always resets the reference. Creates a new reference from `other` if it is * non-empty. The new reference is droppable, see constructor. / template <class S> V8_INLINE void Reset(Isolate isolate, const Local<S>& other, IsDroppable); template <class S> V8_INLINE TracedReference<S>& As() const { return reinterpret_cast<TracedReference<S>&>( const_cast<TracedReference<T>&>(this)); } }; // --- Implementation --- template <class T> internal::Address BasicTracedReference<T>::NewFromNonEmptyValue( Isolate* isolate, T* that, internal::Address** slot, internal::TracedReferenceStoreMode store_mode, internal::TracedReferenceHandling reference_handling) { return internal::GlobalizeTracedReference( reinterpret_cast<internal::Isolate>(isolate), internal::ValueHelper::ValueAsAddress(that), reinterpret_cast<internal::Address>(slot), store_mode, reference_handling); } void TracedReferenceBase::Reset() { if (V8_UNLIKELY(IsEmpty())) { return; } internal::DisposeTracedReference(slot()); SetSlotThreadSafe(nullptr); } V8_INLINE bool operator==(const TracedReferenceBase& lhs, const TracedReferenceBase& rhs) { return internal::HandleHelper::EqualHandles(lhs, rhs); } template <typename U> V8_INLINE bool operator==(const TracedReferenceBase& lhs, const v8::Local<U>& rhs) { return internal::HandleHelper::EqualHandles(lhs, rhs); } template <typename U> V8_INLINE bool operator==(const v8::Local<U>& lhs, const TracedReferenceBase& rhs) { return rhs == lhs; } V8_INLINE bool operator!=(const TracedReferenceBase& lhs, const TracedReferenceBase& rhs) { return !(lhs == rhs); } template <typename U> V8_INLINE bool operator!=(const TracedReferenceBase& lhs, const v8::Local<U>& rhs) { return !(lhs == rhs); } template <typename U> V8_INLINE bool operator!=(const v8::Local<U>& lhs, const TracedReferenceBase& rhs) { return !(rhs == lhs); } template <class T> template <class S> void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) { static_assert(std::is_base_of<T, S>::value, "type check"); this->Reset(); if (V8_UNLIKELY(other.IsEmpty())) { return; } this->SetSlotThreadSafe(this->NewFromNonEmptyValue( isolate, other, &this->slot(), internal::TracedReferenceStoreMode::kAssigningStore, internal::TracedReferenceHandling::kDefault)); } template <class T> template <class S> void TracedReference<T>::Reset(Isolate isolate, const Local<S>& other, IsDroppable) { static_assert(std::is_base_of<T, S>::value, "type check"); this->Reset(); if (V8_UNLIKELY(other.IsEmpty())) { return; } this->SetSlotThreadSafe(this->NewFromNonEmptyValue( isolate, other, &this->slot(), internal::TracedReferenceStoreMode::kAssigningStore, internal::TracedReferenceHandling::kDroppable)); } template <class T> template <class S> TracedReference<T>& TracedReference<T>::operator=( TracedReference<S>&& rhs) noexcept { static_assert(std::is_base_of<T, S>::value, "type check"); this = std::move(rhs.template As<T>()); return this; } template <class T> template <class S> TracedReference<T>& TracedReference<T>::operator=( const TracedReference<S>& rhs) { static_assert(std::is_base_of<T, S>::value, "type check"); this = rhs.template As<T>(); return this; } template <class T> TracedReference<T>& TracedReference<T>::operator=( TracedReference&& rhs) noexcept { if (this != &rhs) { internal::MoveTracedReference(&rhs.slot(), &this->slot()); } return this; } template <class T> TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) { if (this != &rhs) { this->Reset(); if (!rhs.IsEmpty()) { internal::CopyTracedReference(&rhs.slot(), &this->slot()); } } return *this; } } // namespace v8 #endif // INCLUDE_V8_TRACED_HANDLE_H_	12.4 KB	2025-03-03 12:36
📄 v8-typed-array.h // Copyright 2021 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. #ifndef INCLUDE_V8_TYPED_ARRAY_H_ #define INCLUDE_V8_TYPED_ARRAY_H_ #include <limits> #include "v8-array-buffer.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { /** * A base class for an instance of TypedArray series of constructors * (ES6 draft 15.13.6). / class V8_EXPORT TypedArray : public ArrayBufferView { public: / * The largest supported typed array byte size. Each subclass defines a * type-specific kMaxLength for the maximum length that can be passed to New. / #if V8_ENABLE_SANDBOX static constexpr size_t kMaxByteLength = internal::kMaxSafeBufferSizeForSandbox; #elif V8_HOST_ARCH_32_BIT static constexpr size_t kMaxByteLength = std::numeric_limits<int>::max(); #else // The maximum safe integer (2^53 - 1). static constexpr size_t kMaxByteLength = static_cast<size_t>((uint64_t{1} << 53) - 1); #endif /* * Number of elements in this typed array * (e.g. for Int16Array, \|ByteLength\|/2). / size_t Length(); V8_INLINE static TypedArray Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<TypedArray>(value); } private: TypedArray(); static void CheckCast(Value obj); }; /** * An instance of Uint8Array constructor (ES6 draft 15.13.6). / class V8_EXPORT Uint8Array : public TypedArray { public: / * The largest Uint8Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(uint8_t); static_assert(sizeof(uint8_t) == 1); static Local<Uint8Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Uint8Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Uint8Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Uint8Array>(value); } private: Uint8Array(); static void CheckCast(Value obj); }; /** * An instance of Uint8ClampedArray constructor (ES6 draft 15.13.6). / class V8_EXPORT Uint8ClampedArray : public TypedArray { public: / * The largest Uint8ClampedArray size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(uint8_t); static_assert(sizeof(uint8_t) == 1); static Local<Uint8ClampedArray> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Uint8ClampedArray> New( Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Uint8ClampedArray Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Uint8ClampedArray>(value); } private: Uint8ClampedArray(); static void CheckCast(Value obj); }; /** * An instance of Int8Array constructor (ES6 draft 15.13.6). / class V8_EXPORT Int8Array : public TypedArray { public: / * The largest Int8Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(int8_t); static_assert(sizeof(int8_t) == 1); static Local<Int8Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Int8Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Int8Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Int8Array>(value); } private: Int8Array(); static void CheckCast(Value obj); }; /** * An instance of Uint16Array constructor (ES6 draft 15.13.6). / class V8_EXPORT Uint16Array : public TypedArray { public: / * The largest Uint16Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(uint16_t); static_assert(sizeof(uint16_t) == 2); static Local<Uint16Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Uint16Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Uint16Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Uint16Array>(value); } private: Uint16Array(); static void CheckCast(Value obj); }; /** * An instance of Int16Array constructor (ES6 draft 15.13.6). / class V8_EXPORT Int16Array : public TypedArray { public: / * The largest Int16Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(int16_t); static_assert(sizeof(int16_t) == 2); static Local<Int16Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Int16Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Int16Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Int16Array>(value); } private: Int16Array(); static void CheckCast(Value obj); }; /** * An instance of Uint32Array constructor (ES6 draft 15.13.6). / class V8_EXPORT Uint32Array : public TypedArray { public: / * The largest Uint32Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(uint32_t); static_assert(sizeof(uint32_t) == 4); static Local<Uint32Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Uint32Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Uint32Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Uint32Array>(value); } private: Uint32Array(); static void CheckCast(Value obj); }; /** * An instance of Int32Array constructor (ES6 draft 15.13.6). / class V8_EXPORT Int32Array : public TypedArray { public: / * The largest Int32Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(int32_t); static_assert(sizeof(int32_t) == 4); static Local<Int32Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Int32Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Int32Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Int32Array>(value); } private: Int32Array(); static void CheckCast(Value obj); }; /** * An instance of Float16Array constructor. / class V8_EXPORT Float16Array : public TypedArray { static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(uint16_t); public: static Local<Float16Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Float16Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Float16Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Float16Array>(value); } private: Float16Array(); static void CheckCast(Value obj); }; /** * An instance of Float32Array constructor (ES6 draft 15.13.6). / class V8_EXPORT Float32Array : public TypedArray { public: / * The largest Float32Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(float); static_assert(sizeof(float) == 4); static Local<Float32Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Float32Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Float32Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Float32Array>(value); } private: Float32Array(); static void CheckCast(Value obj); }; /** * An instance of Float64Array constructor (ES6 draft 15.13.6). / class V8_EXPORT Float64Array : public TypedArray { public: / * The largest Float64Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(double); static_assert(sizeof(double) == 8); static Local<Float64Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<Float64Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static Float64Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Float64Array>(value); } private: Float64Array(); static void CheckCast(Value obj); }; /** * An instance of BigInt64Array constructor. / class V8_EXPORT BigInt64Array : public TypedArray { public: / * The largest BigInt64Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(int64_t); static_assert(sizeof(int64_t) == 8); static Local<BigInt64Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<BigInt64Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static BigInt64Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<BigInt64Array>(value); } private: BigInt64Array(); static void CheckCast(Value obj); }; /** * An instance of BigUint64Array constructor. / class V8_EXPORT BigUint64Array : public TypedArray { public: / * The largest BigUint64Array size that can be constructed using New. / static constexpr size_t kMaxLength = TypedArray::kMaxByteLength / sizeof(uint64_t); static_assert(sizeof(uint64_t) == 8); static Local<BigUint64Array> New(Local<ArrayBuffer> array_buffer, size_t byte_offset, size_t length); static Local<BigUint64Array> New(Local<SharedArrayBuffer> shared_array_buffer, size_t byte_offset, size_t length); V8_INLINE static BigUint64Array Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<BigUint64Array>(value); } private: BigUint64Array(); static void CheckCast(Value obj); }; } // namespace v8 #endif // INCLUDE_V8_TYPED_ARRAY_H_	11.3 KB	2025-03-03 12:36
📄 v8-unwinder.h // Copyright 2021 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. #ifndef INCLUDE_V8_UNWINDER_H_ #define INCLUDE_V8_UNWINDER_H_ #include <memory> #include "v8-embedder-state-scope.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { // Holds the callee saved registers needed for the stack unwinder. It is the // empty struct if no registers are required. Implemented in // include/v8-unwinder-state.h. struct CalleeSavedRegisters; // A RegisterState represents the current state of registers used // by the sampling profiler API. struct V8_EXPORT RegisterState { RegisterState(); ~RegisterState(); RegisterState(const RegisterState& other); RegisterState& operator=(const RegisterState& other); void* pc; // Instruction pointer. void* sp; // Stack pointer. void* fp; // Frame pointer. void* lr; // Link register (or nullptr on platforms without a link register). // Callee saved registers (or null if no callee saved registers were stored) std::unique_ptr<CalleeSavedRegisters> callee_saved; }; // A StateTag represents a possible state of the VM. enum StateTag : uint16_t { JS, GC, PARSER, BYTECODE_COMPILER, COMPILER, OTHER, EXTERNAL, ATOMICS_WAIT, IDLE }; // The output structure filled up by GetStackSample API function. struct SampleInfo { size_t frames_count; // Number of frames collected. void* external_callback_entry; // External callback address if VM is // executing an external callback. void* context; // Incumbent native context address. void* embedder_context; // Native context address for embedder state StateTag vm_state; // Current VM state. EmbedderStateTag embedder_state; // Current Embedder state }; struct MemoryRange { const void* start = nullptr; size_t length_in_bytes = 0; }; struct JSEntryStub { MemoryRange code; }; struct JSEntryStubs { JSEntryStub js_entry_stub; JSEntryStub js_construct_entry_stub; JSEntryStub js_run_microtasks_entry_stub; }; /** * Various helpers for skipping over V8 frames in a given stack. * * The unwinder API is only supported on the x64, ARM64 and ARM32 architectures. / class V8_EXPORT Unwinder { public: /* * Attempt to unwind the stack to the most recent C++ frame. This function is * signal-safe and does not access any V8 state and thus doesn't require an * Isolate. * * The unwinder needs to know the location of the JS Entry Stub (a piece of * code that is run when C++ code calls into generated JS code). This is used * for edge cases where the current frame is being constructed or torn down * when the stack sample occurs. * * The unwinder also needs the virtual memory range of all possible V8 code * objects. There are two ranges required - the heap code range and the range * for code embedded in the binary. * * Available on x64, ARM64 and ARM32. * * \param code_pages A list of all of the ranges in which V8 has allocated * executable code. The caller should obtain this list by calling * Isolate::CopyCodePages() during the same interrupt/thread suspension that * captures the stack. * \param register_state The current registers. This is an in-out param that * will be overwritten with the register values after unwinding, on success. * \param stack_base The resulting stack pointer and frame pointer values are * bounds-checked against the stack_base and the original stack pointer value * to ensure that they are valid locations in the given stack. If these values * or any intermediate frame pointer values used during unwinding are ever out * of these bounds, unwinding will fail. * * \return True on success. / static bool TryUnwindV8Frames(const JSEntryStubs& entry_stubs, size_t code_pages_length, const MemoryRange code_pages, RegisterState* register_state, const void* stack_base); /** * Whether the PC is within the V8 code range represented by code_pages. * * If this returns false, then calling UnwindV8Frames() with the same PC * and unwind_state will always fail. If it returns true, then unwinding may * (but not necessarily) be successful. * * Available on x64, ARM64 and ARM32 / static bool PCIsInV8(size_t code_pages_length, const MemoryRange code_pages, void* pc); }; } // namespace v8 #endif // INCLUDE_V8_UNWINDER_H_	4.64 KB	2025-03-03 12:36
📄 v8-value-serializer.h // Copyright 2021 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. #ifndef INCLUDE_V8_VALUE_SERIALIZER_H_ #define INCLUDE_V8_VALUE_SERIALIZER_H_ #include <stddef.h> #include <stdint.h> #include <memory> #include <utility> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-maybe.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class ArrayBuffer; class Isolate; class Object; class SharedArrayBuffer; class String; class WasmModuleObject; class Value; namespace internal { struct ScriptStreamingData; class SharedObjectConveyorHandles; class ValueDeserializer; class ValueSerializer; } // namespace internal /** * A move-only class for managing the lifetime of shared value conveyors used * by V8 to keep JS shared values alive in transit when serialized. * * This class is not directly constructible and is always passed to a * ValueSerializer::Delegate via ValueSerializer::SetSharedValueConveyor. * * The embedder must not destruct the SharedValueConveyor until the associated * serialized data will no longer be deserialized. / class V8_EXPORT SharedValueConveyor final { public: SharedValueConveyor(SharedValueConveyor&&) noexcept; ~SharedValueConveyor(); SharedValueConveyor& operator=(SharedValueConveyor&&) noexcept; private: friend class internal::ValueSerializer; friend class internal::ValueDeserializer; explicit SharedValueConveyor(Isolate isolate); std::unique_ptr<internal::SharedObjectConveyorHandles> private_; }; /** * Value serialization compatible with the HTML structured clone algorithm. * The format is backward-compatible (i.e. safe to store to disk). / class V8_EXPORT ValueSerializer { public: class V8_EXPORT Delegate { public: virtual ~Delegate() = default; /* * Handles the case where a DataCloneError would be thrown in the structured * clone spec. Other V8 embedders may throw some other appropriate exception * type. / virtual void ThrowDataCloneError(Local<String> message) = 0; /* * The embedder overrides this method to enable custom host object filter * with Delegate::IsHostObject. * * This method is called at most once per serializer. / virtual bool HasCustomHostObject(Isolate isolate); /** * The embedder overrides this method to determine if an JS object is a * host object and needs to be serialized by the host. / virtual Maybe<bool> IsHostObject(Isolate isolate, Local<Object> object); /** * The embedder overrides this method to write some kind of host object, if * possible. If not, a suitable exception should be thrown and * Nothing<bool>() returned. / virtual Maybe<bool> WriteHostObject(Isolate isolate, Local<Object> object); /** * Called when the ValueSerializer is going to serialize a * SharedArrayBuffer object. The embedder must return an ID for the * object, using the same ID if this SharedArrayBuffer has already been * serialized in this buffer. When deserializing, this ID will be passed to * ValueDeserializer::GetSharedArrayBufferFromId as \|clone_id\|. * * If the object cannot be serialized, an * exception should be thrown and Nothing<uint32_t>() returned. / virtual Maybe<uint32_t> GetSharedArrayBufferId( Isolate isolate, Local<SharedArrayBuffer> shared_array_buffer); virtual Maybe<uint32_t> GetWasmModuleTransferId( Isolate* isolate, Local<WasmModuleObject> module); /** * Called when the first shared value is serialized. All subsequent shared * values will use the same conveyor. * * The embedder must ensure the lifetime of the conveyor matches the * lifetime of the serialized data. * * If the embedder supports serializing shared values, this method should * return true. Otherwise the embedder should throw an exception and return * false. * * This method is called at most once per serializer. / virtual bool AdoptSharedValueConveyor(Isolate isolate, SharedValueConveyor&& conveyor); /** * Allocates memory for the buffer of at least the size provided. The actual * size (which may be greater or equal) is written to \|actual_size\|. If no * buffer has been allocated yet, nullptr will be provided. * * If the memory cannot be allocated, nullptr should be returned. * \|actual_size\| will be ignored. It is assumed that \|old_buffer\| is still * valid in this case and has not been modified. * * The default implementation uses the stdlib's `realloc()` function. / virtual void ReallocateBufferMemory(void* old_buffer, size_t size, size_t* actual_size); /** * Frees a buffer allocated with \|ReallocateBufferMemory\|. * * The default implementation uses the stdlib's `free()` function. / virtual void FreeBufferMemory(void buffer); }; explicit ValueSerializer(Isolate* isolate); ValueSerializer(Isolate* isolate, Delegate* delegate); ~ValueSerializer(); /** * Writes out a header, which includes the format version. / void WriteHeader(); /* * Serializes a JavaScript value into the buffer. / V8_WARN_UNUSED_RESULT Maybe<bool> WriteValue(Local<Context> context, Local<Value> value); /* * Returns the stored data (allocated using the delegate's * ReallocateBufferMemory) and its size. This serializer should not be used * once the buffer is released. The contents are undefined if a previous write * has failed. Ownership of the buffer is transferred to the caller. / V8_WARN_UNUSED_RESULT std::pair<uint8_t, size_t> Release(); /** * Marks an ArrayBuffer as havings its contents transferred out of band. * Pass the corresponding ArrayBuffer in the deserializing context to * ValueDeserializer::TransferArrayBuffer. / void TransferArrayBuffer(uint32_t transfer_id, Local<ArrayBuffer> array_buffer); /* * Indicate whether to treat ArrayBufferView objects as host objects, * i.e. pass them to Delegate::WriteHostObject. This should not be * called when no Delegate was passed. * * The default is not to treat ArrayBufferViews as host objects. / void SetTreatArrayBufferViewsAsHostObjects(bool mode); /* * Write raw data in various common formats to the buffer. * Note that integer types are written in base-128 varint format, not with a * binary copy. For use during an override of Delegate::WriteHostObject. / void WriteUint32(uint32_t value); void WriteUint64(uint64_t value); void WriteDouble(double value); void WriteRawBytes(const void source, size_t length); ValueSerializer(const ValueSerializer&) = delete; void operator=(const ValueSerializer&) = delete; private: struct PrivateData; PrivateData* private_; }; /** * Deserializes values from data written with ValueSerializer, or a compatible * implementation. / class V8_EXPORT ValueDeserializer { public: class V8_EXPORT Delegate { public: virtual ~Delegate() = default; /* * The embedder overrides this method to read some kind of host object, if * possible. If not, a suitable exception should be thrown and * MaybeLocal<Object>() returned. / virtual MaybeLocal<Object> ReadHostObject(Isolate isolate); /** * Get a WasmModuleObject given a transfer_id previously provided * by ValueSerializer::Delegate::GetWasmModuleTransferId / virtual MaybeLocal<WasmModuleObject> GetWasmModuleFromId( Isolate isolate, uint32_t transfer_id); /** * Get a SharedArrayBuffer given a clone_id previously provided * by ValueSerializer::Delegate::GetSharedArrayBufferId / virtual MaybeLocal<SharedArrayBuffer> GetSharedArrayBufferFromId( Isolate isolate, uint32_t clone_id); /** * Get the SharedValueConveyor previously provided by * ValueSerializer::Delegate::AdoptSharedValueConveyor. / virtual const SharedValueConveyor GetSharedValueConveyor(Isolate* isolate); }; ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size); ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size, Delegate* delegate); ~ValueDeserializer(); /** * Reads and validates a header (including the format version). * May, for example, reject an invalid or unsupported wire format. / V8_WARN_UNUSED_RESULT Maybe<bool> ReadHeader(Local<Context> context); /* * Deserializes a JavaScript value from the buffer. / V8_WARN_UNUSED_RESULT MaybeLocal<Value> ReadValue(Local<Context> context); /* * Accepts the array buffer corresponding to the one passed previously to * ValueSerializer::TransferArrayBuffer. / void TransferArrayBuffer(uint32_t transfer_id, Local<ArrayBuffer> array_buffer); /* * Similar to TransferArrayBuffer, but for SharedArrayBuffer. * The id is not necessarily in the same namespace as unshared ArrayBuffer * objects. / void TransferSharedArrayBuffer(uint32_t id, Local<SharedArrayBuffer> shared_array_buffer); /* * Must be called before ReadHeader to enable support for reading the legacy * wire format (i.e., which predates this being shipped). * * Don't use this unless you need to read data written by previous versions of * blink::ScriptValueSerializer. / void SetSupportsLegacyWireFormat(bool supports_legacy_wire_format); /* * Reads the underlying wire format version. Likely mostly to be useful to * legacy code reading old wire format versions. Must be called after * ReadHeader. / uint32_t GetWireFormatVersion() const; /* * Reads raw data in various common formats to the buffer. * Note that integer types are read in base-128 varint format, not with a * binary copy. For use during an override of Delegate::ReadHostObject. / V8_WARN_UNUSED_RESULT bool ReadUint32(uint32_t value); V8_WARN_UNUSED_RESULT bool ReadUint64(uint64_t* value); V8_WARN_UNUSED_RESULT bool ReadDouble(double* value); V8_WARN_UNUSED_RESULT bool ReadRawBytes(size_t length, const void** data); ValueDeserializer(const ValueDeserializer&) = delete; void operator=(const ValueDeserializer&) = delete; private: struct PrivateData; PrivateData* private_; }; } // namespace v8 #endif // INCLUDE_V8_VALUE_SERIALIZER_H_	10.56 KB	2025-03-03 12:36
📄 v8-value.h // Copyright 2021 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. #ifndef INCLUDE_V8_VALUE_H_ #define INCLUDE_V8_VALUE_H_ #include "v8-data.h" // NOLINT(build/include_directory) #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-maybe.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) /** * The v8 JavaScript engine. / namespace v8 { class Primitive; class Numeric; class BigInt; class Int32; class Integer; class Number; class Object; class String; class Uint32; /* * The superclass of all JavaScript values and objects. / class V8_EXPORT Value : public Data { public: /* * Returns true if this value is the undefined value. See ECMA-262 * 4.3.10. * * This is equivalent to `value === undefined` in JS. / V8_INLINE bool IsUndefined() const; /* * Returns true if this value is the null value. See ECMA-262 * 4.3.11. * * This is equivalent to `value === null` in JS. / V8_INLINE bool IsNull() const; /* * Returns true if this value is either the null or the undefined value. * See ECMA-262 * 4.3.11. and 4.3.12 * * This is equivalent to `value == null` in JS. / V8_INLINE bool IsNullOrUndefined() const; /* * Returns true if this value is true. * * This is not the same as `BooleanValue()`. The latter performs a * conversion to boolean, i.e. the result of `Boolean(value)` in JS, whereas * this checks `value === true`. / V8_INLINE bool IsTrue() const; /* * Returns true if this value is false. * * This is not the same as `!BooleanValue()`. The latter performs a * conversion to boolean, i.e. the result of `!Boolean(value)` in JS, whereas * this checks `value === false`. / V8_INLINE bool IsFalse() const; /* * Returns true if this value is a symbol or a string. * * This is equivalent to * `typeof value === 'string' \|\| typeof value === 'symbol'` in JS. / bool IsName() const; /* * Returns true if this value is an instance of the String type. * See ECMA-262 8.4. * * This is equivalent to `typeof value === 'string'` in JS. / V8_INLINE bool IsString() const; /* * Returns true if this value is a symbol. * * This is equivalent to `typeof value === 'symbol'` in JS. / bool IsSymbol() const; /* * Returns true if this value is a function. * * This is equivalent to `typeof value === 'function'` in JS. / bool IsFunction() const; /* * Returns true if this value is an array. Note that it will return false for * an Proxy for an array. / bool IsArray() const; /* * Returns true if this value is an object. / bool IsObject() const; /* * Returns true if this value is a bigint. * * This is equivalent to `typeof value === 'bigint'` in JS. / bool IsBigInt() const; /* * Returns true if this value is boolean. * * This is equivalent to `typeof value === 'boolean'` in JS. / bool IsBoolean() const; /* * Returns true if this value is a number. * * This is equivalent to `typeof value === 'number'` in JS. / bool IsNumber() const; /* * Returns true if this value is an `External` object. / bool IsExternal() const; /* * Returns true if this value is a 32-bit signed integer. / bool IsInt32() const; /* * Returns true if this value is a 32-bit unsigned integer. / bool IsUint32() const; /* * Returns true if this value is a Date. / bool IsDate() const; /* * Returns true if this value is an Arguments object. / bool IsArgumentsObject() const; /* * Returns true if this value is a BigInt object. / bool IsBigIntObject() const; /* * Returns true if this value is a Boolean object. / bool IsBooleanObject() const; /* * Returns true if this value is a Number object. / bool IsNumberObject() const; /* * Returns true if this value is a String object. / bool IsStringObject() const; /* * Returns true if this value is a Symbol object. / bool IsSymbolObject() const; /* * Returns true if this value is a NativeError. / bool IsNativeError() const; /* * Returns true if this value is a RegExp. / bool IsRegExp() const; /* * Returns true if this value is an async function. / bool IsAsyncFunction() const; /* * Returns true if this value is a Generator function. / bool IsGeneratorFunction() const; /* * Returns true if this value is a Generator object (iterator). / bool IsGeneratorObject() const; /* * Returns true if this value is a Promise. / bool IsPromise() const; /* * Returns true if this value is a Map. / bool IsMap() const; /* * Returns true if this value is a Set. / bool IsSet() const; /* * Returns true if this value is a Map Iterator. / bool IsMapIterator() const; /* * Returns true if this value is a Set Iterator. / bool IsSetIterator() const; /* * Returns true if this value is a WeakMap. / bool IsWeakMap() const; /* * Returns true if this value is a WeakSet. / bool IsWeakSet() const; /* * Returns true if this value is a WeakRef. / bool IsWeakRef() const; /* * Returns true if this value is an ArrayBuffer. / bool IsArrayBuffer() const; /* * Returns true if this value is an ArrayBufferView. / bool IsArrayBufferView() const; /* * Returns true if this value is one of TypedArrays. / bool IsTypedArray() const; /* * Returns true if this value is an Uint8Array. / bool IsUint8Array() const; /* * Returns true if this value is an Uint8ClampedArray. / bool IsUint8ClampedArray() const; /* * Returns true if this value is an Int8Array. / bool IsInt8Array() const; /* * Returns true if this value is an Uint16Array. / bool IsUint16Array() const; /* * Returns true if this value is an Int16Array. / bool IsInt16Array() const; /* * Returns true if this value is an Uint32Array. / bool IsUint32Array() const; /* * Returns true if this value is an Int32Array. / bool IsInt32Array() const; /* * Returns true if this value is a Float16Array. / bool IsFloat16Array() const; /* * Returns true if this value is a Float32Array. / bool IsFloat32Array() const; /* * Returns true if this value is a Float64Array. / bool IsFloat64Array() const; /* * Returns true if this value is a BigInt64Array. / bool IsBigInt64Array() const; /* * Returns true if this value is a BigUint64Array. / bool IsBigUint64Array() const; /* * Returns true if this value is a DataView. / bool IsDataView() const; /* * Returns true if this value is a SharedArrayBuffer. / bool IsSharedArrayBuffer() const; /* * Returns true if this value is a JavaScript Proxy. / bool IsProxy() const; /* * Returns true if this value is a WasmMemoryObject. / bool IsWasmMemoryObject() const; /* * Returns true if this value is a WasmModuleObject. / bool IsWasmModuleObject() const; /* * Returns true if this value is the WasmNull object. / bool IsWasmNull() const; /* * Returns true if the value is a Module Namespace Object. / bool IsModuleNamespaceObject() const; /* * Perform `ToPrimitive(value)` as specified in: * https://tc39.es/ecma262/#sec-toprimitive. / V8_WARN_UNUSED_RESULT MaybeLocal<Primitive> ToPrimitive( Local<Context> context) const; /* * Perform `ToNumeric(value)` as specified in: * https://tc39.es/ecma262/#sec-tonumeric. / V8_WARN_UNUSED_RESULT MaybeLocal<Numeric> ToNumeric( Local<Context> context) const; /* * Perform the equivalent of `BigInt(value)` in JS. / V8_WARN_UNUSED_RESULT MaybeLocal<BigInt> ToBigInt( Local<Context> context) const; /* * Perform the equivalent of `Number(value)` in JS. / V8_WARN_UNUSED_RESULT MaybeLocal<Number> ToNumber( Local<Context> context) const; /* * Perform the equivalent of `String(value)` in JS. / V8_WARN_UNUSED_RESULT MaybeLocal<String> ToString( Local<Context> context) const; /* * Provide a string representation of this value usable for debugging. * This operation has no observable side effects and will succeed * unless e.g. execution is being terminated. / V8_WARN_UNUSED_RESULT MaybeLocal<String> ToDetailString( Local<Context> context) const; /* * Perform the equivalent of `Tagged<Object>(value)` in JS. / V8_WARN_UNUSED_RESULT MaybeLocal<Object> ToObject( Local<Context> context) const; /* * Perform the equivalent of `Number(value)` in JS and convert the result * to an integer. Negative values are rounded up, positive values are rounded * down. NaN is converted to 0. Infinite values yield undefined results. / V8_WARN_UNUSED_RESULT MaybeLocal<Integer> ToInteger( Local<Context> context) const; /* * Perform the equivalent of `Number(value)` in JS and convert the result * to an unsigned 32-bit integer by performing the steps in * https://tc39.es/ecma262/#sec-touint32. / V8_WARN_UNUSED_RESULT MaybeLocal<Uint32> ToUint32( Local<Context> context) const; /* * Perform the equivalent of `Number(value)` in JS and convert the result * to a signed 32-bit integer by performing the steps in * https://tc39.es/ecma262/#sec-toint32. / V8_WARN_UNUSED_RESULT MaybeLocal<Int32> ToInt32(Local<Context> context) const; /* * Perform the equivalent of `Boolean(value)` in JS. This can never fail. / Local<Boolean> ToBoolean(Isolate isolate) const; /** * Attempts to convert a string to an array index. * Returns an empty handle if the conversion fails. / V8_WARN_UNUSED_RESULT MaybeLocal<Uint32> ToArrayIndex( Local<Context> context) const; /* Returns the equivalent of `ToBoolean()->Value()`. / bool BooleanValue(Isolate isolate) const; /** Returns the equivalent of `ToNumber()->Value()`. / V8_WARN_UNUSED_RESULT Maybe<double> NumberValue(Local<Context> context) const; /* Returns the equivalent of `ToInteger()->Value()`. / V8_WARN_UNUSED_RESULT Maybe<int64_t> IntegerValue( Local<Context> context) const; /* Returns the equivalent of `ToUint32()->Value()`. / V8_WARN_UNUSED_RESULT Maybe<uint32_t> Uint32Value( Local<Context> context) const; /* Returns the equivalent of `ToInt32()->Value()`. / V8_WARN_UNUSED_RESULT Maybe<int32_t> Int32Value(Local<Context> context) const; /* JS == / V8_WARN_UNUSED_RESULT Maybe<bool> Equals(Local<Context> context, Local<Value> that) const; bool StrictEquals(Local<Value> that) const; bool SameValue(Local<Value> that) const; template <class T> V8_INLINE static Value Cast(T* value) { return static_cast<Value>(value); } Local<String> TypeOf(Isolate); Maybe<bool> InstanceOf(Local<Context> context, Local<Object> object); private: V8_INLINE bool QuickIsUndefined() const; V8_INLINE bool QuickIsNull() const; V8_INLINE bool QuickIsNullOrUndefined() const; #if V8_STATIC_ROOTS_BOOL V8_INLINE bool QuickIsTrue() const; V8_INLINE bool QuickIsFalse() const; #endif // V8_STATIC_ROOTS_BOOL V8_INLINE bool QuickIsString() const; bool FullIsUndefined() const; bool FullIsNull() const; bool FullIsTrue() const; bool FullIsFalse() const; bool FullIsString() const; static void CheckCast(Data* that); }; /** * Can be used to avoid repeated expensive type checks for groups of objects * that are expected to be similar (e.g. when Blink converts a bunch of * JavaScript objects to "ScriptWrappable" after a "HasInstance" check) by * making use of V8-internal "hidden classes". An object that has passed the * full check can be remembered via {Update}; further objects can be queried * using {Matches}. * Note that the answer will be conservative/"best-effort": when {Matches} * returns true, then the {candidate} can be relied upon to have the same * shape/constructor/prototype/etc. as the {baseline}. Otherwise, no reliable * statement can be made (the objects might still have indistinguishable shapes * for all intents and purposes, but this mechanism, being optimized for speed, * couldn't determine that quickly). / class V8_EXPORT TypecheckWitness { public: explicit TypecheckWitness(Isolate isolate); /** * Checks whether {candidate} can cheaply be identified as being "similar" * to the {baseline} that was passed to {Update} earlier. * It's safe to call this on an uninitialized {TypecheckWitness} instance: * it will then return {false} for any input. / V8_INLINE bool Matches(Local<Value> candidate) const; /* * Remembers a new baseline for future {Matches} queries. / void Update(Local<Value> baseline); private: Local<Data> cached_map_; }; template <> V8_INLINE Value Value::Cast(Data* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<Value>(value); } bool Value::IsUndefined() const { #ifdef V8_ENABLE_CHECKS return FullIsUndefined(); #else return QuickIsUndefined(); #endif } bool Value::QuickIsUndefined() const { using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); #if V8_STATIC_ROOTS_BOOL return I::is_identical(obj, I::StaticReadOnlyRoot::kUndefinedValue); #else if (!I::HasHeapObjectTag(obj)) return false; if (I::GetInstanceType(obj) != I::kOddballType) return false; return (I::GetOddballKind(obj) == I::kUndefinedOddballKind); #endif // V8_STATIC_ROOTS_BOOL } bool Value::IsNull() const { #ifdef V8_ENABLE_CHECKS return FullIsNull(); #else return QuickIsNull(); #endif } bool Value::QuickIsNull() const { using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); #if V8_STATIC_ROOTS_BOOL return I::is_identical(obj, I::StaticReadOnlyRoot::kNullValue); #else if (!I::HasHeapObjectTag(obj)) return false; if (I::GetInstanceType(obj) != I::kOddballType) return false; return (I::GetOddballKind(obj) == I::kNullOddballKind); #endif // V8_STATIC_ROOTS_BOOL } bool Value::IsNullOrUndefined() const { #ifdef V8_ENABLE_CHECKS return FullIsNull() \|\| FullIsUndefined(); #else return QuickIsNullOrUndefined(); #endif } bool Value::QuickIsNullOrUndefined() const { #if V8_STATIC_ROOTS_BOOL return QuickIsNull() \|\| QuickIsUndefined(); #else using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); if (!I::HasHeapObjectTag(obj)) return false; if (I::GetInstanceType(obj) != I::kOddballType) return false; int kind = I::GetOddballKind(obj); return kind == I::kNullOddballKind \|\| kind == I::kUndefinedOddballKind; #endif // V8_STATIC_ROOTS_BOOL } bool Value::IsTrue() const { #if V8_STATIC_ROOTS_BOOL && !defined(V8_ENABLE_CHECKS) return QuickIsTrue(); #else return FullIsTrue(); #endif } #if V8_STATIC_ROOTS_BOOL bool Value::QuickIsTrue() const { using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); return I::is_identical(obj, I::StaticReadOnlyRoot::kTrueValue); } #endif // V8_STATIC_ROOTS_BOOL bool Value::IsFalse() const { #if V8_STATIC_ROOTS_BOOL && !defined(V8_ENABLE_CHECKS) return QuickIsFalse(); #else return FullIsFalse(); #endif } #if V8_STATIC_ROOTS_BOOL bool Value::QuickIsFalse() const { using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); return I::is_identical(obj, I::StaticReadOnlyRoot::kFalseValue); } #endif // V8_STATIC_ROOTS_BOOL bool Value::IsString() const { #ifdef V8_ENABLE_CHECKS return FullIsString(); #else return QuickIsString(); #endif } bool Value::QuickIsString() const { using A = internal::Address; using I = internal::Internals; A obj = internal::ValueHelper::ValueAsAddress(this); if (!I::HasHeapObjectTag(obj)) return false; #if V8_STATIC_ROOTS_BOOL && !V8_MAP_PACKING return I::CheckInstanceMapRange(obj, I::StaticReadOnlyRoot::kFirstStringMap, I::StaticReadOnlyRoot::kLastStringMap); #else return (I::GetInstanceType(obj) < I::kFirstNonstringType); #endif // V8_STATIC_ROOTS_BOOL } bool TypecheckWitness::Matches(Local<Value> candidate) const { internal::Address obj = internal::ValueHelper::ValueAsAddress(candidate); internal::Address obj_map = internal::Internals::LoadMap(obj); internal::Address cached = internal::ValueHelper::ValueAsAddress(*cached_map_); return obj_map == cached; } } // namespace v8 #endif // INCLUDE_V8_VALUE_H_	16.71 KB	2025-03-03 12:36
📄 v8-version.h // Copyright 2015 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. #ifndef V8_INCLUDE_VERSION_H_ // V8_VERSION_H_ conflicts with src/version.h #define V8_INCLUDE_VERSION_H_ // These macros define the version number for the current version. // NOTE these macros are used by some of the tool scripts and the build // system so their names cannot be changed without changing the scripts. #define V8_MAJOR_VERSION 12 #define V8_MINOR_VERSION 4 #define V8_BUILD_NUMBER 254 #define V8_PATCH_LEVEL 21 // Use 1 for candidates and 0 otherwise. // (Boolean macro values are not supported by all preprocessors.) #define V8_IS_CANDIDATE_VERSION 0 #endif // V8_INCLUDE_VERSION_H_	773 B	2025-03-03 12:36
📄 v8-wasm.h // Copyright 2021 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. #ifndef INCLUDE_V8_WASM_H_ #define INCLUDE_V8_WASM_H_ #include <functional> #include <memory> #include <string> #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-memory-span.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class ArrayBuffer; class Promise; namespace internal { namespace wasm { class NativeModule; class StreamingDecoder; } // namespace wasm } // namespace internal /** * An owned byte buffer with associated size. / struct OwnedBuffer { std::unique_ptr<const uint8_t[]> buffer; size_t size = 0; OwnedBuffer(std::unique_ptr<const uint8_t[]> buffer, size_t size) : buffer(std::move(buffer)), size(size) {} OwnedBuffer() = default; }; // Wrapper around a compiled WebAssembly module, which is potentially shared by // different WasmModuleObjects. class V8_EXPORT CompiledWasmModule { public: /* * Serialize the compiled module. The serialized data does not include the * wire bytes. / OwnedBuffer Serialize(); /* * Get the (wasm-encoded) wire bytes that were used to compile this module. / MemorySpan<const uint8_t> GetWireBytesRef(); const std::string& source_url() const { return source_url_; } private: friend class WasmModuleObject; friend class WasmStreaming; explicit CompiledWasmModule(std::shared_ptr<internal::wasm::NativeModule>, const char source_url, size_t url_length); const std::shared_ptr<internal::wasm::NativeModule> native_module_; const std::string source_url_; }; // An instance of WebAssembly.Memory. class V8_EXPORT WasmMemoryObject : public Object { public: WasmMemoryObject() = delete; /** * Returns underlying ArrayBuffer. / Local<ArrayBuffer> Buffer(); V8_INLINE static WasmMemoryObject Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<WasmMemoryObject>(value); } private: static void CheckCast(Value object); }; // An instance of WebAssembly.Module. class V8_EXPORT WasmModuleObject : public Object { public: WasmModuleObject() = delete; /** * Efficiently re-create a WasmModuleObject, without recompiling, from * a CompiledWasmModule. / static MaybeLocal<WasmModuleObject> FromCompiledModule( Isolate isolate, const CompiledWasmModule&); /** * Get the compiled module for this module object. The compiled module can be * shared by several module objects. / CompiledWasmModule GetCompiledModule(); /* * Compile a Wasm module from the provided uncompiled bytes. / static MaybeLocal<WasmModuleObject> Compile( Isolate isolate, MemorySpan<const uint8_t> wire_bytes); V8_INLINE static WasmModuleObject* Cast(Value* value) { #ifdef V8_ENABLE_CHECKS CheckCast(value); #endif return static_cast<WasmModuleObject>(value); } private: static void CheckCast(Value obj); }; /** * The V8 interface for WebAssembly streaming compilation. When streaming * compilation is initiated, V8 passes a {WasmStreaming} object to the embedder * such that the embedder can pass the input bytes for streaming compilation to * V8. / class V8_EXPORT WasmStreaming final { public: class WasmStreamingImpl; explicit WasmStreaming(std::unique_ptr<WasmStreamingImpl> impl); ~WasmStreaming(); /* * Pass a new chunk of bytes to WebAssembly streaming compilation. * The buffer passed into {OnBytesReceived} is owned by the caller. / void OnBytesReceived(const uint8_t bytes, size_t size); /** * {Finish} should be called after all received bytes where passed to * {OnBytesReceived} to tell V8 that there will be no more bytes. {Finish} * must not be called after {Abort} has been called already. * If {can_use_compiled_module} is true and {SetCompiledModuleBytes} was * previously called, the compiled module bytes can be used. * If {can_use_compiled_module} is false, the compiled module bytes previously * set by {SetCompiledModuleBytes} should not be used. / void Finish(bool can_use_compiled_module = true); /* * Abort streaming compilation. If {exception} has a value, then the promise * associated with streaming compilation is rejected with that value. If * {exception} does not have value, the promise does not get rejected. * {Abort} must not be called repeatedly, or after {Finish}. / void Abort(MaybeLocal<Value> exception); /* * Passes previously compiled module bytes. This must be called before * {OnBytesReceived}, {Finish}, or {Abort}. Returns true if the module bytes * can be used, false otherwise. The buffer passed via {bytes} and {size} * is owned by the caller. If {SetCompiledModuleBytes} returns true, the * buffer must remain valid until either {Finish} or {Abort} completes. * The compiled module bytes should not be used until {Finish(true)} is * called, because they can be invalidated later by {Finish(false)}. / bool SetCompiledModuleBytes(const uint8_t bytes, size_t size); /** * Sets a callback which is called whenever a significant number of new * functions are ready for serialization. / void SetMoreFunctionsCanBeSerializedCallback( std::function<void(CompiledWasmModule)>); / * Sets the UTF-8 encoded source URL for the {Script} object. This must be * called before {Finish}. / void SetUrl(const char url, size_t length); /** * Unpacks a {WasmStreaming} object wrapped in a {Managed} for the embedder. * Since the embedder is on the other side of the API, it cannot unpack the * {Managed} itself. / static std::shared_ptr<WasmStreaming> Unpack(Isolate isolate, Local<Value> value); private: std::unique_ptr<WasmStreamingImpl> impl_; }; } // namespace v8 #endif // INCLUDE_V8_WASM_H_	6 KB	2025-03-03 12:36
📄 v8-weak-callback-info.h // Copyright 2021 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. #ifndef INCLUDE_V8_WEAK_CALLBACK_INFO_H_ #define INCLUDE_V8_WEAK_CALLBACK_INFO_H_ #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { class Isolate; namespace api_internal { V8_EXPORT void InternalFieldOutOfBounds(int index); } // namespace api_internal static const int kInternalFieldsInWeakCallback = 2; static const int kEmbedderFieldsInWeakCallback = 2; template <typename T> class WeakCallbackInfo { public: using Callback = void ()(const WeakCallbackInfo<T>& data); WeakCallbackInfo(Isolate isolate, T* parameter, void* embedder_fields[kEmbedderFieldsInWeakCallback], Callback* callback) : isolate_(isolate), parameter_(parameter), callback_(callback) { for (int i = 0; i < kEmbedderFieldsInWeakCallback; ++i) { embedder_fields_[i] = embedder_fields[i]; } } V8_INLINE Isolate* GetIsolate() const { return isolate_; } V8_INLINE T* GetParameter() const { return parameter_; } V8_INLINE void* GetInternalField(int index) const; // When first called, the embedder MUST Reset() the Global which triggered the // callback. The Global itself is unusable for anything else. No v8 other api // calls may be called in the first callback. Should additional work be // required, the embedder must set a second pass callback, which will be // called after all the initial callbacks are processed. // Calling SetSecondPassCallback on the second pass will immediately crash. void SetSecondPassCallback(Callback callback) const { callback_ = callback; } private: Isolate isolate_; T* parameter_; Callback* callback_; void* embedder_fields_[kEmbedderFieldsInWeakCallback]; }; /** * Weakness type for weak handles. / enum class WeakCallbackType { /* * Passes a user-defined void* parameter back to the callback. / kParameter, /* * Passes the first two internal fields of the object back to the callback. / kInternalFields, }; template <class T> void WeakCallbackInfo<T>::GetInternalField(int index) const { #ifdef V8_ENABLE_CHECKS if (index < 0 \|\| index >= kEmbedderFieldsInWeakCallback) { api_internal::InternalFieldOutOfBounds(index); } #endif return embedder_fields_[index]; } } // namespace v8 #endif // INCLUDE_V8_WEAK_CALLBACK_INFO_H_	2.41 KB	2025-03-03 12:36
📄 v8.h // Copyright 2012 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. /** \mainpage V8 API Reference Guide * * V8 is Google's open source JavaScript engine. * * This set of documents provides reference material generated from the * V8 header files in the include/ subdirectory. * * For other documentation see https://v8.dev/. / #ifndef INCLUDE_V8_H_ #define INCLUDE_V8_H_ #include <stddef.h> #include <stdint.h> #include <memory> #include "cppgc/common.h" #include "v8-array-buffer.h" // NOLINT(build/include_directory) #include "v8-container.h" // NOLINT(build/include_directory) #include "v8-context.h" // NOLINT(build/include_directory) #include "v8-data.h" // NOLINT(build/include_directory) #include "v8-date.h" // NOLINT(build/include_directory) #include "v8-debug.h" // NOLINT(build/include_directory) #include "v8-exception.h" // NOLINT(build/include_directory) #include "v8-extension.h" // NOLINT(build/include_directory) #include "v8-external.h" // NOLINT(build/include_directory) #include "v8-function.h" // NOLINT(build/include_directory) #include "v8-initialization.h" // NOLINT(build/include_directory) #include "v8-internal.h" // NOLINT(build/include_directory) #include "v8-isolate.h" // NOLINT(build/include_directory) #include "v8-json.h" // NOLINT(build/include_directory) #include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-locker.h" // NOLINT(build/include_directory) #include "v8-maybe.h" // NOLINT(build/include_directory) #include "v8-memory-span.h" // NOLINT(build/include_directory) #include "v8-message.h" // NOLINT(build/include_directory) #include "v8-microtask-queue.h" // NOLINT(build/include_directory) #include "v8-microtask.h" // NOLINT(build/include_directory) #include "v8-object.h" // NOLINT(build/include_directory) #include "v8-persistent-handle.h" // NOLINT(build/include_directory) #include "v8-primitive-object.h" // NOLINT(build/include_directory) #include "v8-primitive.h" // NOLINT(build/include_directory) #include "v8-promise.h" // NOLINT(build/include_directory) #include "v8-proxy.h" // NOLINT(build/include_directory) #include "v8-regexp.h" // NOLINT(build/include_directory) #include "v8-script.h" // NOLINT(build/include_directory) #include "v8-snapshot.h" // NOLINT(build/include_directory) #include "v8-statistics.h" // NOLINT(build/include_directory) #include "v8-template.h" // NOLINT(build/include_directory) #include "v8-traced-handle.h" // NOLINT(build/include_directory) #include "v8-typed-array.h" // NOLINT(build/include_directory) #include "v8-unwinder.h" // NOLINT(build/include_directory) #include "v8-value-serializer.h" // NOLINT(build/include_directory) #include "v8-value.h" // NOLINT(build/include_directory) #include "v8-version.h" // NOLINT(build/include_directory) #include "v8-wasm.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) // We reserve the V8_ prefix for macros defined in V8 public API and // assume there are no name conflicts with the embedder's code. /** * The v8 JavaScript engine. / namespace v8 { class Platform; /* * \example shell.cc * A simple shell that takes a list of expressions on the * command-line and executes them. / /* * \example process.cc */ } // namespace v8 #endif // INCLUDE_V8_H_	3.69 KB	2025-03-03 12:36
📄 v8config.h // Copyright 2013 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. #ifndef V8CONFIG_H_ #define V8CONFIG_H_ #ifdef V8_GN_HEADER #if __cplusplus >= 201703L && !__has_include("v8-gn.h") #error Missing v8-gn.h. The configuration for v8 is missing from the include \ path. Add it with -I<path> to the command line #endif #include "v8-gn.h" // NOLINT(build/include_directory) #endif #include <memory> // clang-format off // Platform headers for feature detection below. #if defined(__ANDROID__) # include <sys/cdefs.h> #elif defined(__APPLE__) # include <TargetConditionals.h> #elif defined(__linux__) # include <features.h> #endif // This macro allows to test for the version of the GNU C library (or // a compatible C library that masquerades as glibc). It evaluates to // 0 if libc is not GNU libc or compatible. // Use like: // #if V8_GLIBC_PREREQ(2, 3) // ... // #endif #if defined(__GLIBC__) && defined(__GLIBC_MINOR__) # define V8_GLIBC_PREREQ(major, minor) \ ((__GLIBC__ * 100 + __GLIBC_MINOR__) >= ((major) * 100 + (minor))) #else # define V8_GLIBC_PREREQ(major, minor) 0 #endif // This macro allows to test for the version of the GNU C++ compiler. // Note that this also applies to compilers that masquerade as GCC, // for example clang and the Intel C++ compiler for Linux. // Use like: // #if V8_GNUC_PREREQ(4, 3, 1) // ... // #endif #if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) # define V8_GNUC_PREREQ(major, minor, patchlevel) \ ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= \ ((major) * 10000 + (minor) * 100 + (patchlevel))) #elif defined(__GNUC__) && defined(__GNUC_MINOR__) # define V8_GNUC_PREREQ(major, minor, patchlevel) \ ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100) >= \ ((major) * 10000 + (minor) * 100 + (patchlevel))) #else # define V8_GNUC_PREREQ(major, minor, patchlevel) 0 #endif // ----------------------------------------------------------------------------- // Operating system detection (host) // // V8_OS_ANDROID - Android // V8_OS_BSD - BSDish (macOS, Net/Free/Open/DragonFlyBSD) // V8_OS_CYGWIN - Cygwin // V8_OS_DRAGONFLYBSD - DragonFlyBSD // V8_OS_FREEBSD - FreeBSD // V8_OS_FUCHSIA - Fuchsia // V8_OS_LINUX - Linux (Android, ChromeOS, Linux, ...) // V8_OS_DARWIN - Darwin (macOS, iOS) // V8_OS_MACOS - macOS // V8_OS_IOS - iOS // V8_OS_NETBSD - NetBSD // V8_OS_OPENBSD - OpenBSD // V8_OS_POSIX - POSIX compatible (mostly everything except Windows) // V8_OS_QNX - QNX Neutrino // V8_OS_SOLARIS - Sun Solaris and OpenSolaris // V8_OS_STARBOARD - Starboard (platform abstraction for Cobalt) // V8_OS_AIX - AIX // V8_OS_WIN - Microsoft Windows #if defined(__ANDROID__) # define V8_OS_ANDROID 1 # define V8_OS_LINUX 1 # define V8_OS_POSIX 1 # define V8_OS_STRING "android" #elif defined(__APPLE__) # define V8_OS_POSIX 1 # define V8_OS_BSD 1 # define V8_OS_DARWIN 1 # if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE # define V8_OS_IOS 1 # define V8_OS_STRING "ios" # else # define V8_OS_MACOS 1 # define V8_OS_STRING "macos" # endif // defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE #elif defined(__CYGWIN__) # define V8_OS_CYGWIN 1 # define V8_OS_POSIX 1 # define V8_OS_STRING "cygwin" #elif defined(__linux__) # define V8_OS_LINUX 1 # define V8_OS_POSIX 1 # define V8_OS_STRING "linux" #elif defined(__sun) # define V8_OS_POSIX 1 # define V8_OS_SOLARIS 1 # define V8_OS_STRING "sun" #elif defined(STARBOARD) # define V8_OS_STARBOARD 1 # define V8_OS_STRING "starboard" #elif defined(_AIX) # define V8_OS_POSIX 1 # define V8_OS_AIX 1 # define V8_OS_STRING "aix" #elif defined(__FreeBSD__) # define V8_OS_BSD 1 # define V8_OS_FREEBSD 1 # define V8_OS_POSIX 1 # define V8_OS_STRING "freebsd" #elif defined(__Fuchsia__) # define V8_OS_FUCHSIA 1 # define V8_OS_POSIX 1 # define V8_OS_STRING "fuchsia" #elif defined(__DragonFly__) # define V8_OS_BSD 1 # define V8_OS_DRAGONFLYBSD 1 # define V8_OS_POSIX 1 # define V8_OS_STRING "dragonflybsd" #elif defined(__NetBSD__) # define V8_OS_BSD 1 # define V8_OS_NETBSD 1 # define V8_OS_POSIX 1 # define V8_OS_STRING "netbsd" #elif defined(__OpenBSD__) # define V8_OS_BSD 1 # define V8_OS_OPENBSD 1 # define V8_OS_POSIX 1 # define V8_OS_STRING "openbsd" #elif defined(__QNXNTO__) # define V8_OS_POSIX 1 # define V8_OS_QNX 1 # define V8_OS_STRING "qnx" #elif defined(_WIN32) # define V8_OS_WIN 1 # define V8_OS_STRING "windows" #endif // ----------------------------------------------------------------------------- // Operating system detection (target) // // V8_TARGET_OS_ANDROID // V8_TARGET_OS_FUCHSIA // V8_TARGET_OS_IOS // V8_TARGET_OS_LINUX // V8_TARGET_OS_MACOS // V8_TARGET_OS_WIN // V8_TARGET_OS_CHROMEOS // // If not set explicitly, these fall back to corresponding V8_OS_ values. #ifdef V8_HAVE_TARGET_OS // The target OS is provided, just check that at least one known value is set. # if !defined(V8_TARGET_OS_ANDROID) \ && !defined(V8_TARGET_OS_FUCHSIA) \ && !defined(V8_TARGET_OS_IOS) \ && !defined(V8_TARGET_OS_LINUX) \ && !defined(V8_TARGET_OS_MACOS) \ && !defined(V8_TARGET_OS_WIN) \ && !defined(V8_TARGET_OS_CHROMEOS) # error No known target OS defined. # endif #else // V8_HAVE_TARGET_OS # if defined(V8_TARGET_OS_ANDROID) \ \|\| defined(V8_TARGET_OS_FUCHSIA) \ \|\| defined(V8_TARGET_OS_IOS) \ \|\| defined(V8_TARGET_OS_LINUX) \ \|\| defined(V8_TARGET_OS_MACOS) \ \|\| defined(V8_TARGET_OS_WIN) \ \|\| defined(V8_TARGET_OS_CHROMEOS) # error A target OS is defined but V8_HAVE_TARGET_OS is unset. # endif // Fall back to the detected host OS. #ifdef V8_OS_ANDROID # define V8_TARGET_OS_ANDROID #endif #ifdef V8_OS_FUCHSIA # define V8_TARGET_OS_FUCHSIA #endif #ifdef V8_OS_IOS # define V8_TARGET_OS_IOS #endif #ifdef V8_OS_LINUX # define V8_TARGET_OS_LINUX #endif #ifdef V8_OS_MACOS # define V8_TARGET_OS_MACOS #endif #ifdef V8_OS_WIN # define V8_TARGET_OS_WIN #endif #endif // V8_HAVE_TARGET_OS #if defined(V8_TARGET_OS_ANDROID) # define V8_TARGET_OS_STRING "android" #elif defined(V8_TARGET_OS_FUCHSIA) # define V8_TARGET_OS_STRING "fuchsia" #elif defined(V8_TARGET_OS_IOS) # define V8_TARGET_OS_STRING "ios" #elif defined(V8_TARGET_OS_LINUX) # define V8_TARGET_OS_STRING "linux" #elif defined(V8_TARGET_OS_MACOS) # define V8_TARGET_OS_STRING "macos" #elif defined(V8_TARGET_OS_WINDOWS) # define V8_TARGET_OS_STRING "windows" #else # define V8_TARGET_OS_STRING "unknown" #endif // ----------------------------------------------------------------------------- // C library detection // // V8_LIBC_MSVCRT - MSVC libc // V8_LIBC_BIONIC - Bionic libc // V8_LIBC_BSD - BSD libc derivate // V8_LIBC_GLIBC - GNU C library // V8_LIBC_UCLIBC - uClibc // // Note that testing for libc must be done using #if not #ifdef. For example, // to test for the GNU C library, use: // #if V8_LIBC_GLIBC // ... // #endif #if defined (_MSC_VER) # define V8_LIBC_MSVCRT 1 #elif defined(__BIONIC__) # define V8_LIBC_BIONIC 1 # define V8_LIBC_BSD 1 #elif defined(__UCLIBC__) // Must test for UCLIBC before GLIBC, as UCLIBC pretends to be GLIBC. # define V8_LIBC_UCLIBC 1 #elif defined(__GLIBC__) \|\| defined(__GNU_LIBRARY__) # define V8_LIBC_GLIBC 1 #else # define V8_LIBC_BSD V8_OS_BSD #endif // ----------------------------------------------------------------------------- // Compiler detection // // V8_CC_GNU - GCC, or clang in gcc mode // V8_CC_INTEL - Intel C++ // V8_CC_MINGW - Minimalist GNU for Windows // V8_CC_MINGW32 - Minimalist GNU for Windows (mingw32) // V8_CC_MINGW64 - Minimalist GNU for Windows (mingw-w64) // V8_CC_MSVC - Microsoft Visual C/C++, or clang in cl.exe mode // // C++11 feature detection // // Compiler-specific feature detection // // V8_HAS_ATTRIBUTE_ALWAYS_INLINE - __attribute__((always_inline)) // supported // V8_HAS_ATTRIBUTE_CONSTINIT - __attribute__((require_constant_ // initialization)) // supported // V8_HAS_ATTRIBUTE_NONNULL - __attribute__((nonnull)) supported // V8_HAS_ATTRIBUTE_NOINLINE - __attribute__((noinline)) supported // V8_HAS_ATTRIBUTE_UNUSED - __attribute__((unused)) supported // V8_HAS_ATTRIBUTE_USED - __attribute__((used)) supported // V8_HAS_ATTRIBUTE_RETAIN - __attribute__((retain)) supported // V8_HAS_ATTRIBUTE_VISIBILITY - __attribute__((visibility)) supported // V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT - __attribute__((warn_unused_result)) // supported // V8_HAS_CPP_ATTRIBUTE_NODISCARD - [[nodiscard]] supported // V8_HAS_CPP_ATTRIBUTE_NO_UNIQUE_ADDRESS // - [[no_unique_address]] supported // V8_HAS_BUILTIN_ADD_OVERFLOW - __builtin_add_overflow() supported // V8_HAS_BUILTIN_BIT_CAST - __builtin_bit_cast() supported // V8_HAS_BUILTIN_BSWAP16 - __builtin_bswap16() supported // V8_HAS_BUILTIN_BSWAP32 - __builtin_bswap32() supported // V8_HAS_BUILTIN_BSWAP64 - __builtin_bswap64() supported // V8_HAS_BUILTIN_CLZ - __builtin_clz() supported // V8_HAS_BUILTIN_CTZ - __builtin_ctz() supported // V8_HAS_BUILTIN_EXPECT - __builtin_expect() supported // V8_HAS_BUILTIN_FRAME_ADDRESS - __builtin_frame_address() supported // V8_HAS_BUILTIN_MUL_OVERFLOW - __builtin_mul_overflow() supported // V8_HAS_BUILTIN_POPCOUNT - __builtin_popcount() supported // V8_HAS_BUILTIN_SADD_OVERFLOW - __builtin_sadd_overflow() supported // V8_HAS_BUILTIN_SMUL_OVERFLOW - __builtin_smul_overflow() supported // V8_HAS_BUILTIN_SSUB_OVERFLOW - __builtin_ssub_overflow() supported // V8_HAS_BUILTIN_SUB_OVERFLOW - __builtin_sub_overflow() supported // V8_HAS_BUILTIN_UADD_OVERFLOW - __builtin_uadd_overflow() supported // V8_HAS_COMPUTED_GOTO - computed goto/labels as values // supported // V8_HAS_DECLSPEC_NOINLINE - __declspec(noinline) supported // V8_HAS_DECLSPEC_SELECTANY - __declspec(selectany) supported // V8_HAS___FORCEINLINE - __forceinline supported // // Note that testing for compilers and/or features must be done using #if // not #ifdef. For example, to test for Intel C++ Compiler, use: // #if V8_CC_INTEL // ... // #endif #if defined(__has_cpp_attribute) #define V8_HAS_CPP_ATTRIBUTE(FEATURE) __has_cpp_attribute(FEATURE) #else #define V8_HAS_CPP_ATTRIBUTE(FEATURE) 0 #endif #if defined(__clang__) #if defined(__GNUC__) // Clang in gcc mode. # define V8_CC_GNU 1 #endif # define V8_HAS_ATTRIBUTE_ALWAYS_INLINE (__has_attribute(always_inline)) # define V8_HAS_ATTRIBUTE_CONSTINIT \ (__has_attribute(require_constant_initialization)) # define V8_HAS_ATTRIBUTE_CONST (__has_attribute(const)) # define V8_HAS_ATTRIBUTE_NONNULL (__has_attribute(nonnull)) # define V8_HAS_ATTRIBUTE_NOINLINE (__has_attribute(noinline)) # define V8_HAS_ATTRIBUTE_UNUSED (__has_attribute(unused)) # define V8_HAS_ATTRIBUTE_USED (__has_attribute(used)) # define V8_HAS_ATTRIBUTE_RETAIN (__has_attribute(retain)) // Support for the "preserve_most" attribute is limited: // - 32-bit platforms do not implement it, // - component builds fail because _dl_runtime_resolve clobbers registers, // - we see crashes on arm64 on Windows (https://crbug.com/1409934), which can // hopefully be fixed in the future. // Additionally, the initial implementation in clang <= 16 overwrote the return // register(s) in the epilogue of a preserve_most function, so we only use // preserve_most in clang >= 17 (see https://reviews.llvm.org/D143425). #if (defined(_M_X64) \|\| defined(__x86_64__) /* x64 (everywhere) / \ \|\| ((defined(__AARCH64EL__) \|\| defined(_M_ARM64)) / arm64, but ... / \ && !defined(_WIN32))) / not on windows / \ && !defined(COMPONENT_BUILD) / no component build /\ && __clang_major__ >= 17 / clang >= 17 / # define V8_HAS_ATTRIBUTE_PRESERVE_MOST (__has_attribute(preserve_most)) #endif # define V8_HAS_ATTRIBUTE_VISIBILITY (__has_attribute(visibility)) # define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT \ (__has_attribute(warn_unused_result)) # define V8_HAS_ATTRIBUTE_WEAK (__has_attribute(weak)) # define V8_HAS_CPP_ATTRIBUTE_NODISCARD (V8_HAS_CPP_ATTRIBUTE(nodiscard)) # define V8_HAS_CPP_ATTRIBUTE_NO_UNIQUE_ADDRESS \ (V8_HAS_CPP_ATTRIBUTE(no_unique_address)) # define V8_HAS_BUILTIN_ADD_OVERFLOW (__has_builtin(__builtin_add_overflow)) # define V8_HAS_BUILTIN_ASSUME (__has_builtin(__builtin_assume)) # define V8_HAS_BUILTIN_ASSUME_ALIGNED (__has_builtin(__builtin_assume_aligned)) # define V8_HAS_BUILTIN_BIT_CAST (__has_builtin(__builtin_bit_cast)) # define V8_HAS_BUILTIN_BSWAP16 (__has_builtin(__builtin_bswap16)) # define V8_HAS_BUILTIN_BSWAP32 (__has_builtin(__builtin_bswap32)) # define V8_HAS_BUILTIN_BSWAP64 (__has_builtin(__builtin_bswap64)) # define V8_HAS_BUILTIN_CLZ (__has_builtin(__builtin_clz)) # define V8_HAS_BUILTIN_CTZ (__has_builtin(__builtin_ctz)) # define V8_HAS_BUILTIN_EXPECT (__has_builtin(__builtin_expect)) # define V8_HAS_BUILTIN_FRAME_ADDRESS (__has_builtin(__builtin_frame_address)) # define V8_HAS_BUILTIN_MUL_OVERFLOW (__has_builtin(__builtin_mul_overflow)) # define V8_HAS_BUILTIN_POPCOUNT (__has_builtin(__builtin_popcount)) # define V8_HAS_BUILTIN_SADD_OVERFLOW (__has_builtin(__builtin_sadd_overflow)) # define V8_HAS_BUILTIN_SMUL_OVERFLOW (__has_builtin(__builtin_smul_overflow)) # define V8_HAS_BUILTIN_SSUB_OVERFLOW (__has_builtin(__builtin_ssub_overflow)) # define V8_HAS_BUILTIN_SUB_OVERFLOW (__has_builtin(__builtin_sub_overflow)) # define V8_HAS_BUILTIN_UADD_OVERFLOW (__has_builtin(__builtin_uadd_overflow)) # define V8_HAS_BUILTIN_UNREACHABLE (__has_builtin(__builtin_unreachable)) // Clang has no __has_feature for computed gotos. // GCC doc: https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html # define V8_HAS_COMPUTED_GOTO 1 #elif defined(__GNUC__) # define V8_CC_GNU 1 # if defined(__INTEL_COMPILER) // Intel C++ also masquerades as GCC 3.2.0 # define V8_CC_INTEL 1 # endif # if defined(__MINGW32__) # define V8_CC_MINGW32 1 # endif # if defined(__MINGW64__) # define V8_CC_MINGW64 1 # endif # define V8_CC_MINGW (V8_CC_MINGW32 \|\| V8_CC_MINGW64) // FYI: __has_builtin is only available with GCC 10 and later, so explicitly // check GCC version numbers to enable features. TODO(leszeks): Merge feature // enabling for GCC 10 and later into the Clang section above, and leave this // section for GCC 9 and earlier. // always_inline is available in gcc 4.0 but not very reliable until 4.4. // Works around "sorry, unimplemented: inlining failed" build errors with // older compilers. # define V8_HAS_ATTRIBUTE_ALWAYS_INLINE 1 # define V8_HAS_ATTRIBUTE_NOINLINE 1 # define V8_HAS_ATTRIBUTE_UNUSED 1 # define V8_HAS_ATTRIBUTE_VISIBILITY 1 # define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT (!V8_CC_INTEL) # define V8_HAS_ATTRIBUTE_WEAK 1 // [[nodiscard]] does not work together with with // __attribute__((visibility(""))) on GCC 7.4 which is why there is no define // for V8_HAS_CPP_ATTRIBUTE_NODISCARD. See https://crbug.com/v8/11707. # define V8_HAS_BUILTIN_ASSUME_ALIGNED 1 # if __GNUC__ >= 11 # define V8_HAS_BUILTIN_BIT_CAST 1 # endif # define V8_HAS_BUILTIN_CLZ 1 # define V8_HAS_BUILTIN_CTZ 1 # define V8_HAS_BUILTIN_EXPECT 1 # define V8_HAS_BUILTIN_FRAME_ADDRESS 1 # define V8_HAS_BUILTIN_POPCOUNT 1 # define V8_HAS_BUILTIN_UNREACHABLE 1 // GCC doc: https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html #define V8_HAS_COMPUTED_GOTO 1 #endif #if defined(_MSC_VER) # define V8_CC_MSVC 1 # define V8_HAS_DECLSPEC_NOINLINE 1 # define V8_HAS_DECLSPEC_SELECTANY 1 # define V8_HAS___FORCEINLINE 1 #endif // ----------------------------------------------------------------------------- // Helper macros // A macro used to make better inlining. Don't bother for debug builds. // Use like: // V8_INLINE int GetZero() { return 0; } #if !defined(DEBUG) && V8_HAS_ATTRIBUTE_ALWAYS_INLINE # define V8_INLINE inline __attribute__((always_inline)) #elif !defined(DEBUG) && V8_HAS___FORCEINLINE # define V8_INLINE __forceinline #else # define V8_INLINE inline #endif #ifdef DEBUG // In debug mode, check assumptions instead of actually adding annotations. # define V8_ASSUME DCHECK #elif V8_HAS_BUILTIN_ASSUME # define V8_ASSUME __builtin_assume #elif V8_HAS_BUILTIN_UNREACHABLE # define V8_ASSUME(condition) \ do { \ if (!(condition)) __builtin_unreachable(); \ } while (false) #else # define V8_ASSUME USE #endif // Prefer c++20 std::assume_aligned #if __cplusplus >= 202002L && defined(__cpp_lib_assume_aligned) # define V8_ASSUME_ALIGNED(ptr, alignment) \ std::assume_aligned<(alignment)>(ptr) #elif V8_HAS_BUILTIN_ASSUME_ALIGNED # define V8_ASSUME_ALIGNED(ptr, alignment) \ __builtin_assume_aligned((ptr), (alignment)) #else # define V8_ASSUME_ALIGNED(ptr, alignment) (ptr) #endif // A macro to mark functions whose values don't change (e.g. across calls) // and thereby compiler is free to hoist and fold multiple calls together. // Use like: // V8_CONST int foo() { ... } #if V8_HAS_ATTRIBUTE_CONST # define V8_CONST __attribute__((const)) #else # define V8_CONST #endif // A macro to mark a declaration as requiring constant initialization. // Use like: // int foo V8_CONSTINIT; #if V8_HAS_ATTRIBUTE_CONSTINIT # define V8_CONSTINIT __attribute__((require_constant_initialization)) #else # define V8_CONSTINIT #endif // A macro to mark specific arguments as non-null. // Use like: // int add(int* x, int y, int* z) V8_NONNULL(1, 3) { return x + y + z; } #if V8_HAS_ATTRIBUTE_NONNULL # define V8_NONNULL(...) __attribute__((nonnull(__VA_ARGS__))) #else # define V8_NONNULL(...) /* NOT SUPPORTED / #endif // A macro used to tell the compiler to never inline a particular function. // Use like: // V8_NOINLINE int GetMinusOne() { return -1; } #if V8_HAS_ATTRIBUTE_NOINLINE # define V8_NOINLINE __attribute__((noinline)) #elif V8_HAS_DECLSPEC_NOINLINE # define V8_NOINLINE __declspec(noinline) #else # define V8_NOINLINE / NOT SUPPORTED / #endif // A macro used to change the calling conventions to preserve all registers (no // caller-saved registers). Use this for cold functions called from hot // functions. // Use like: // V8_NOINLINE V8_PRESERVE_MOST void UnlikelyMethod(); #if V8_OS_WIN # define V8_PRESERVE_MOST #else #if V8_HAS_ATTRIBUTE_PRESERVE_MOST # define V8_PRESERVE_MOST __attribute__((preserve_most)) #else # define V8_PRESERVE_MOST / NOT SUPPORTED / #endif #endif // A macro (V8_DEPRECATED) to mark classes or functions as deprecated. #if defined(V8_DEPRECATION_WARNINGS) # define V8_DEPRECATED(message) [[deprecated(message)]] #else # define V8_DEPRECATED(message) #endif // A macro (V8_DEPRECATE_SOON) to make it easier to see what will be deprecated. #if defined(V8_IMMINENT_DEPRECATION_WARNINGS) # define V8_DEPRECATE_SOON(message) [[deprecated(message)]] #else # define V8_DEPRECATE_SOON(message) #endif #if defined(V8_IMMINENT_DEPRECATION_WARNINGS) \|\| \ defined(V8_DEPRECATION_WARNINGS) #if defined(V8_CC_MSVC) # define START_ALLOW_USE_DEPRECATED() \ __pragma(warning(push)) \ __pragma(warning(disable : 4996)) # define END_ALLOW_USE_DEPRECATED() __pragma(warning(pop)) #else // !defined(V8_CC_MSVC) # define START_ALLOW_USE_DEPRECATED() \ _Pragma("GCC diagnostic push") \ _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") #define END_ALLOW_USE_DEPRECATED() _Pragma("GCC diagnostic pop") #endif // !defined(V8_CC_MSVC) #else // !(defined(V8_IMMINENT_DEPRECATION_WARNINGS) \|\| // defined(V8_DEPRECATION_WARNINGS)) #define START_ALLOW_USE_DEPRECATED() #define END_ALLOW_USE_DEPRECATED() #endif // !(defined(V8_IMMINENT_DEPRECATION_WARNINGS) \|\| // defined(V8_DEPRECATION_WARNINGS)) #define ALLOW_COPY_AND_MOVE_WITH_DEPRECATED_FIELDS(ClassName) \ START_ALLOW_USE_DEPRECATED() \ ClassName(const ClassName&) = default; \ ClassName(ClassName&&) = default; \ ClassName& operator=(const ClassName&) = default; \ ClassName& operator=(ClassName&&) = default; \ END_ALLOW_USE_DEPRECATED() #if defined(__GNUC__) && !defined(__clang__) && (__GNUC__ < 6) # define V8_ENUM_DEPRECATED(message) # define V8_ENUM_DEPRECATE_SOON(message) #else # define V8_ENUM_DEPRECATED(message) V8_DEPRECATED(message) # define V8_ENUM_DEPRECATE_SOON(message) V8_DEPRECATE_SOON(message) #endif // A macro to provide the compiler with branch prediction information. #if V8_HAS_BUILTIN_EXPECT # define V8_UNLIKELY(condition) (__builtin_expect(!!(condition), 0)) # define V8_LIKELY(condition) (__builtin_expect(!!(condition), 1)) #else # define V8_UNLIKELY(condition) (condition) # define V8_LIKELY(condition) (condition) #endif // Annotate a function indicating the caller must examine the return value. // Use like: // int foo() V8_WARN_UNUSED_RESULT; #if V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT #define V8_WARN_UNUSED_RESULT __attribute__((warn_unused_result)) #else #define V8_WARN_UNUSED_RESULT / NOT SUPPORTED / #endif // Annotate functions/variables as weak to allow overriding the symbol. #if V8_HAS_ATTRIBUTE_WEAK #define V8_WEAK __attribute__((weak)) #else #define V8_WEAK / NOT SUPPORTED / #endif // Annotate a class or constructor indicating the caller must assign the // constructed instances. // Apply to the whole class like: // class V8_NODISCARD Foo() { ... }; // or apply to just one constructor like: // V8_NODISCARD Foo() { ... }; // [[nodiscard]] comes in C++17 but supported in clang with -std >= c++11. #if V8_HAS_CPP_ATTRIBUTE_NODISCARD #define V8_NODISCARD [[nodiscard]] #else #define V8_NODISCARD / NOT SUPPORTED / #endif // The no_unique_address attribute allows tail padding in a non-static data // member to overlap other members of the enclosing class (and in the special // case when the type is empty, permits it to fully overlap other members). The // field is laid out as if a base class were encountered at the corresponding // point within the class (except that it does not share a vptr with the // enclosing object). // // Apply to a data member like: // // class Foo { // V8_NO_UNIQUE_ADDRESS Bar bar_; // }; // // [[no_unique_address]] comes in C++20 but supported in clang with // -std >= c++11. #if V8_HAS_CPP_ATTRIBUTE_NO_UNIQUE_ADDRESS #define V8_NO_UNIQUE_ADDRESS [[no_unique_address]] #else #define V8_NO_UNIQUE_ADDRESS / NOT SUPPORTED / #endif // Marks a type as being eligible for the "trivial" ABI despite having a // non-trivial destructor or copy/move constructor. Such types can be relocated // after construction by simply copying their memory, which makes them eligible // to be passed in registers. The canonical example is std::unique_ptr. // // Use with caution; this has some subtle effects on constructor/destructor // ordering and will be very incorrect if the type relies on its address // remaining constant. When used as a function argument (by value), the value // may be constructed in the caller's stack frame, passed in a register, and // then used and destructed in the callee's stack frame. A similar thing can // occur when values are returned. // // TRIVIAL_ABI is not needed for types which have a trivial destructor and // copy/move constructors, since those are automatically trivial by the ABI // spec. // // It is also not likely to be effective on types too large to be passed in one // or two registers on typical target ABIs. // // See also: // https://clang.llvm.org/docs/AttributeReference.html#trivial-abi // https://libcxx.llvm.org/docs/DesignDocs/UniquePtrTrivialAbi.html #if defined(__clang__) && defined(__has_attribute) #if __has_attribute(trivial_abi) #define V8_TRIVIAL_ABI [[clang::trivial_abi]] #define V8_HAS_ATTRIBUTE_TRIVIAL_ABI 1 #endif // __has_attribute(trivial_abi) #endif // defined(__clang__) && defined(__has_attribute) #if !defined(V8_TRIVIAL_ABI) #define V8_TRIVIAL_ABI #define V8_HAS_ATTRIBUTE_TRIVIAL_ABI 0 #endif //!defined(V8_TRIVIAL_ABI) // Helper macro to define no_sanitize attributes only with clang. #if defined(__clang__) && defined(__has_attribute) #if __has_attribute(no_sanitize) #define V8_CLANG_NO_SANITIZE(what) __attribute__((no_sanitize(what))) #endif #endif #if !defined(V8_CLANG_NO_SANITIZE) #define V8_CLANG_NO_SANITIZE(what) #endif // Exposing private symbols requires exposing public symbols too. #ifdef BUILDING_V8_SHARED_PRIVATE #define BUILDING_V8_SHARED #endif #if defined(BUILDING_V8_SHARED) && defined(USING_V8_SHARED) #error Inconsistent build configuration: To build the V8 shared library \ set BUILDING_V8_SHARED, to include its headers for linking against the \ V8 shared library set USING_V8_SHARED. #endif #ifdef V8_OS_WIN // Setup for Windows DLL export/import. When building the V8 DLL the // BUILDING_V8_SHARED needs to be defined. When building a program which uses // the V8 DLL USING_V8_SHARED needs to be defined. When either building the V8 // static library or building a program which uses the V8 static library neither // BUILDING_V8_SHARED nor USING_V8_SHARED should be defined. #ifdef BUILDING_V8_SHARED # define V8_EXPORT __declspec(dllexport) #elif USING_V8_SHARED # define V8_EXPORT __declspec(dllimport) #else # define V8_EXPORT #endif // BUILDING_V8_SHARED #else // V8_OS_WIN // Setup for Linux shared library export. #if V8_HAS_ATTRIBUTE_VISIBILITY # ifdef BUILDING_V8_SHARED # define V8_EXPORT __attribute__ ((visibility("default"))) # else # define V8_EXPORT # endif #else # define V8_EXPORT #endif #endif // V8_OS_WIN // clang-format on // Processor architecture detection. For more info on what's defined, see: // http://msdn.microsoft.com/en-us/library/b0084kay.aspx // http://www.agner.org/optimize/calling_conventions.pdf // or with gcc, run: "echo \| gcc -E -dM -" // The V8_HOST_ARCH_ macros correspond to the architecture on which V8, as a // virtual machine and compiler, runs. Don't confuse this with the architecture // on which V8 is built. #if defined(_M_X64) \|\| defined(__x86_64__) #define V8_HOST_ARCH_X64 1 #if defined(__x86_64__) && __SIZEOF_POINTER__ == 4 // Check for x32. #define V8_HOST_ARCH_32_BIT 1 #else #define V8_HOST_ARCH_64_BIT 1 #endif #elif defined(_M_IX86) \|\| defined(__i386__) #define V8_HOST_ARCH_IA32 1 #define V8_HOST_ARCH_32_BIT 1 #elif defined(__AARCH64EL__) \|\| defined(_M_ARM64) #define V8_HOST_ARCH_ARM64 1 #define V8_HOST_ARCH_64_BIT 1 #elif defined(__ARMEL__) #define V8_HOST_ARCH_ARM 1 #define V8_HOST_ARCH_32_BIT 1 #elif defined(__mips64) #define V8_HOST_ARCH_MIPS64 1 #define V8_HOST_ARCH_64_BIT 1 #elif defined(__loongarch_lp64) #define V8_HOST_ARCH_LOONG64 1 #define V8_HOST_ARCH_64_BIT 1 #elif defined(__PPC64__) \|\| defined(_ARCH_PPC64) #define V8_HOST_ARCH_PPC64 1 #define V8_HOST_ARCH_64_BIT 1 #elif defined(__PPC__) \|\| defined(_ARCH_PPC) #define V8_HOST_ARCH_PPC 1 #define V8_HOST_ARCH_32_BIT 1 #elif defined(__s390__) \|\| defined(__s390x__) #define V8_HOST_ARCH_S390 1 #if defined(__s390x__) #define V8_HOST_ARCH_64_BIT 1 #else #define V8_HOST_ARCH_32_BIT 1 #endif #elif defined(__riscv) \|\| defined(__riscv__) #if __riscv_xlen == 64 #define V8_HOST_ARCH_RISCV64 1 #define V8_HOST_ARCH_64_BIT 1 #elif __riscv_xlen == 32 #define V8_HOST_ARCH_RISCV32 1 #define V8_HOST_ARCH_32_BIT 1 #else #error "Cannot detect Riscv's bitwidth" #endif #else #error "Host architecture was not detected as supported by v8" #endif // Target architecture detection. This corresponds to the architecture for which // V8's JIT will generate code (the last stage of the canadian cross-compiler). // The macros may be set externally. If not, detect in the same way as the host // architecture, that is, target the native environment as presented by the // compiler. #if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_IA32 && !V8_TARGET_ARCH_ARM && \ !V8_TARGET_ARCH_ARM64 && !V8_TARGET_ARCH_MIPS64 && !V8_TARGET_ARCH_PPC && \ !V8_TARGET_ARCH_PPC64 && !V8_TARGET_ARCH_S390 && \ !V8_TARGET_ARCH_RISCV64 && !V8_TARGET_ARCH_LOONG64 && \ !V8_TARGET_ARCH_RISCV32 #if defined(_M_X64) \|\| defined(__x86_64__) #define V8_TARGET_ARCH_X64 1 #elif defined(_M_IX86) \|\| defined(__i386__) #define V8_TARGET_ARCH_IA32 1 #elif defined(__AARCH64EL__) \|\| defined(_M_ARM64) #define V8_TARGET_ARCH_ARM64 1 #elif defined(__ARMEL__) #define V8_TARGET_ARCH_ARM 1 #elif defined(__mips64) #define V8_TARGET_ARCH_MIPS64 1 #elif defined(__loongarch_lp64) #define V8_TARGET_ARCH_LOONG64 1 #elif defined(_ARCH_PPC64) #define V8_TARGET_ARCH_PPC64 1 #elif defined(_ARCH_PPC) #define V8_TARGET_ARCH_PPC 1 #elif defined(__s390__) #define V8_TARGET_ARCH_S390 1 #if defined(__s390x__) #define V8_TARGET_ARCH_S390X 1 #endif #elif defined(__riscv) \|\| defined(__riscv__) #if __riscv_xlen == 64 #define V8_TARGET_ARCH_RISCV64 1 #elif __riscv_xlen == 32 #define V8_TARGET_ARCH_RISCV32 1 #endif #else #error Target architecture was not detected as supported by v8 #endif #endif // Determine architecture pointer size. #if V8_TARGET_ARCH_IA32 #define V8_TARGET_ARCH_32_BIT 1 #elif V8_TARGET_ARCH_X64 #if !V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_64_BIT #if defined(__x86_64__) && __SIZEOF_POINTER__ == 4 // Check for x32. #define V8_TARGET_ARCH_32_BIT 1 #else #define V8_TARGET_ARCH_64_BIT 1 #endif #endif #elif V8_TARGET_ARCH_ARM #define V8_TARGET_ARCH_32_BIT 1 #elif V8_TARGET_ARCH_ARM64 #define V8_TARGET_ARCH_64_BIT 1 #elif V8_TARGET_ARCH_MIPS #define V8_TARGET_ARCH_32_BIT 1 #elif V8_TARGET_ARCH_MIPS64 #define V8_TARGET_ARCH_64_BIT 1 #elif V8_TARGET_ARCH_LOONG64 #define V8_TARGET_ARCH_64_BIT 1 #elif V8_TARGET_ARCH_PPC #define V8_TARGET_ARCH_32_BIT 1 #elif V8_TARGET_ARCH_PPC64 #define V8_TARGET_ARCH_64_BIT 1 #elif V8_TARGET_ARCH_S390 #if V8_TARGET_ARCH_S390X #define V8_TARGET_ARCH_64_BIT 1 #else #define V8_TARGET_ARCH_32_BIT 1 #endif #elif V8_TARGET_ARCH_RISCV64 #define V8_TARGET_ARCH_64_BIT 1 #elif V8_TARGET_ARCH_RISCV32 #define V8_TARGET_ARCH_32_BIT 1 #else #error Unknown target architecture pointer size #endif // Check for supported combinations of host and target architectures. #if V8_TARGET_ARCH_IA32 && !V8_HOST_ARCH_IA32 #error Target architecture ia32 is only supported on ia32 host #endif #if (V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_64_BIT && \ !((V8_HOST_ARCH_X64 \|\| V8_HOST_ARCH_ARM64) && V8_HOST_ARCH_64_BIT)) #error Target architecture x64 is only supported on x64 and arm64 host #endif #if (V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_32_BIT && \ !(V8_HOST_ARCH_X64 && V8_HOST_ARCH_32_BIT)) #error Target architecture x32 is only supported on x64 host with x32 support #endif #if (V8_TARGET_ARCH_ARM && !(V8_HOST_ARCH_IA32 \|\| V8_HOST_ARCH_ARM)) #error Target architecture arm is only supported on arm and ia32 host #endif #if (V8_TARGET_ARCH_ARM64 && !(V8_HOST_ARCH_X64 \|\| V8_HOST_ARCH_ARM64)) #error Target architecture arm64 is only supported on arm64 and x64 host #endif #if (V8_TARGET_ARCH_MIPS64 && !(V8_HOST_ARCH_X64 \|\| V8_HOST_ARCH_MIPS64)) #error Target architecture mips64 is only supported on mips64 and x64 host #endif #if (V8_TARGET_ARCH_RISCV64 && !(V8_HOST_ARCH_X64 \|\| V8_HOST_ARCH_RISCV64)) #error Target architecture riscv64 is only supported on riscv64 and x64 host #endif #if (V8_TARGET_ARCH_RISCV32 && !(V8_HOST_ARCH_IA32 \|\| V8_HOST_ARCH_RISCV32)) #error Target architecture riscv32 is only supported on riscv32 and ia32 host #endif #if (V8_TARGET_ARCH_LOONG64 && !(V8_HOST_ARCH_X64 \|\| V8_HOST_ARCH_LOONG64)) #error Target architecture loong64 is only supported on loong64 and x64 host #endif // Determine architecture endianness. #if V8_TARGET_ARCH_IA32 #define V8_TARGET_LITTLE_ENDIAN 1 #elif V8_TARGET_ARCH_X64 #define V8_TARGET_LITTLE_ENDIAN 1 #elif V8_TARGET_ARCH_ARM #define V8_TARGET_LITTLE_ENDIAN 1 #elif V8_TARGET_ARCH_ARM64 #define V8_TARGET_LITTLE_ENDIAN 1 #elif V8_TARGET_ARCH_LOONG64 #define V8_TARGET_LITTLE_ENDIAN 1 #elif V8_TARGET_ARCH_MIPS64 #if defined(__MIPSEB__) \|\| defined(V8_TARGET_ARCH_MIPS64_BE) #define V8_TARGET_BIG_ENDIAN 1 #else #define V8_TARGET_LITTLE_ENDIAN 1 #endif #elif defined(__BIG_ENDIAN__) // FOR PPCGR on AIX #define V8_TARGET_BIG_ENDIAN 1 #elif V8_TARGET_ARCH_PPC_LE #define V8_TARGET_LITTLE_ENDIAN 1 #elif V8_TARGET_ARCH_PPC_BE #define V8_TARGET_BIG_ENDIAN 1 #elif V8_TARGET_ARCH_S390 #if V8_TARGET_ARCH_S390_LE_SIM #define V8_TARGET_LITTLE_ENDIAN 1 #else #define V8_TARGET_BIG_ENDIAN 1 #endif #elif V8_TARGET_ARCH_RISCV32 \|\| V8_TARGET_ARCH_RISCV64 #define V8_TARGET_LITTLE_ENDIAN 1 #elif defined(__BYTE_ORDER__) #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ #define V8_TARGET_BIG_ENDIAN 1 #else #define V8_TARGET_LITTLE_ENDIAN 1 #endif #else #error Unknown target architecture endianness #endif #undef V8_HAS_CPP_ATTRIBUTE #if !defined(V8_STATIC_ROOTS) #define V8_STATIC_ROOTS_BOOL false #else #define V8_STATIC_ROOTS_BOOL true #endif #endif // V8CONFIG_H_	32.85 KB	2025-03-03 12:36

Edit File:

Terminal