diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000000..3000372e6d --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +NodeMobile filter=lfs diff=lfs merge=lfs -text diff --git a/packages/backend/classic_level.cjs b/packages/backend/classic_level.cjs index 0cf856e774..a3e6bf3b3d 100644 --- a/packages/backend/classic_level.cjs +++ b/packages/backend/classic_level.cjs @@ -7,7 +7,7 @@ const require = createRequire(import.meta.url) let bindings = null let arch = process.arch -if (process.platform === 'darwin') { +if (process.platform === 'darwin' || process.platform === 'ios') { arch = 'universal' } diff --git a/packages/mobile/.gitattributes b/packages/mobile/.gitattributes new file mode 100644 index 0000000000..3000372e6d --- /dev/null +++ b/packages/mobile/.gitattributes @@ -0,0 +1 @@ +NodeMobile filter=lfs diff=lfs merge=lfs -text diff --git a/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/Headers/NodeMobile.h b/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/Headers/NodeMobile.h old mode 100755 new mode 100644 diff --git a/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/Info.plist b/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/Info.plist index de36644842..776fd601c5 100644 Binary files a/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/Info.plist and b/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/Info.plist differ diff --git a/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/NodeMobile b/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/NodeMobile index 041ac319b7..e097bbc665 100755 Binary files a/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/NodeMobile and b/packages/mobile/ios/NodeJsMobile/NodeMobile.framework/NodeMobile differ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/common.gypi b/packages/mobile/ios/NodeJsMobile/libnode/include/node/common.gypi index 201592d909..70e825f082 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/common.gypi +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/common.gypi @@ -26,21 +26,20 @@ 'uv_library%': 'static_library', 'clang%': 0, + 'error_on_warn%': 'false', 'openssl_fips%': '', + '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.44', + 'v8_embedder_string': '-node.22', ##### V8 defaults for Node.js ##### - # Old time default, now explicitly stated. - 'v8_use_snapshot': 1, - # Turn on SipHash for hash seed generation, addresses HashWick 'v8_use_siphash': 'true', @@ -61,10 +60,19 @@ # 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 untrusted code mitigations. # See https://github.com/v8/v8/wiki/Untrusted-code-mitigations 'v8_untrusted_code_mitigations': 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, @@ -77,67 +85,47 @@ ##### end V8 defaults ##### 'conditions': [ - ['target_arch=="arm64"', { - # Disabled pending https://github.com/nodejs/node/issues/23913. - 'openssl_no_asm%': 1, - }, { - 'openssl_no_asm%': 0, - }], ['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, }], - ['v8_use_snapshot==1', { - 'conditions': [ - ['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 == "win"', { - 'obj_dir': '<(PRODUCT_DIR)/obj', - 'v8_base': '<(PRODUCT_DIR)/lib/libv8_snapshot.a', - }], - ['OS == "mac" or OS == "ios"', { - 'obj_dir%': '<(PRODUCT_DIR)/obj.target', - 'v8_base': '<(PRODUCT_DIR)/libv8_snapshot.a', - }], - ], + ['GENERATOR == "ninja"', { + 'obj_dir': '<(PRODUCT_DIR)/obj', + 'v8_base': '<(PRODUCT_DIR)/obj/tools/v8_gypfiles/libv8_snapshot.a', }, { - 'conditions': [ - ['GENERATOR == "ninja"', { - 'obj_dir': '<(PRODUCT_DIR)/obj', - 'v8_base': '<(PRODUCT_DIR)/obj/tools/v8_gypfiles/libv8_nosnapshot.a', - }, { - 'obj_dir%': '<(PRODUCT_DIR)/obj.target', - 'v8_base': '<(PRODUCT_DIR)/obj.target/tools/v8_gypfiles/libv8_nosnapshot.a', - }], - ['OS == "win"', { - 'obj_dir': '<(PRODUCT_DIR)/obj', - 'v8_base': '<(PRODUCT_DIR)/lib/libv8_nosnapshot.a', - }], - ['OS == "mac" or OS == "ios"', { - 'obj_dir%': '<(PRODUCT_DIR)/obj.target', - 'v8_base': '<(PRODUCT_DIR)/libv8_nosnapshot.a', - }], - ], + 'obj_dir%': '<(PRODUCT_DIR)/obj.target', + 'v8_base': '<(PRODUCT_DIR)/obj.target/tools/v8_gypfiles/libv8_snapshot.a', }], ['openssl_fips != ""', { - 'openssl_product': '<(STATIC_LIB_PREFIX)crypto<(STATIC_LIB_SUFFIX)', + 'openssl_product': '<(STATIC_LIB_PREFIX)openssl<(STATIC_LIB_SUFFIX)', }, { 'openssl_product': '<(STATIC_LIB_PREFIX)openssl<(STATIC_LIB_SUFFIX)', }], ['OS=="mac" or OS == "ios"', { 'clang%': 1, + '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, }], ['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 + }] ], }, @@ -188,22 +176,51 @@ 'v8_enable_handle_zapping': 0, 'pgo_generate': ' -fprofile-generate ', 'pgo_use': ' -fprofile-use -fprofile-correction ', - 'lto': ' -flto=4 -fuse-linker-plugin -ffat-lto-objects ', 'conditions': [ ['node_shared != "true"', { 'MSVC_runtimeType': 0 # MultiThreaded (/MT) }, { 'MSVC_runtimeType': 2 # MultiThreadedDLL (/MD) }], + ['llvm_version=="0.0"', { + 'lto': ' -flto=4 -fuse-linker-plugin -ffat-lto-objects ', # GCC + }, { + 'lto': ' -flto ', # Clang + }], ], }, '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!="mac" and OS!="ios" and OS!="win"', { + ['OS=="zos"', { + # increase performance, number from experimentation + 'cflags': [ '-qINLINE=::150:100000' ] + }], + ['OS!="mac" and OS!="ios" and OS!="win" and OS!="zos"', { 'cflags': [ '-fno-omit-frame-pointer' ], }], ['OS=="linux"', { @@ -216,10 +233,6 @@ 'cflags': ['<(pgo_use)'], 'ldflags': ['<(pgo_use)'], },], - ['enable_lto=="true"', { - 'cflags': ['<(lto)'], - 'ldflags': ['<(lto)'], - },], ], },], ['OS == "android"', { @@ -229,6 +242,11 @@ ], 'msvs_settings': { 'VCCLCompilerTool': { + 'conditions': [ + ['target_arch=="arm64"', { + 'FloatingPointModel': 1 # /fp:strict + }] + ], 'EnableFunctionLevelLinking': 'true', 'EnableIntrinsicFunctions': 'true', 'FavorSizeOrSpeed': 1, # /Ot, favor speed over size @@ -250,16 +268,29 @@ 'defines': [ 'V8_DEPRECATION_WARNINGS', 'V8_IMMINENT_DEPRECATION_WARNINGS', + '_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. - 'cflags!': ['-Werror'], + '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': { + 'AdditionalOptions': ['/Zc:__cplusplus'], 'BufferSecurityCheck': 'true', - 'DebugInformationFormat': 1, # /Z7 embed info in .obj files + 'target_conditions': [ + ['_toolset=="target"', { + 'DebugInformationFormat': 1 # /Z7 embed info in .obj files + }], + ], 'ExceptionHandling': 0, # /EHsc 'MultiProcessorCompilation': 'true', 'StringPooling': 'true', # pool string literals @@ -317,7 +348,7 @@ [ 'target_arch=="arm64"', { 'msvs_configuration_platform': 'arm64', }], - ['asan == 1 and OS != "mac" and OS !="ios"', { + ['asan == 1 and OS != "mac" and OS != "ios" and OS != "zos"', { 'cflags+': [ '-fno-omit-frame-pointer', '-fsanitize=address', @@ -345,6 +376,15 @@ }], ], }], + ['v8_enable_pointer_compression == 1', { + 'defines': [ + 'V8_COMPRESS_POINTERS', + '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'], + }], ['OS == "win"', { 'defines': [ 'WIN32', @@ -366,7 +406,7 @@ }], [ 'OS in "linux freebsd openbsd solaris android aix cloudabi"', { 'cflags': [ '-Wall', '-Wextra', '-Wno-unused-parameter', ], - 'cflags_cc': [ '-fno-rtti', '-fno-exceptions', '-std=gnu++1y' ], + 'cflags_cc': [ '-fno-rtti', '-fno-exceptions', '-std=gnu++14' ], 'defines': [ '__STDC_FORMAT_MACROS' ], 'ldflags': [ '-rdynamic' ], 'target_conditions': [ @@ -384,10 +424,6 @@ 'cflags': [ '-m32' ], 'ldflags': [ '-m32' ], }], - [ 'target_arch=="x32"', { - 'cflags': [ '-mx32' ], - 'ldflags': [ '-mx32' ], - }], [ 'target_arch=="x64"', { 'cflags': [ '-m64' ], 'ldflags': [ '-m64' ], @@ -400,7 +436,7 @@ 'cflags': [ '-m64', '-mminimal-toc' ], 'ldflags': [ '-m64' ], }], - [ 'target_arch=="s390x"', { + [ 'target_arch=="s390x" and OS=="linux"', { 'cflags': [ '-m64', '-march=z196' ], 'ldflags': [ '-m64', '-march=z196' ], }], @@ -488,7 +524,7 @@ 'GCC_ENABLE_CPP_RTTI': 'NO', # -fno-rtti 'GCC_ENABLE_PASCAL_STRINGS': 'NO', # No -mpascal-strings 'PREBINDING': 'NO', # No -Wl,-prebind - 'MACOSX_DEPLOYMENT_TARGET': '10.10', # -mmacosx-version-min=10.10 + 'MACOSX_DEPLOYMENT_TARGET': '10.13', # -mmacosx-version-min=10.13 'USE_HEADERMAP': 'NO', 'OTHER_CFLAGS': [ '-fno-strict-aliasing', @@ -504,8 +540,7 @@ ['_type!="static_library"', { 'xcode_settings': { 'OTHER_LDFLAGS': [ - '-Wl,-no_pie', - '-Wl,-search_paths_first', + '-Wl,-search_paths_first' ], }, }], @@ -528,7 +563,7 @@ ['clang==1', { 'xcode_settings': { 'GCC_VERSION': 'com.apple.compilers.llvm.clang.1_0', - 'CLANG_CXX_LANGUAGE_STANDARD': 'gnu++1y', # -std=gnu++1y + 'CLANG_CXX_LANGUAGE_STANDARD': 'gnu++14', # -std=gnu++14 'CLANG_CXX_LIBRARY': 'libc++', }, }], @@ -545,7 +580,7 @@ 'GCC_ENABLE_CPP_RTTI': 'NO', # -fno-rtti 'GCC_ENABLE_PASCAL_STRINGS': 'NO', # No -mpascal-strings 'PREBINDING': 'NO', # No -Wl,-prebind - 'IPHONEOS_DEPLOYMENT_TARGET': '9.0', # -miphoneos-version-min=9.0 + 'IPHONEOS_DEPLOYMENT_TARGET': '11.0', # -miphoneos-version-min=11.0 'USE_HEADERMAP': 'NO', 'OTHER_CFLAGS': [ '-fno-strict-aliasing', @@ -638,6 +673,50 @@ '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)'], + }], ], } -} \ No newline at end of file +} diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/config.gypi b/packages/mobile/ios/NodeJsMobile/libnode/include/node/config.gypi index 43bbab5bea..03ead402b5 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/config.gypi +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/config.gypi @@ -1,9 +1,5 @@ # Do not edit. Generated by the configure script. -{ 'target_defaults': { 'cflags': [], - 'default_configuration': 'Release', - 'defines': [], - 'include_dirs': [], - 'libraries': []}, +{ 'target_defaults': {'cflags': [], 'default_configuration': 'Release', 'defines': ['NODE_OPENSSL_CONF_NAME=nodejs_conf'], 'include_dirs': [], 'libraries': []}, 'variables': { 'OS': 'ios', 'asan': 0, 'coverage': 'false', @@ -16,14 +12,7 @@ 'error_on_warn': 'false', 'force_dynamic_crt': 0, 'host_arch': 'x64', - 'icu_data_in': '../../deps/icu-tmp/icudt70l.dat', - 'icu_default_data': '', - 'icu_endianness': 'l', - 'icu_gyp_path': 'tools/icu/icu-generic.gyp', - 'icu_locales': 'en,root', - 'icu_path': 'deps/icu-small', - 'icu_small': 'true', - 'icu_ver_major': '70', + 'icu_small': 'false', 'is_debug': 0, 'llvm_version': '14.0', 'napi_build_version': '8', @@ -44,6 +33,7 @@ 'lib/child_process.js', 'lib/assert.js', 'lib/_tls_wrap.js', + 'lib/test.js', 'lib/http2.js', 'lib/inspector.js', 'lib/os.js', @@ -139,6 +129,11 @@ 'lib/internal/http.js', 'lib/internal/buffer.js', 'lib/internal/trace_events_async_hooks.js', + 'lib/internal/v8/startup_snapshot.js', + 'lib/internal/test_runner/test.js', + 'lib/internal/test_runner/harness.js', + 'lib/internal/test_runner/utils.js', + 'lib/internal/test_runner/tap_stream.js', 'lib/internal/crypto/sig.js', 'lib/internal/crypto/rsa.js', 'lib/internal/crypto/aes.js', @@ -146,6 +141,7 @@ 'lib/internal/crypto/scrypt.js', 'lib/internal/crypto/random.js', 'lib/internal/crypto/keys.js', + 'lib/internal/crypto/cfrg.js', 'lib/internal/crypto/x509.js', 'lib/internal/crypto/certificate.js', 'lib/internal/crypto/ec.js', @@ -157,7 +153,6 @@ 'lib/internal/crypto/hash.js', 'lib/internal/crypto/pbkdf2.js', 'lib/internal/crypto/webcrypto.js', - 'lib/internal/crypto/dsa.js', 'lib/internal/crypto/hashnames.js', 'lib/internal/cluster/shared_handle.js', 'lib/internal/cluster/round_robin_handle.js', @@ -165,6 +160,7 @@ 'lib/internal/cluster/primary.js', 'lib/internal/cluster/utils.js', 'lib/internal/cluster/child.js', + 'lib/internal/webstreams/compression.js', 'lib/internal/webstreams/util.js', 'lib/internal/webstreams/writablestream.js', 'lib/internal/webstreams/readablestream.js', @@ -189,6 +185,8 @@ 'lib/internal/util/debuglog.js', 'lib/internal/util/inspect.js', 'lib/internal/util/iterable_weak_map.js', + 'lib/internal/util/parse_args/utils.js', + 'lib/internal/util/parse_args/parse_args.js', 'lib/internal/streams/add-abort-signal.js', 'lib/internal/streams/compose.js', 'lib/internal/streams/duplexify.js', @@ -238,7 +236,9 @@ 'lib/internal/main/eval_string.js', 'lib/internal/main/check_syntax.js', 'lib/internal/main/prof_process.js', + 'lib/internal/main/test_runner.js', 'lib/internal/main/worker_thread.js', + 'lib/internal/main/mksnapshot.js', 'lib/internal/main/inspect.js', 'lib/internal/main/eval_stdin.js', 'lib/internal/main/run_main_module.js', @@ -246,7 +246,7 @@ 'lib/internal/modules/package_json_reader.js', 'lib/internal/modules/esm/module_job.js', 'lib/internal/modules/esm/assert.js', - 'lib/internal/modules/esm/get_source.js', + 'lib/internal/modules/esm/fetch_module.js', 'lib/internal/modules/esm/translators.js', 'lib/internal/modules/esm/resolve.js', 'lib/internal/modules/esm/create_dynamic_module.js', @@ -255,6 +255,7 @@ 'lib/internal/modules/esm/initialize_import_meta.js', 'lib/internal/modules/esm/module_map.js', 'lib/internal/modules/esm/get_format.js', + 'lib/internal/modules/esm/formats.js', 'lib/internal/modules/esm/loader.js', 'lib/internal/modules/cjs/helpers.js', 'lib/internal/modules/cjs/loader.js', @@ -281,6 +282,7 @@ 'lib/internal/perf/utils.js', 'lib/internal/perf/observe.js', 'lib/internal/perf/event_loop_delay.js', + 'lib/internal/perf/resource_timing.js', 'lib/internal/perf/event_loop_utilization.js', 'lib/internal/policy/manifest.js', 'lib/internal/policy/sri.js', @@ -331,15 +333,16 @@ 'openssl_quic': 'true', 'ossfuzz': 'false', 'shlib_suffix': '93.dylib', - 'target_arch': 'arm64', + 'target_arch': 'x64', 'v8_enable_31bit_smis_on_64bit_arch': 0, 'v8_enable_gdbjit': 0, - 'v8_enable_i18n_support': 1, - 'v8_enable_inspector': 1, + 'v8_enable_hugepage': 0, + 'v8_enable_i18n_support': 0, + 'v8_enable_inspector': 0, 'v8_enable_lite_mode': 0, 'v8_enable_object_print': 1, 'v8_enable_pointer_compression': 0, - 'v8_enable_webassembly': 0, + 'v8_enable_webassembly': 1, 'v8_no_strict_aliasing': 1, 'v8_optimized_debug': 1, 'v8_promise_internal_field_count': 1, diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/allocation.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/allocation.h new file mode 100644 index 0000000000..d75f1a9729 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/allocation.h @@ -0,0 +1,233 @@ +// 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_CPPGC_ALLOCATION_H_ +#define INCLUDE_CPPGC_ALLOCATION_H_ + +#include +#include +#include +#include +#include +#include + +#include "cppgc/custom-space.h" +#include "cppgc/internal/api-constants.h" +#include "cppgc/internal/gc-info.h" +#include "cppgc/type-traits.h" +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +/** + * AllocationHandle is used to allocate garbage-collected objects. + */ +class AllocationHandle; + +namespace internal { + +class V8_EXPORT MakeGarbageCollectedTraitInternal { + protected: + static inline void MarkObjectAsFullyConstructed(const void* payload) { + // See api_constants for an explanation of the constants. + std::atomic* atomic_mutable_bitfield = + reinterpret_cast*>( + const_cast(reinterpret_cast( + reinterpret_cast(payload) - + api_constants::kFullyConstructedBitFieldOffsetFromPayload))); + atomic_mutable_bitfield->fetch_or(api_constants::kFullyConstructedBitMask, + std::memory_order_release); + } + + template + struct SpacePolicy { + static void* Allocate(AllocationHandle& handle, size_t size) { + // Custom space. + static_assert(std::is_base_of::value, + "Custom space must inherit from CustomSpaceBase."); + return MakeGarbageCollectedTraitInternal::Allocate( + handle, size, internal::GCInfoTrait::Index(), + CustomSpace::kSpaceIndex); + } + }; + + template + struct SpacePolicy { + static void* Allocate(AllocationHandle& handle, size_t size) { + // Default space. + return MakeGarbageCollectedTraitInternal::Allocate( + handle, size, internal::GCInfoTrait::Index()); + } + }; + + private: + static void* Allocate(cppgc::AllocationHandle& handle, size_t size, + GCInfoIndex index); + static void* Allocate(cppgc::AllocationHandle& handle, size_t size, + GCInfoIndex index, CustomSpaceIndex space_index); + + friend class HeapObjectHeader; +}; + +} // namespace internal + +/** + * Base trait that provides utilities for advancers users that have custom + * allocation needs (e.g., overriding size). It's expected that users override + * MakeGarbageCollectedTrait (see below) and inherit from + * MakeGarbageCollectedTraitBase and make use of the low-level primitives + * offered to allocate and construct an object. + */ +template +class MakeGarbageCollectedTraitBase + : private internal::MakeGarbageCollectedTraitInternal { + private: + static_assert(internal::IsGarbageCollectedType::value, + "T needs to be a garbage collected object"); + static_assert(!IsGarbageCollectedWithMixinTypeV || + sizeof(T) <= + internal::api_constants::kLargeObjectSizeThreshold, + "GarbageCollectedMixin may not be a large object"); + + protected: + /** + * Allocates memory for an object of type T. + * + * \param handle AllocationHandle identifying the heap to allocate the object + * on. + * \param size The size that should be reserved for the object. + * \returns the memory to construct an object of type T on. + */ + V8_INLINE static void* Allocate(AllocationHandle& handle, size_t size) { + static_assert( + std::is_base_of::value, + "U of GarbageCollected must be a base of T. Check " + "GarbageCollected base class inheritance."); + return SpacePolicy< + typename internal::GCInfoFolding< + T, typename T::ParentMostGarbageCollectedType>::ResultType, + typename SpaceTrait::Space>::Allocate(handle, size); + } + + /** + * Marks an object as fully constructed, resulting in precise handling by the + * garbage collector. + * + * \param payload The base pointer the object is allocated at. + */ + V8_INLINE static void MarkObjectAsFullyConstructed(const void* payload) { + internal::MakeGarbageCollectedTraitInternal::MarkObjectAsFullyConstructed( + payload); + } +}; + +/** + * Passed to MakeGarbageCollected to specify how many bytes should be appended + * to the allocated object. + * + * Example: + * \code + * class InlinedArray final : public GarbageCollected { + * public: + * explicit InlinedArray(size_t bytes) : size(bytes), byte_array(this + 1) {} + * void Trace(Visitor*) const {} + + * size_t size; + * char* byte_array; + * }; + * + * auto* inlined_array = MakeGarbageCollectedbyte_array[i]); + * } + * \endcode + */ +struct AdditionalBytes { + constexpr explicit AdditionalBytes(size_t bytes) : value(bytes) {} + const size_t value; +}; + +/** + * Default trait class that specifies how to construct an object of type T. + * Advanced users may override how an object is constructed using the utilities + * that are provided through MakeGarbageCollectedTraitBase. + * + * Any trait overriding construction must + * - allocate through `MakeGarbageCollectedTraitBase::Allocate`; + * - mark the object as fully constructed using + * `MakeGarbageCollectedTraitBase::MarkObjectAsFullyConstructed`; + */ +template +class MakeGarbageCollectedTrait : public MakeGarbageCollectedTraitBase { + public: + template + static T* Call(AllocationHandle& handle, Args&&... args) { + void* memory = + MakeGarbageCollectedTraitBase::Allocate(handle, sizeof(T)); + T* object = ::new (memory) T(std::forward(args)...); + MakeGarbageCollectedTraitBase::MarkObjectAsFullyConstructed(object); + return object; + } + + template + static T* Call(AllocationHandle& handle, AdditionalBytes additional_bytes, + Args&&... args) { + void* memory = MakeGarbageCollectedTraitBase::Allocate( + handle, sizeof(T) + additional_bytes.value); + T* object = ::new (memory) T(std::forward(args)...); + MakeGarbageCollectedTraitBase::MarkObjectAsFullyConstructed(object); + return object; + } +}; + +/** + * Allows users to specify a post-construction callback for specific types. The + * callback is invoked on the instance of type T right after it has been + * constructed. This can be useful when the callback requires a + * fully-constructed object to be able to dispatch to virtual methods. + */ +template +struct PostConstructionCallbackTrait { + static void Call(T*) {} +}; + +/** + * Constructs a managed object of type T where T transitively inherits from + * GarbageCollected. + * + * \param args List of arguments with which an instance of T will be + * constructed. + * \returns an instance of type T. + */ +template +T* MakeGarbageCollected(AllocationHandle& handle, Args&&... args) { + T* object = + MakeGarbageCollectedTrait::Call(handle, std::forward(args)...); + PostConstructionCallbackTrait::Call(object); + return object; +} + +/** + * Constructs a managed object of type T where T transitively inherits from + * GarbageCollected. Created objects will have additional bytes appended to + * it. Allocated memory would suffice for `sizeof(T) + additional_bytes`. + * + * \param additional_bytes Denotes how many bytes to append to T. + * \param args List of arguments with which an instance of T will be + * constructed. + * \returns an instance of type T. + */ +template +T* MakeGarbageCollected(AllocationHandle& handle, + AdditionalBytes additional_bytes, Args&&... args) { + T* object = MakeGarbageCollectedTrait::Call(handle, additional_bytes, + std::forward(args)...); + PostConstructionCallbackTrait::Call(object); + return object; +} + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_ALLOCATION_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/common.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/common.h new file mode 100644 index 0000000000..b6dbff3dd6 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/common.h @@ -0,0 +1,29 @@ +// 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_CPPGC_COMMON_H_ +#define INCLUDE_CPPGC_COMMON_H_ + +// TODO(chromium:1056170): Remove dependency on v8. +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +/** + * Indicator for the stack state of the embedder. + */ +enum class EmbedderStackState { + /** + * Stack may contain interesting heap pointers. + */ + kMayContainHeapPointers, + /** + * Stack does not contain any interesting heap pointers. + */ + kNoHeapPointers, +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_COMMON_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/cross-thread-persistent.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/cross-thread-persistent.h new file mode 100644 index 0000000000..0a9afdcd2b --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/cross-thread-persistent.h @@ -0,0 +1,413 @@ +// 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_CPPGC_CROSS_THREAD_PERSISTENT_H_ +#define INCLUDE_CPPGC_CROSS_THREAD_PERSISTENT_H_ + +#include + +#include "cppgc/internal/persistent-node.h" +#include "cppgc/internal/pointer-policies.h" +#include "cppgc/persistent.h" +#include "cppgc/visitor.h" + +namespace cppgc { +namespace internal { + +// Wrapper around PersistentBase that allows accessing poisoned memory when +// using ASAN. This is needed as the GC of the heap that owns the value +// of a CTP, may clear it (heap termination, weakness) while the object +// holding the CTP may be poisoned as itself may be deemed dead. +class CrossThreadPersistentBase : public PersistentBase { + public: + CrossThreadPersistentBase() = default; + explicit CrossThreadPersistentBase(const void* raw) : PersistentBase(raw) {} + + V8_CLANG_NO_SANITIZE("address") const void* GetValueFromGC() const { + return raw_; + } + + V8_CLANG_NO_SANITIZE("address") + PersistentNode* GetNodeFromGC() const { return node_; } + + V8_CLANG_NO_SANITIZE("address") + void ClearFromGC() const { + raw_ = nullptr; + node_ = nullptr; + } +}; + +template +class BasicCrossThreadPersistent final : public CrossThreadPersistentBase, + public LocationPolicy, + private WeaknessPolicy, + private CheckingPolicy { + public: + using typename WeaknessPolicy::IsStrongPersistent; + using PointeeType = T; + + ~BasicCrossThreadPersistent() { Clear(); } + + BasicCrossThreadPersistent( + const SourceLocation& loc = SourceLocation::Current()) + : LocationPolicy(loc) {} + + BasicCrossThreadPersistent( + std::nullptr_t, const SourceLocation& loc = SourceLocation::Current()) + : LocationPolicy(loc) {} + + BasicCrossThreadPersistent( + SentinelPointer s, const SourceLocation& loc = SourceLocation::Current()) + : CrossThreadPersistentBase(s), LocationPolicy(loc) {} + + BasicCrossThreadPersistent( + T* raw, const SourceLocation& loc = SourceLocation::Current()) + : CrossThreadPersistentBase(raw), LocationPolicy(loc) { + if (!IsValid(raw)) return; + PersistentRegionLock guard; + CrossThreadPersistentRegion& region = this->GetPersistentRegion(raw); + SetNode(region.AllocateNode(this, &Trace)); + this->CheckPointer(raw); + } + + class UnsafeCtorTag { + private: + UnsafeCtorTag() = default; + template + friend class BasicCrossThreadPersistent; + }; + + BasicCrossThreadPersistent( + UnsafeCtorTag, T* raw, + const SourceLocation& loc = SourceLocation::Current()) + : CrossThreadPersistentBase(raw), LocationPolicy(loc) { + if (!IsValid(raw)) return; + CrossThreadPersistentRegion& region = this->GetPersistentRegion(raw); + SetNode(region.AllocateNode(this, &Trace)); + this->CheckPointer(raw); + } + + BasicCrossThreadPersistent( + T& raw, const SourceLocation& loc = SourceLocation::Current()) + : BasicCrossThreadPersistent(&raw, loc) {} + + template ::value>> + BasicCrossThreadPersistent( + internal::BasicMember + member, + const SourceLocation& loc = SourceLocation::Current()) + : BasicCrossThreadPersistent(member.Get(), loc) {} + + BasicCrossThreadPersistent( + const BasicCrossThreadPersistent& other, + const SourceLocation& loc = SourceLocation::Current()) + : BasicCrossThreadPersistent(loc) { + // Invoke operator=. + *this = other; + } + + // Heterogeneous ctor. + template ::value>> + BasicCrossThreadPersistent( + const BasicCrossThreadPersistent& other, + const SourceLocation& loc = SourceLocation::Current()) + : BasicCrossThreadPersistent(loc) { + *this = other; + } + + BasicCrossThreadPersistent( + BasicCrossThreadPersistent&& other, + const SourceLocation& loc = SourceLocation::Current()) noexcept { + // Invoke operator=. + *this = std::move(other); + } + + BasicCrossThreadPersistent& operator=( + const BasicCrossThreadPersistent& other) { + PersistentRegionLock guard; + AssignUnsafe(other.Get()); + return *this; + } + + template ::value>> + BasicCrossThreadPersistent& operator=( + const BasicCrossThreadPersistent& other) { + PersistentRegionLock guard; + AssignUnsafe(other.Get()); + return *this; + } + + BasicCrossThreadPersistent& operator=(BasicCrossThreadPersistent&& other) { + if (this == &other) return *this; + Clear(); + PersistentRegionLock guard; + PersistentBase::operator=(std::move(other)); + LocationPolicy::operator=(std::move(other)); + if (!IsValid(GetValue())) return *this; + GetNode()->UpdateOwner(this); + other.SetValue(nullptr); + other.SetNode(nullptr); + this->CheckPointer(Get()); + return *this; + } + + BasicCrossThreadPersistent& operator=(T* other) { + Assign(other); + return *this; + } + + // Assignment from member. + template ::value>> + BasicCrossThreadPersistent& operator=( + internal::BasicMember + member) { + return operator=(member.Get()); + } + + BasicCrossThreadPersistent& operator=(std::nullptr_t) { + Clear(); + return *this; + } + + BasicCrossThreadPersistent& operator=(SentinelPointer s) { + Assign(s); + return *this; + } + + /** + * Returns a pointer to the stored object. + * + * Note: **Not thread-safe.** + * + * \returns a pointer to the stored object. + */ + // CFI cast exemption to allow passing SentinelPointer through T* and support + // heterogeneous assignments between different Member and Persistent handles + // based on their actual types. + V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const { + return static_cast(const_cast(GetValue())); + } + + /** + * Clears the stored object. + */ + void Clear() { + // Simplified version of `Assign()` to allow calling without a complete type + // `T`. + const void* old_value = GetValue(); + if (IsValid(old_value)) { + PersistentRegionLock guard; + old_value = GetValue(); + // The fast path check (IsValid()) does not acquire the lock. Reload + // the value to ensure the reference has not been cleared. + if (IsValid(old_value)) { + CrossThreadPersistentRegion& region = + this->GetPersistentRegion(old_value); + region.FreeNode(GetNode()); + SetNode(nullptr); + } else { + CPPGC_DCHECK(!GetNode()); + } + } + SetValue(nullptr); + } + + /** + * Returns a pointer to the stored object and releases it. + * + * Note: **Not thread-safe.** + * + * \returns a pointer to the stored object. + */ + T* Release() { + T* result = Get(); + Clear(); + return result; + } + + /** + * Conversio to boolean. + * + * Note: **Not thread-safe.** + * + * \returns true if an actual object has been stored and false otherwise. + */ + explicit operator bool() const { return Get(); } + + /** + * Conversion to object of type T. + * + * Note: **Not thread-safe.** + * + * \returns the object. + */ + operator T*() const { return Get(); } + + /** + * Dereferences the stored object. + * + * Note: **Not thread-safe.** + */ + T* operator->() const { return Get(); } + T& operator*() const { return *Get(); } + + template + BasicCrossThreadPersistent + To() const { + using OtherBasicCrossThreadPersistent = + BasicCrossThreadPersistent; + PersistentRegionLock guard; + return OtherBasicCrossThreadPersistent( + typename OtherBasicCrossThreadPersistent::UnsafeCtorTag(), + static_cast(Get())); + } + + template ::IsStrongPersistent::value>::type> + BasicCrossThreadPersistent + Lock() const { + return BasicCrossThreadPersistent< + U, internal::StrongCrossThreadPersistentPolicy>(*this); + } + + private: + static bool IsValid(const void* ptr) { + return ptr && ptr != kSentinelPointer; + } + + static void Trace(Visitor* v, const void* ptr) { + const auto* handle = static_cast(ptr); + v->TraceRoot(*handle, handle->Location()); + } + + void Assign(T* ptr) { + const void* old_value = GetValue(); + if (IsValid(old_value)) { + PersistentRegionLock guard; + old_value = GetValue(); + // The fast path check (IsValid()) does not acquire the lock. Reload + // the value to ensure the reference has not been cleared. + if (IsValid(old_value)) { + CrossThreadPersistentRegion& region = + this->GetPersistentRegion(old_value); + if (IsValid(ptr) && (®ion == &this->GetPersistentRegion(ptr))) { + SetValue(ptr); + this->CheckPointer(ptr); + return; + } + region.FreeNode(GetNode()); + SetNode(nullptr); + } else { + CPPGC_DCHECK(!GetNode()); + } + } + SetValue(ptr); + if (!IsValid(ptr)) return; + PersistentRegionLock guard; + SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &Trace)); + this->CheckPointer(ptr); + } + + void AssignUnsafe(T* ptr) { + PersistentRegionLock::AssertLocked(); + const void* old_value = GetValue(); + if (IsValid(old_value)) { + CrossThreadPersistentRegion& region = + this->GetPersistentRegion(old_value); + if (IsValid(ptr) && (®ion == &this->GetPersistentRegion(ptr))) { + SetValue(ptr); + this->CheckPointer(ptr); + return; + } + region.FreeNode(GetNode()); + SetNode(nullptr); + } + SetValue(ptr); + if (!IsValid(ptr)) return; + SetNode(this->GetPersistentRegion(ptr).AllocateNode(this, &Trace)); + this->CheckPointer(ptr); + } + + void ClearFromGC() const { + if (IsValid(GetValueFromGC())) { + WeaknessPolicy::GetPersistentRegion(GetValueFromGC()) + .FreeNode(GetNodeFromGC()); + CrossThreadPersistentBase::ClearFromGC(); + } + } + + // See Get() for details. + V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") + T* GetFromGC() const { + return static_cast(const_cast(GetValueFromGC())); + } + + friend class cppgc::Visitor; +}; + +template +struct IsWeak< + BasicCrossThreadPersistent> + : std::true_type {}; + +} // namespace internal + +namespace subtle { + +/** + * **DO NOT USE: Has known caveats, see below.** + * + * CrossThreadPersistent allows retaining objects from threads other than the + * thread the owning heap is operating on. + * + * Known caveats: + * - Does not protect the heap owning an object from terminating. + * - Reaching transitively through the graph is unsupported as objects may be + * moved concurrently on the thread owning the object. + */ +template +using CrossThreadPersistent = internal::BasicCrossThreadPersistent< + T, internal::StrongCrossThreadPersistentPolicy>; + +/** + * **DO NOT USE: Has known caveats, see below.** + * + * CrossThreadPersistent allows weakly retaining objects from threads other than + * the thread the owning heap is operating on. + * + * Known caveats: + * - Does not protect the heap owning an object from terminating. + * - Reaching transitively through the graph is unsupported as objects may be + * moved concurrently on the thread owning the object. + */ +template +using WeakCrossThreadPersistent = internal::BasicCrossThreadPersistent< + T, internal::WeakCrossThreadPersistentPolicy>; + +} // namespace subtle +} // namespace cppgc + +#endif // INCLUDE_CPPGC_CROSS_THREAD_PERSISTENT_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/custom-space.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/custom-space.h new file mode 100644 index 0000000000..757c4fde15 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/custom-space.h @@ -0,0 +1,97 @@ +// 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_CPPGC_CUSTOM_SPACE_H_ +#define INCLUDE_CPPGC_CUSTOM_SPACE_H_ + +#include + +namespace cppgc { + +/** + * Index identifying a custom space. + */ +struct CustomSpaceIndex { + constexpr CustomSpaceIndex(size_t value) : value(value) {} // NOLINT + size_t value; +}; + +/** + * Top-level base class for custom spaces. Users must inherit from CustomSpace + * below. + */ +class CustomSpaceBase { + public: + virtual ~CustomSpaceBase() = default; + virtual CustomSpaceIndex GetCustomSpaceIndex() const = 0; + virtual bool IsCompactable() const = 0; +}; + +/** + * Base class custom spaces should directly inherit from. The class inheriting + * from `CustomSpace` must define `kSpaceIndex` as unique space index. These + * indices need for form a sequence starting at 0. + * + * Example: + * \code + * class CustomSpace1 : public CustomSpace { + * public: + * static constexpr CustomSpaceIndex kSpaceIndex = 0; + * }; + * class CustomSpace2 : public CustomSpace { + * public: + * static constexpr CustomSpaceIndex kSpaceIndex = 1; + * }; + * \endcode + */ +template +class CustomSpace : public CustomSpaceBase { + public: + /** + * Compaction is only supported on spaces that manually manage slots + * recording. + */ + static constexpr bool kSupportsCompaction = false; + + CustomSpaceIndex GetCustomSpaceIndex() const final { + return ConcreteCustomSpace::kSpaceIndex; + } + bool IsCompactable() const final { + return ConcreteCustomSpace::kSupportsCompaction; + } +}; + +/** + * User-overridable trait that allows pinning types to custom spaces. + */ +template +struct SpaceTrait { + using Space = void; +}; + +namespace internal { + +template +struct IsAllocatedOnCompactableSpaceImpl { + static constexpr bool value = CustomSpace::kSupportsCompaction; +}; + +template <> +struct IsAllocatedOnCompactableSpaceImpl { + // Non-custom spaces are by default not compactable. + static constexpr bool value = false; +}; + +template +struct IsAllocatedOnCompactableSpace { + public: + static constexpr bool value = + IsAllocatedOnCompactableSpaceImpl::Space>::value; +}; + +} // namespace internal + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_CUSTOM_SPACE_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/default-platform.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/default-platform.h new file mode 100644 index 0000000000..2ccdeddd83 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/default-platform.h @@ -0,0 +1,75 @@ +// 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_CPPGC_DEFAULT_PLATFORM_H_ +#define INCLUDE_CPPGC_DEFAULT_PLATFORM_H_ + +#include +#include + +#include "cppgc/platform.h" +#include "libplatform/libplatform.h" +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +/** + * Platform provided by cppgc. Uses V8's DefaultPlatform provided by + * libplatform internally. Exception: `GetForegroundTaskRunner()`, see below. + */ +class V8_EXPORT DefaultPlatform : public Platform { + public: + /** + * Use this method instead of 'cppgc::InitializeProcess' when using + * 'cppgc::DefaultPlatform'. 'cppgc::DefaultPlatform::InitializeProcess' + * will initialize cppgc and v8 if needed (for non-standalone builds). + * + * \param platform DefaultPlatform instance used to initialize cppgc/v8. + */ + static void InitializeProcess(DefaultPlatform* platform); + + using IdleTaskSupport = v8::platform::IdleTaskSupport; + explicit DefaultPlatform( + int thread_pool_size = 0, + IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled, + std::unique_ptr tracing_controller = {}) + : v8_platform_(v8::platform::NewDefaultPlatform( + thread_pool_size, idle_task_support, + v8::platform::InProcessStackDumping::kDisabled, + std::move(tracing_controller))) {} + + cppgc::PageAllocator* GetPageAllocator() override { + return v8_platform_->GetPageAllocator(); + } + + double MonotonicallyIncreasingTime() override { + return v8_platform_->MonotonicallyIncreasingTime(); + } + + std::shared_ptr GetForegroundTaskRunner() override { + // V8's default platform creates a new task runner when passed the + // `v8::Isolate` pointer the first time. For non-default platforms this will + // require getting the appropriate task runner. + return v8_platform_->GetForegroundTaskRunner(kNoIsolate); + } + + std::unique_ptr PostJob( + cppgc::TaskPriority priority, + std::unique_ptr job_task) override { + return v8_platform_->PostJob(priority, std::move(job_task)); + } + + TracingController* GetTracingController() override { + return v8_platform_->GetTracingController(); + } + + protected: + static constexpr v8::Isolate* kNoIsolate = nullptr; + + std::unique_ptr v8_platform_; +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_DEFAULT_PLATFORM_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/ephemeron-pair.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/ephemeron-pair.h new file mode 100644 index 0000000000..e16cf1f0aa --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/ephemeron-pair.h @@ -0,0 +1,30 @@ +// 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_CPPGC_EPHEMERON_PAIR_H_ +#define INCLUDE_CPPGC_EPHEMERON_PAIR_H_ + +#include "cppgc/liveness-broker.h" +#include "cppgc/member.h" + +namespace cppgc { + +/** + * An ephemeron pair is used to conditionally retain an object. + * The `value` will be kept alive only if the `key` is alive. + */ +template +struct EphemeronPair { + EphemeronPair(K* k, V* v) : key(k), value(v) {} + WeakMember key; + Member value; + + void ClearValueIfKeyIsDead(const LivenessBroker& broker) { + if (!broker.IsHeapObjectAlive(key)) value = nullptr; + } +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_EPHEMERON_PAIR_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/explicit-management.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/explicit-management.h new file mode 100644 index 0000000000..cdb6af4858 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/explicit-management.h @@ -0,0 +1,82 @@ +// 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_CPPGC_EXPLICIT_MANAGEMENT_H_ +#define INCLUDE_CPPGC_EXPLICIT_MANAGEMENT_H_ + +#include + +#include "cppgc/allocation.h" +#include "cppgc/internal/logging.h" +#include "cppgc/type-traits.h" + +namespace cppgc { + +class HeapHandle; + +namespace internal { + +V8_EXPORT void FreeUnreferencedObject(HeapHandle&, void*); +V8_EXPORT bool Resize(void*, size_t); + +} // namespace internal + +namespace subtle { + +/** + * Informs the garbage collector that `object` can be immediately reclaimed. The + * destructor may not be invoked immediately but only on next garbage + * collection. + * + * It is up to the embedder to guarantee that no other object holds a reference + * to `object` after calling `FreeUnreferencedObject()`. In case such a + * reference exists, it's use results in a use-after-free. + * + * To aid in using the API, `FreeUnreferencedObject()` may be called from + * destructors on objects that would be reclaimed in the same garbage collection + * cycle. + * + * \param heap_handle The corresponding heap. + * \param object Reference to an object that is of type `GarbageCollected` and + * should be immediately reclaimed. + */ +template +void FreeUnreferencedObject(HeapHandle& heap_handle, T& object) { + static_assert(IsGarbageCollectedTypeV, + "Object must be of type GarbageCollected."); + internal::FreeUnreferencedObject(heap_handle, &object); +} + +/** + * Tries to resize `object` of type `T` with additional bytes on top of + * sizeof(T). Resizing is only useful with trailing inlined storage, see e.g. + * `MakeGarbageCollected(AllocationHandle&, AdditionalBytes)`. + * + * `Resize()` performs growing or shrinking as needed and may skip the operation + * for internal reasons, see return value. + * + * It is up to the embedder to guarantee that in case of shrinking a larger + * object down, the reclaimed area is not used anymore. Any subsequent use + * results in a use-after-free. + * + * The `object` must be live when calling `Resize()`. + * + * \param object Reference to an object that is of type `GarbageCollected` and + * should be resized. + * \param additional_bytes Bytes in addition to sizeof(T) that the object should + * provide. + * \returns true when the operation was successful and the result can be relied + * on, and false otherwise. + */ +template +bool Resize(T& object, AdditionalBytes additional_bytes) { + static_assert(IsGarbageCollectedTypeV, + "Object must be of type GarbageCollected."); + return internal::Resize(&object, sizeof(T) + additional_bytes.value); +} + +} // namespace subtle +} // namespace cppgc + +#endif // INCLUDE_CPPGC_EXPLICIT_MANAGEMENT_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/garbage-collected.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/garbage-collected.h new file mode 100644 index 0000000000..a3839e1baa --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/garbage-collected.h @@ -0,0 +1,117 @@ +// 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_CPPGC_GARBAGE_COLLECTED_H_ +#define INCLUDE_CPPGC_GARBAGE_COLLECTED_H_ + +#include + +#include "cppgc/internal/api-constants.h" +#include "cppgc/platform.h" +#include "cppgc/trace-trait.h" +#include "cppgc/type-traits.h" + +namespace cppgc { + +class Visitor; + +namespace internal { + +class GarbageCollectedBase { + public: + // Must use MakeGarbageCollected. + void* operator new(size_t) = delete; + void* operator new[](size_t) = delete; + // The garbage collector is taking care of reclaiming the object. Also, + // virtual destructor requires an unambiguous, accessible 'operator delete'. + void operator delete(void*) { +#ifdef V8_ENABLE_CHECKS + internal::Abort(); +#endif // V8_ENABLE_CHECKS + } + void operator delete[](void*) = delete; + + protected: + GarbageCollectedBase() = default; +}; + +} // namespace internal + +/** + * Base class for managed objects. Only descendent types of `GarbageCollected` + * can be constructed using `MakeGarbageCollected()`. Must be inherited from as + * left-most base class. + * + * Types inheriting from GarbageCollected must provide a method of + * signature `void Trace(cppgc::Visitor*) const` that dispatchs all managed + * pointers to the visitor and delegates to garbage-collected base classes. + * The method must be virtual if the type is not directly a child of + * GarbageCollected and marked as final. + * + * \code + * // Example using final class. + * class FinalType final : public GarbageCollected { + * public: + * void Trace(cppgc::Visitor* visitor) const { + * // Dispatch using visitor->Trace(...); + * } + * }; + * + * // Example using non-final base class. + * class NonFinalBase : public GarbageCollected { + * public: + * virtual void Trace(cppgc::Visitor*) const {} + * }; + * + * class FinalChild final : public NonFinalBase { + * public: + * void Trace(cppgc::Visitor* visitor) const final { + * // Dispatch using visitor->Trace(...); + * NonFinalBase::Trace(visitor); + * } + * }; + * \endcode + */ +template +class GarbageCollected : public internal::GarbageCollectedBase { + public: + using IsGarbageCollectedTypeMarker = void; + using ParentMostGarbageCollectedType = T; + + protected: + GarbageCollected() = default; +}; + +/** + * Base class for managed mixin objects. Such objects cannot be constructed + * directly but must be mixed into the inheritance hierarchy of a + * GarbageCollected object. + * + * Types inheriting from GarbageCollectedMixin must override a virtual method + * of signature `void Trace(cppgc::Visitor*) const` that dispatchs all managed + * pointers to the visitor and delegates to base classes. + * + * \code + * class Mixin : public GarbageCollectedMixin { + * public: + * void Trace(cppgc::Visitor* visitor) const override { + * // Dispatch using visitor->Trace(...); + * } + * }; + * \endcode + */ +class GarbageCollectedMixin : public internal::GarbageCollectedBase { + public: + using IsGarbageCollectedMixinTypeMarker = void; + + /** + * This Trace method must be overriden by objects inheriting from + * GarbageCollectedMixin. + */ + virtual void Trace(cppgc::Visitor*) const {} +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_GARBAGE_COLLECTED_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap-consistency.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap-consistency.h new file mode 100644 index 0000000000..8e603d5d8a --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap-consistency.h @@ -0,0 +1,253 @@ +// 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_CPPGC_HEAP_CONSISTENCY_H_ +#define INCLUDE_CPPGC_HEAP_CONSISTENCY_H_ + +#include + +#include "cppgc/internal/write-barrier.h" +#include "cppgc/macros.h" +#include "cppgc/trace-trait.h" +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +class HeapHandle; + +namespace subtle { + +/** + * **DO NOT USE: Use the appropriate managed types.** + * + * Consistency helpers that aid in maintaining a consistent internal state of + * the garbage collector. + */ +class HeapConsistency final { + public: + using WriteBarrierParams = internal::WriteBarrier::Params; + using WriteBarrierType = internal::WriteBarrier::Type; + + /** + * Gets the required write barrier type for a specific write. + * + * \param slot Slot containing the pointer to the object. The slot itself + * must reside in an object that has been allocated using + * `MakeGarbageCollected()`. + * \param value The pointer to the object. May be an interior pointer to an + * interface of the actual object. + * \param params Parameters that may be used for actual write barrier calls. + * Only filled if return value indicates that a write barrier is needed. The + * contents of the `params` are an implementation detail. + * \returns whether a write barrier is needed and which barrier to invoke. + */ + static V8_INLINE WriteBarrierType GetWriteBarrierType( + const void* slot, const void* value, WriteBarrierParams& params) { + return internal::WriteBarrier::GetWriteBarrierType(slot, value, params); + } + + /** + * Gets the required write barrier type for a specific write. + * + * \param slot Slot to some part of an object. The object must not necessarily + have been allocated using `MakeGarbageCollected()` but can also live + off-heap or on stack. + * \param params Parameters that may be used for actual write barrier calls. + * Only filled if return value indicates that a write barrier is needed. The + * contents of the `params` are an implementation detail. + * \param callback Callback returning the corresponding heap handle. The + * callback is only invoked if the heap cannot otherwise be figured out. The + * callback must not allocate. + * \returns whether a write barrier is needed and which barrier to invoke. + */ + template + static V8_INLINE WriteBarrierType + GetWriteBarrierType(const void* slot, WriteBarrierParams& params, + HeapHandleCallback callback) { + return internal::WriteBarrier::GetWriteBarrierType(slot, params, callback); + } + + /** + * Gets the required write barrier type for a specific write. + * This version is meant to be used in conjunction with with a marking write + * barrier barrier which doesn't consider the slot. + * + * \param value The pointer to the object. May be an interior pointer to an + * interface of the actual object. + * \param params Parameters that may be used for actual write barrier calls. + * Only filled if return value indicates that a write barrier is needed. The + * contents of the `params` are an implementation detail. + * \returns whether a write barrier is needed and which barrier to invoke. + */ + static V8_INLINE WriteBarrierType + GetWriteBarrierType(const void* value, WriteBarrierParams& params) { + return internal::WriteBarrier::GetWriteBarrierType(value, params); + } + + /** + * Conservative Dijkstra-style write barrier that processes an object if it + * has not yet been processed. + * + * \param params The parameters retrieved from `GetWriteBarrierType()`. + * \param object The pointer to the object. May be an interior pointer to a + * an interface of the actual object. + */ + static V8_INLINE void DijkstraWriteBarrier(const WriteBarrierParams& params, + const void* object) { + internal::WriteBarrier::DijkstraMarkingBarrier(params, object); + } + + /** + * Conservative Dijkstra-style write barrier that processes a range of + * elements if they have not yet been processed. + * + * \param params The parameters retrieved from `GetWriteBarrierType()`. + * \param first_element Pointer to the first element that should be processed. + * The slot itself must reside in an object that has been allocated using + * `MakeGarbageCollected()`. + * \param element_size Size of the element in bytes. + * \param number_of_elements Number of elements that should be processed, + * starting with `first_element`. + * \param trace_callback The trace callback that should be invoked for each + * element if necessary. + */ + static V8_INLINE void DijkstraWriteBarrierRange( + const WriteBarrierParams& params, const void* first_element, + size_t element_size, size_t number_of_elements, + TraceCallback trace_callback) { + internal::WriteBarrier::DijkstraMarkingBarrierRange( + params, first_element, element_size, number_of_elements, + trace_callback); + } + + /** + * Steele-style write barrier that re-processes an object if it has already + * been processed. + * + * \param params The parameters retrieved from `GetWriteBarrierType()`. + * \param object The pointer to the object which must point to an object that + * has been allocated using `MakeGarbageCollected()`. Interior pointers are + * not supported. + */ + static V8_INLINE void SteeleWriteBarrier(const WriteBarrierParams& params, + const void* object) { + internal::WriteBarrier::SteeleMarkingBarrier(params, object); + } + + /** + * Generational barrier for maintaining consistency when running with multiple + * generations. + * + * \param params The parameters retrieved from `GetWriteBarrierType()`. + * \param slot Slot containing the pointer to the object. The slot itself + * must reside in an object that has been allocated using + * `MakeGarbageCollected()`. + */ + static V8_INLINE void GenerationalBarrier(const WriteBarrierParams& params, + const void* slot) { + internal::WriteBarrier::GenerationalBarrier(params, slot); + } + + private: + HeapConsistency() = delete; +}; + +/** + * Disallows garbage collection finalizations. Any garbage collection triggers + * result in a crash when in this scope. + * + * Note that the garbage collector already covers paths that can lead to garbage + * collections, so user code does not require checking + * `IsGarbageCollectionAllowed()` before allocations. + */ +class V8_EXPORT V8_NODISCARD DisallowGarbageCollectionScope final { + CPPGC_STACK_ALLOCATED(); + + public: + /** + * \returns whether garbage collections are currently allowed. + */ + static bool IsGarbageCollectionAllowed(HeapHandle& heap_handle); + + /** + * Enters a disallow garbage collection scope. Must be paired with `Leave()`. + * Prefer a scope instance of `DisallowGarbageCollectionScope`. + * + * \param heap_handle The corresponding heap. + */ + static void Enter(HeapHandle& heap_handle); + + /** + * Leaves a disallow garbage collection scope. Must be paired with `Enter()`. + * Prefer a scope instance of `DisallowGarbageCollectionScope`. + * + * \param heap_handle The corresponding heap. + */ + static void Leave(HeapHandle& heap_handle); + + /** + * Constructs a scoped object that automatically enters and leaves a disallow + * garbage collection scope based on its lifetime. + * + * \param heap_handle The corresponding heap. + */ + explicit DisallowGarbageCollectionScope(HeapHandle& heap_handle); + ~DisallowGarbageCollectionScope(); + + DisallowGarbageCollectionScope(const DisallowGarbageCollectionScope&) = + delete; + DisallowGarbageCollectionScope& operator=( + const DisallowGarbageCollectionScope&) = delete; + + private: + HeapHandle& heap_handle_; +}; + +/** + * Avoids invoking garbage collection finalizations. Already running garbage + * collection phase are unaffected by this scope. + * + * Should only be used temporarily as the scope has an impact on memory usage + * and follow up garbage collections. + */ +class V8_EXPORT V8_NODISCARD NoGarbageCollectionScope final { + CPPGC_STACK_ALLOCATED(); + + public: + /** + * Enters a no garbage collection scope. Must be paired with `Leave()`. Prefer + * a scope instance of `NoGarbageCollectionScope`. + * + * \param heap_handle The corresponding heap. + */ + static void Enter(HeapHandle& heap_handle); + + /** + * Leaves a no garbage collection scope. Must be paired with `Enter()`. Prefer + * a scope instance of `NoGarbageCollectionScope`. + * + * \param heap_handle The corresponding heap. + */ + static void Leave(HeapHandle& heap_handle); + + /** + * Constructs a scoped object that automatically enters and leaves a no + * garbage collection scope based on its lifetime. + * + * \param heap_handle The corresponding heap. + */ + explicit NoGarbageCollectionScope(HeapHandle& heap_handle); + ~NoGarbageCollectionScope(); + + NoGarbageCollectionScope(const NoGarbageCollectionScope&) = delete; + NoGarbageCollectionScope& operator=(const NoGarbageCollectionScope&) = delete; + + private: + HeapHandle& heap_handle_; +}; + +} // namespace subtle +} // namespace cppgc + +#endif // INCLUDE_CPPGC_HEAP_CONSISTENCY_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap-state.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap-state.h new file mode 100644 index 0000000000..3fd6b54a8a --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap-state.h @@ -0,0 +1,70 @@ +// 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_CPPGC_HEAP_STATE_H_ +#define INCLUDE_CPPGC_HEAP_STATE_H_ + +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +class HeapHandle; + +namespace subtle { + +/** + * Helpers to peek into heap-internal state. + */ +class V8_EXPORT HeapState final { + public: + /** + * Returns whether the garbage collector is marking. This API is experimental + * and is expected to be removed in future. + * + * \param heap_handle The corresponding heap. + * \returns true if the garbage collector is currently marking, and false + * otherwise. + */ + static bool IsMarking(const HeapHandle& heap_handle); + + /* + * Returns whether the garbage collector is sweeping. This API is experimental + * and is expected to be removed in future. + * + * \param heap_handle The corresponding heap. + * \returns true if the garbage collector is currently sweeping, and false + * otherwise. + */ + static bool IsSweeping(const HeapHandle& heap_handle); + + /** + * Returns whether the garbage collector is in the atomic pause, i.e., the + * mutator is stopped from running. This API is experimental and is expected + * to be removed in future. + * + * \param heap_handle The corresponding heap. + * \returns true if the garbage collector is currently in the atomic pause, + * and false otherwise. + */ + static bool IsInAtomicPause(const HeapHandle& heap_handle); + + /** + * Returns whether the last garbage collection was finalized conservatively + * (i.e., with a non-empty stack). This API is experimental and is expected to + * be removed in future. + * + * \param heap_handle The corresponding heap. + * \returns true if the last garbage collection was finalized conservatively, + * and false otherwise. + */ + static bool PreviousGCWasConservative(const HeapHandle& heap_handle); + + private: + HeapState() = delete; +}; + +} // namespace subtle +} // namespace cppgc + +#endif // INCLUDE_CPPGC_HEAP_STATE_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap-statistics.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap-statistics.h new file mode 100644 index 0000000000..8e626596e5 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap-statistics.h @@ -0,0 +1,120 @@ +// 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_CPPGC_HEAP_STATISTICS_H_ +#define INCLUDE_CPPGC_HEAP_STATISTICS_H_ + +#include +#include +#include +#include + +namespace cppgc { + +/** + * `HeapStatistics` contains memory consumption and utilization statistics for a + * cppgc heap. + */ +struct HeapStatistics final { + /** + * Specifies the detail level of the heap statistics. Brief statistics contain + * only the top-level allocated and used memory statistics for the entire + * heap. Detailed statistics also contain a break down per space and page, as + * well as freelist statistics and object type histograms. Note that used + * memory reported by brief statistics and detailed statistics might differ + * slightly. + */ + enum DetailLevel : uint8_t { + kBrief, + kDetailed, + }; + + /** + * Object statistics for a single type. + */ + struct ObjectStatsEntry { + /** + * Number of allocated bytes. + */ + size_t allocated_bytes; + /** + * Number of allocated objects. + */ + size_t object_count; + }; + + /** + * Page granularity statistics. For each page the statistics record the + * allocated memory size and overall used memory size for the page. + */ + struct PageStatistics { + /** Overall committed amount of memory for the page. */ + size_t committed_size_bytes = 0; + /** Resident amount of memory held by the page. */ + size_t resident_size_bytes = 0; + /** Amount of memory actually used on the page. */ + size_t used_size_bytes = 0; + /** Statistics for object allocated on the page. Filled only when + * NameProvider::HideInternalNames() is false. */ + std::vector object_statistics; + }; + + /** + * Statistics of the freelist (used only in non-large object spaces). For + * each bucket in the freelist the statistics record the bucket size, the + * number of freelist entries in the bucket, and the overall allocated memory + * consumed by these freelist entries. + */ + struct FreeListStatistics { + /** bucket sizes in the freelist. */ + std::vector bucket_size; + /** number of freelist entries per bucket. */ + std::vector free_count; + /** memory size consumed by freelist entries per size. */ + std::vector free_size; + }; + + /** + * Space granularity statistics. For each space the statistics record the + * space name, the amount of allocated memory and overall used memory for the + * space. The statistics also contain statistics for each of the space's + * pages, its freelist and the objects allocated on the space. + */ + struct SpaceStatistics { + /** The space name */ + std::string name; + /** Overall committed amount of memory for the heap. */ + size_t committed_size_bytes = 0; + /** Resident amount of memory held by the heap. */ + size_t resident_size_bytes = 0; + /** Amount of memory actually used on the space. */ + size_t used_size_bytes = 0; + /** Statistics for each of the pages in the space. */ + std::vector page_stats; + /** Statistics for the freelist of the space. */ + FreeListStatistics free_list_stats; + }; + + /** Overall committed amount of memory for the heap. */ + size_t committed_size_bytes = 0; + /** Resident amount of memory help by the heap. */ + size_t resident_size_bytes = 0; + /** Amount of memory actually used on the heap. */ + size_t used_size_bytes = 0; + /** Detail level of this HeapStatistics. */ + DetailLevel detail_level; + + /** Statistics for each of the spaces in the heap. Filled only when + * `detail_level` is `DetailLevel::kDetailed`. */ + std::vector space_stats; + + /** + * Vector of `cppgc::GarbageCollected` type names. + */ + std::vector type_names; +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_HEAP_STATISTICS_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap.h new file mode 100644 index 0000000000..136c4fb44d --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/heap.h @@ -0,0 +1,201 @@ +// 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_CPPGC_HEAP_H_ +#define INCLUDE_CPPGC_HEAP_H_ + +#include +#include +#include +#include + +#include "cppgc/common.h" +#include "cppgc/custom-space.h" +#include "cppgc/platform.h" +#include "v8config.h" // NOLINT(build/include_directory) + +/** + * cppgc - A C++ garbage collection library. + */ +namespace cppgc { + +class AllocationHandle; + +/** + * Implementation details of cppgc. Those details are considered internal and + * may change at any point in time without notice. Users should never rely on + * the contents of this namespace. + */ +namespace internal { +class Heap; +} // namespace internal + +/** + * Used for additional heap APIs. + */ +class HeapHandle; + +class V8_EXPORT Heap { + public: + /** + * Specifies the stack state the embedder is in. + */ + using StackState = EmbedderStackState; + + /** + * Specifies whether conservative stack scanning is supported. + */ + enum class StackSupport : uint8_t { + /** + * Conservative stack scan is supported. + */ + kSupportsConservativeStackScan, + /** + * Conservative stack scan is not supported. Embedders may use this option + * when using custom infrastructure that is unsupported by the library. + */ + kNoConservativeStackScan, + }; + + /** + * Specifies supported marking types + */ + enum class MarkingType : uint8_t { + /** + * Atomic stop-the-world marking. This option does not require any write + * barriers but is the most intrusive in terms of jank. + */ + kAtomic, + /** + * Incremental marking, i.e. interleave marking is the rest of the + * application on the same thread. + */ + kIncremental, + /** + * Incremental and concurrent marking. + */ + kIncrementalAndConcurrent + }; + + /** + * Specifies supported sweeping types + */ + enum class SweepingType : uint8_t { + /** + * Atomic stop-the-world sweeping. All of sweeping is performed at once. + */ + kAtomic, + /** + * Incremental and concurrent sweeping. Sweeping is split and interleaved + * with the rest of the application. + */ + kIncrementalAndConcurrent + }; + + /** + * Constraints for a Heap setup. + */ + struct ResourceConstraints { + /** + * Allows the heap to grow to some initial size in bytes before triggering + * garbage collections. This is useful when it is known that applications + * need a certain minimum heap to run to avoid repeatedly invoking the + * garbage collector when growing the heap. + */ + size_t initial_heap_size_bytes = 0; + }; + + /** + * Options specifying Heap properties (e.g. custom spaces) when initializing a + * heap through `Heap::Create()`. + */ + struct HeapOptions { + /** + * Creates reasonable defaults for instantiating a Heap. + * + * \returns the HeapOptions that can be passed to `Heap::Create()`. + */ + static HeapOptions Default() { return {}; } + + /** + * Custom spaces added to heap are required to have indices forming a + * numbered sequence starting at 0, i.e., their `kSpaceIndex` must + * correspond to the index they reside in the vector. + */ + std::vector> custom_spaces; + + /** + * Specifies whether conservative stack scan is supported. When conservative + * stack scan is not supported, the collector may try to invoke + * garbage collections using non-nestable task, which are guaranteed to have + * no interesting stack, through the provided Platform. If such tasks are + * not supported by the Platform, the embedder must take care of invoking + * the GC through `ForceGarbageCollectionSlow()`. + */ + StackSupport stack_support = StackSupport::kSupportsConservativeStackScan; + + /** + * Specifies which types of marking are supported by the heap. + */ + MarkingType marking_support = MarkingType::kIncrementalAndConcurrent; + + /** + * Specifies which types of sweeping are supported by the heap. + */ + SweepingType sweeping_support = SweepingType::kIncrementalAndConcurrent; + + /** + * Resource constraints specifying various properties that the internal + * GC scheduler follows. + */ + ResourceConstraints resource_constraints; + }; + + /** + * Creates a new heap that can be used for object allocation. + * + * \param platform implemented and provided by the embedder. + * \param options HeapOptions specifying various properties for the Heap. + * \returns a new Heap instance. + */ + static std::unique_ptr Create( + std::shared_ptr platform, + HeapOptions options = HeapOptions::Default()); + + virtual ~Heap() = default; + + /** + * Forces garbage collection. + * + * \param source String specifying the source (or caller) triggering a + * forced garbage collection. + * \param reason String specifying the reason for the forced garbage + * collection. + * \param stack_state The embedder stack state, see StackState. + */ + void ForceGarbageCollectionSlow( + const char* source, const char* reason, + StackState stack_state = StackState::kMayContainHeapPointers); + + /** + * \returns the opaque handle for allocating objects using + * `MakeGarbageCollected()`. + */ + 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 `Heap` is alive. + */ + HeapHandle& GetHeapHandle(); + + private: + Heap() = default; + + friend class internal::Heap; +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_HEAP_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/liveness-broker.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/liveness-broker.h new file mode 100644 index 0000000000..c94eef0d4a --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/liveness-broker.h @@ -0,0 +1,77 @@ +// 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_CPPGC_LIVENESS_BROKER_H_ +#define INCLUDE_CPPGC_LIVENESS_BROKER_H_ + +#include "cppgc/heap.h" +#include "cppgc/member.h" +#include "cppgc/trace-trait.h" +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +namespace internal { +class LivenessBrokerFactory; +} // namespace internal + +/** + * The broker is passed to weak callbacks to allow (temporarily) querying + * the liveness state of an object. References to non-live objects must be + * cleared when `IsHeapObjectAlive()` returns false. + * + * \code + * class GCedWithCustomWeakCallback final + * : public GarbageCollected { + * public: + * UntracedMember bar; + * + * void CustomWeakCallbackMethod(const LivenessBroker& broker) { + * if (!broker.IsHeapObjectAlive(bar)) + * bar = nullptr; + * } + * + * void Trace(cppgc::Visitor* visitor) const { + * visitor->RegisterWeakCallbackMethod< + * GCedWithCustomWeakCallback, + * &GCedWithCustomWeakCallback::CustomWeakCallbackMethod>(this); + * } + * }; + * \endcode + */ +class V8_EXPORT LivenessBroker final { + public: + template + bool IsHeapObjectAlive(const T* object) const { + // nullptr objects are considered alive to allow weakness to be used from + // stack while running into a conservative GC. Treating nullptr as dead + // would mean that e.g. custom collectins could not be strongified on stack. + return !object || + IsHeapObjectAliveImpl( + TraceTrait::GetTraceDescriptor(object).base_object_payload); + } + + template + bool IsHeapObjectAlive(const WeakMember& weak_member) const { + return (weak_member != kSentinelPointer) && + IsHeapObjectAlive(weak_member.Get()); + } + + template + bool IsHeapObjectAlive(const UntracedMember& untraced_member) const { + return (untraced_member != kSentinelPointer) && + IsHeapObjectAlive(untraced_member.Get()); + } + + private: + LivenessBroker() = default; + + bool IsHeapObjectAliveImpl(const void*) const; + + friend class internal::LivenessBrokerFactory; +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_LIVENESS_BROKER_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/macros.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/macros.h new file mode 100644 index 0000000000..030f397e3d --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/macros.h @@ -0,0 +1,26 @@ +// 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_CPPGC_MACROS_H_ +#define INCLUDE_CPPGC_MACROS_H_ + +#include + +#include "cppgc/internal/compiler-specific.h" + +namespace cppgc { + +// Use if the object is only stack allocated. +#define CPPGC_STACK_ALLOCATED() \ + public: \ + using IsStackAllocatedTypeMarker CPPGC_UNUSED = int; \ + \ + private: \ + void* operator new(size_t) = delete; \ + void* operator new(size_t, void*) = delete; \ + static_assert(true, "Force semicolon.") + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_MACROS_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/member.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/member.h new file mode 100644 index 0000000000..38105b8e43 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/member.h @@ -0,0 +1,288 @@ +// 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_CPPGC_MEMBER_H_ +#define INCLUDE_CPPGC_MEMBER_H_ + +#include +#include +#include + +#include "cppgc/internal/pointer-policies.h" +#include "cppgc/sentinel-pointer.h" +#include "cppgc/type-traits.h" +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +class Visitor; + +namespace internal { + +// MemberBase always refers to the object as const object and defers to +// BasicMember on casting to the right type as needed. +class MemberBase { + protected: + struct AtomicInitializerTag {}; + + MemberBase() = default; + explicit MemberBase(const void* value) : raw_(value) {} + MemberBase(const void* value, AtomicInitializerTag) { SetRawAtomic(value); } + + const void** GetRawSlot() const { return &raw_; } + const void* GetRaw() const { return raw_; } + void SetRaw(void* value) { raw_ = value; } + + const void* GetRawAtomic() const { + return reinterpret_cast*>(&raw_)->load( + std::memory_order_relaxed); + } + void SetRawAtomic(const void* value) { + reinterpret_cast*>(&raw_)->store( + value, std::memory_order_relaxed); + } + + void ClearFromGC() const { raw_ = nullptr; } + + private: + mutable const void* raw_ = nullptr; +}; + +// The basic class from which all Member classes are 'generated'. +template +class BasicMember final : private MemberBase, private CheckingPolicy { + public: + using PointeeType = T; + + constexpr BasicMember() = default; + constexpr BasicMember(std::nullptr_t) {} // NOLINT + BasicMember(SentinelPointer s) : MemberBase(s) {} // NOLINT + BasicMember(T* raw) : MemberBase(raw) { // NOLINT + InitializingWriteBarrier(); + this->CheckPointer(Get()); + } + BasicMember(T& raw) : BasicMember(&raw) {} // NOLINT + // Atomic ctor. Using the AtomicInitializerTag forces BasicMember to + // initialize using atomic assignments. This is required for preventing + // data races with concurrent marking. + using AtomicInitializerTag = MemberBase::AtomicInitializerTag; + BasicMember(std::nullptr_t, AtomicInitializerTag atomic) + : MemberBase(nullptr, atomic) {} + BasicMember(SentinelPointer s, AtomicInitializerTag atomic) + : MemberBase(s, atomic) {} + BasicMember(T* raw, AtomicInitializerTag atomic) : MemberBase(raw, atomic) { + InitializingWriteBarrier(); + this->CheckPointer(Get()); + } + BasicMember(T& raw, AtomicInitializerTag atomic) + : BasicMember(&raw, atomic) {} + // Copy ctor. + BasicMember(const BasicMember& other) : BasicMember(other.Get()) {} + // Allow heterogeneous construction. + template ::value>> + BasicMember( // NOLINT + const BasicMember& other) + : BasicMember(other.Get()) {} + // Move ctor. + BasicMember(BasicMember&& other) noexcept : BasicMember(other.Get()) { + other.Clear(); + } + // Allow heterogeneous move construction. + template ::value>> + BasicMember(BasicMember&& other) noexcept + : BasicMember(other.Get()) { + other.Clear(); + } + // Construction from Persistent. + template ::value>> + BasicMember(const BasicPersistent& p) + : BasicMember(p.Get()) {} + + // Copy assignment. + BasicMember& operator=(const BasicMember& other) { + return operator=(other.Get()); + } + // Allow heterogeneous copy assignment. + template ::value>> + BasicMember& operator=( + const BasicMember& other) { + return operator=(other.Get()); + } + // Move assignment. + BasicMember& operator=(BasicMember&& other) noexcept { + operator=(other.Get()); + other.Clear(); + return *this; + } + // Heterogeneous move assignment. + template ::value>> + BasicMember& operator=(BasicMember&& other) noexcept { + operator=(other.Get()); + other.Clear(); + return *this; + } + // Assignment from Persistent. + template ::value>> + BasicMember& operator=( + const BasicPersistent& + other) { + return operator=(other.Get()); + } + BasicMember& operator=(T* other) { + SetRawAtomic(other); + AssigningWriteBarrier(); + this->CheckPointer(Get()); + return *this; + } + BasicMember& operator=(std::nullptr_t) { + Clear(); + return *this; + } + BasicMember& operator=(SentinelPointer s) { + SetRawAtomic(s); + return *this; + } + + template + void Swap(BasicMember& other) { + T* tmp = Get(); + *this = other; + other = tmp; + } + + explicit operator bool() const { return Get(); } + operator T*() const { return Get(); } + T* operator->() const { return Get(); } + T& operator*() const { return *Get(); } + + // CFI cast exemption to allow passing SentinelPointer through T* and support + // heterogeneous assignments between different Member and Persistent handles + // based on their actual types. + V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const { + // Executed by the mutator, hence non atomic load. + // + // The const_cast below removes the constness from MemberBase storage. The + // following static_cast re-adds any constness if specified through the + // user-visible template parameter T. + return static_cast(const_cast(MemberBase::GetRaw())); + } + + void Clear() { SetRawAtomic(nullptr); } + + T* Release() { + T* result = Get(); + Clear(); + return result; + } + + const T** GetSlotForTesting() const { + return reinterpret_cast(GetRawSlot()); + } + + private: + const T* GetRawAtomic() const { + return static_cast(MemberBase::GetRawAtomic()); + } + + void InitializingWriteBarrier() const { + WriteBarrierPolicy::InitializingBarrier(GetRawSlot(), GetRaw()); + } + void AssigningWriteBarrier() const { + WriteBarrierPolicy::AssigningBarrier(GetRawSlot(), GetRaw()); + } + + void ClearFromGC() const { MemberBase::ClearFromGC(); } + + T* GetFromGC() const { return Get(); } + + friend class cppgc::Visitor; + template + friend struct cppgc::TraceTrait; +}; + +template +bool operator==(const BasicMember& member1, + const BasicMember& member2) { + return member1.Get() == member2.Get(); +} + +template +bool operator!=(const BasicMember& member1, + const BasicMember& member2) { + return !(member1 == member2); +} + +template +struct IsWeak< + internal::BasicMember> + : std::true_type {}; + +} // namespace internal + +/** + * Members are used in classes to contain strong pointers to other garbage + * collected objects. All Member fields of a class must be traced in the class' + * trace method. + */ +template +using Member = internal::BasicMember; + +/** + * WeakMember is similar to Member in that it is used to point to other garbage + * collected objects. However instead of creating a strong pointer to the + * object, the WeakMember creates a weak pointer, which does not keep the + * pointee alive. Hence if all pointers to to a heap allocated object are weak + * the object will be garbage collected. At the time of GC the weak pointers + * will automatically be set to null. + */ +template +using WeakMember = internal::BasicMember; + +/** + * UntracedMember is a pointer to an on-heap object that is not traced for some + * reason. Do not use this unless you know what you are doing. Keeping raw + * pointers to on-heap objects is prohibited unless used from stack. Pointee + * must be kept alive through other means. + */ +template +using UntracedMember = internal::BasicMember; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_MEMBER_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/name-provider.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/name-provider.h new file mode 100644 index 0000000000..224dd4b5d6 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/name-provider.h @@ -0,0 +1,65 @@ +// 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_CPPGC_NAME_PROVIDER_H_ +#define INCLUDE_CPPGC_NAME_PROVIDER_H_ + +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +/** + * NameProvider allows for providing a human-readable name for garbage-collected + * objects. + * + * There's two cases of names to distinguish: + * a. Explicitly specified names via using NameProvider. Such names are always + * preserved in the system. + * b. Internal names that Oilpan infers from a C++ type on the class hierarchy + * of the object. This is not necessarily the type of the actually + * instantiated object. + * + * Depending on the build configuration, Oilpan may hide names, i.e., represent + * them with kHiddenName, of case b. to avoid exposing internal details. + */ +class V8_EXPORT NameProvider { + public: + /** + * Name that is used when hiding internals. + */ + static constexpr const char kHiddenName[] = "InternalNode"; + + /** + * Name that is used in case compiler support is missing for composing a name + * from C++ types. + */ + static constexpr const char kNoNameDeducible[] = ""; + + /** + * Indicating whether internal names are hidden or not. + * + * @returns true if C++ names should be hidden and represented by kHiddenName. + */ + static constexpr bool HideInternalNames() { +#if CPPGC_SUPPORTS_OBJECT_NAMES + return false; +#else // !CPPGC_SUPPORTS_OBJECT_NAMES + return true; +#endif // !CPPGC_SUPPORTS_OBJECT_NAMES + } + + virtual ~NameProvider() = default; + + /** + * Specifies a name for the garbage-collected object. Such names will never + * be hidden, as they are explicitly specified by the user of this API. + * + * @returns a human readable name for the object. + */ + virtual const char* GetHumanReadableName() const = 0; +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_NAME_PROVIDER_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/object-size-trait.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/object-size-trait.h new file mode 100644 index 0000000000..35795596d3 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/object-size-trait.h @@ -0,0 +1,58 @@ +// 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_CPPGC_OBJECT_SIZE_TRAIT_H_ +#define INCLUDE_CPPGC_OBJECT_SIZE_TRAIT_H_ + +#include + +#include "cppgc/type-traits.h" +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +namespace internal { + +struct V8_EXPORT BaseObjectSizeTrait { + protected: + static size_t GetObjectSizeForGarbageCollected(const void*); + static size_t GetObjectSizeForGarbageCollectedMixin(const void*); +}; + +} // namespace internal + +namespace subtle { + +/** + * Trait specifying how to get the size of an object that was allocated using + * `MakeGarbageCollected()`. Also supports querying the size with an inner + * pointer to a mixin. + */ +template > +struct ObjectSizeTrait; + +template +struct ObjectSizeTrait : cppgc::internal::BaseObjectSizeTrait { + static_assert(sizeof(T), "T must be fully defined"); + static_assert(IsGarbageCollectedTypeV, + "T must be of type GarbageCollected or GarbageCollectedMixin"); + + static size_t GetSize(const T& object) { + return GetObjectSizeForGarbageCollected(&object); + } +}; + +template +struct ObjectSizeTrait : cppgc::internal::BaseObjectSizeTrait { + static_assert(sizeof(T), "T must be fully defined"); + + static size_t GetSize(const T& object) { + return GetObjectSizeForGarbageCollectedMixin(&object); + } +}; + +} // namespace subtle +} // namespace cppgc + +#endif // INCLUDE_CPPGC_OBJECT_SIZE_TRAIT_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/persistent.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/persistent.h new file mode 100644 index 0000000000..b83a464576 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/persistent.h @@ -0,0 +1,371 @@ +// 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_CPPGC_PERSISTENT_H_ +#define INCLUDE_CPPGC_PERSISTENT_H_ + +#include + +#include "cppgc/internal/persistent-node.h" +#include "cppgc/internal/pointer-policies.h" +#include "cppgc/sentinel-pointer.h" +#include "cppgc/source-location.h" +#include "cppgc/type-traits.h" +#include "cppgc/visitor.h" +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +class Visitor; + +namespace internal { + +// PersistentBase always refers to the object as const object and defers to +// BasicPersistent on casting to the right type as needed. +class PersistentBase { + protected: + PersistentBase() = default; + explicit PersistentBase(const void* raw) : raw_(raw) {} + + const void* GetValue() const { return raw_; } + void SetValue(const void* value) { raw_ = value; } + + PersistentNode* GetNode() const { return node_; } + void SetNode(PersistentNode* node) { node_ = node; } + + // Performs a shallow clear which assumes that internal persistent nodes are + // destroyed elsewhere. + void ClearFromGC() const { + raw_ = nullptr; + node_ = nullptr; + } + + protected: + mutable const void* raw_ = nullptr; + mutable PersistentNode* node_ = nullptr; + + friend class PersistentRegion; +}; + +// The basic class from which all Persistent classes are generated. +template +class BasicPersistent final : public PersistentBase, + public LocationPolicy, + private WeaknessPolicy, + private CheckingPolicy { + public: + using typename WeaknessPolicy::IsStrongPersistent; + using PointeeType = T; + + // Null-state/sentinel constructors. + BasicPersistent( // NOLINT + const SourceLocation& loc = SourceLocation::Current()) + : LocationPolicy(loc) {} + + BasicPersistent(std::nullptr_t, // NOLINT + const SourceLocation& loc = SourceLocation::Current()) + : LocationPolicy(loc) {} + + BasicPersistent( // NOLINT + SentinelPointer s, const SourceLocation& loc = SourceLocation::Current()) + : PersistentBase(s), LocationPolicy(loc) {} + + // Raw value constructors. + BasicPersistent(T* raw, // NOLINT + const SourceLocation& loc = SourceLocation::Current()) + : PersistentBase(raw), LocationPolicy(loc) { + if (!IsValid()) return; + SetNode(WeaknessPolicy::GetPersistentRegion(GetValue()) + .AllocateNode(this, &BasicPersistent::Trace)); + this->CheckPointer(Get()); + } + + BasicPersistent(T& raw, // NOLINT + const SourceLocation& loc = SourceLocation::Current()) + : BasicPersistent(&raw, loc) {} + + // Copy ctor. + BasicPersistent(const BasicPersistent& other, + const SourceLocation& loc = SourceLocation::Current()) + : BasicPersistent(other.Get(), loc) {} + + // Heterogeneous ctor. + template ::value>> + BasicPersistent( + const BasicPersistent& other, + const SourceLocation& loc = SourceLocation::Current()) + : BasicPersistent(other.Get(), loc) {} + + // Move ctor. The heterogeneous move ctor is not supported since e.g. + // persistent can't reuse persistent node from weak persistent. + BasicPersistent( + BasicPersistent&& other, + const SourceLocation& loc = SourceLocation::Current()) noexcept + : PersistentBase(std::move(other)), LocationPolicy(std::move(other)) { + if (!IsValid()) return; + GetNode()->UpdateOwner(this); + other.SetValue(nullptr); + other.SetNode(nullptr); + this->CheckPointer(Get()); + } + + // Constructor from member. + template ::value>> + BasicPersistent(internal::BasicMember + member, + const SourceLocation& loc = SourceLocation::Current()) + : BasicPersistent(member.Get(), loc) {} + + ~BasicPersistent() { Clear(); } + + // Copy assignment. + BasicPersistent& operator=(const BasicPersistent& other) { + return operator=(other.Get()); + } + + template ::value>> + BasicPersistent& operator=( + const BasicPersistent& other) { + return operator=(other.Get()); + } + + // Move assignment. + BasicPersistent& operator=(BasicPersistent&& other) noexcept { + if (this == &other) return *this; + Clear(); + PersistentBase::operator=(std::move(other)); + LocationPolicy::operator=(std::move(other)); + if (!IsValid()) return *this; + GetNode()->UpdateOwner(this); + other.SetValue(nullptr); + other.SetNode(nullptr); + this->CheckPointer(Get()); + return *this; + } + + // Assignment from member. + template ::value>> + BasicPersistent& operator=( + internal::BasicMember + member) { + return operator=(member.Get()); + } + + BasicPersistent& operator=(T* other) { + Assign(other); + return *this; + } + + BasicPersistent& operator=(std::nullptr_t) { + Clear(); + return *this; + } + + BasicPersistent& operator=(SentinelPointer s) { + Assign(s); + return *this; + } + + explicit operator bool() const { return Get(); } + operator T*() const { return Get(); } + T* operator->() const { return Get(); } + T& operator*() const { return *Get(); } + + // CFI cast exemption to allow passing SentinelPointer through T* and support + // heterogeneous assignments between different Member and Persistent handles + // based on their actual types. + V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const { + // The const_cast below removes the constness from PersistentBase storage. + // The following static_cast re-adds any constness if specified through the + // user-visible template parameter T. + return static_cast(const_cast(GetValue())); + } + + void Clear() { + // Simplified version of `Assign()` to allow calling without a complete type + // `T`. + if (IsValid()) { + WeaknessPolicy::GetPersistentRegion(GetValue()).FreeNode(GetNode()); + SetNode(nullptr); + } + SetValue(nullptr); + } + + T* Release() { + T* result = Get(); + Clear(); + return result; + } + + template + BasicPersistent + To() const { + return BasicPersistent(static_cast(Get())); + } + + private: + static void Trace(Visitor* v, const void* ptr) { + const auto* persistent = static_cast(ptr); + v->TraceRoot(*persistent, persistent->Location()); + } + + bool IsValid() const { + // Ideally, handling kSentinelPointer would be done by the embedder. On the + // other hand, having Persistent aware of it is beneficial since no node + // gets wasted. + return GetValue() != nullptr && GetValue() != kSentinelPointer; + } + + void Assign(T* ptr) { + if (IsValid()) { + if (ptr && ptr != kSentinelPointer) { + // Simply assign the pointer reusing the existing node. + SetValue(ptr); + this->CheckPointer(ptr); + return; + } + WeaknessPolicy::GetPersistentRegion(GetValue()).FreeNode(GetNode()); + SetNode(nullptr); + } + SetValue(ptr); + if (!IsValid()) return; + SetNode(WeaknessPolicy::GetPersistentRegion(GetValue()) + .AllocateNode(this, &BasicPersistent::Trace)); + this->CheckPointer(Get()); + } + + void ClearFromGC() const { + if (IsValid()) { + WeaknessPolicy::GetPersistentRegion(GetValue()).FreeNode(GetNode()); + PersistentBase::ClearFromGC(); + } + } + + // Set Get() for details. + V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") + T* GetFromGC() const { + return static_cast(const_cast(GetValue())); + } + + friend class cppgc::Visitor; +}; + +template +bool operator==(const BasicPersistent& p1, + const BasicPersistent& p2) { + return p1.Get() == p2.Get(); +} + +template +bool operator!=(const BasicPersistent& p1, + const BasicPersistent& p2) { + return !(p1 == p2); +} + +template +bool operator==(const BasicPersistent& p, + BasicMember + m) { + return p.Get() == m.Get(); +} + +template +bool operator!=(const BasicPersistent& p, + BasicMember + m) { + return !(p == m); +} + +template +bool operator==(BasicMember + m, + const BasicPersistent& p) { + return m.Get() == p.Get(); +} + +template +bool operator!=(BasicMember + m, + const BasicPersistent& p) { + return !(m == p); +} + +template +struct IsWeak> : std::true_type {}; +} // namespace internal + +/** + * Persistent is a way to create a strong pointer from an off-heap object to + * another on-heap object. As long as the Persistent handle is alive the GC will + * keep the object pointed to alive. The Persistent handle is always a GC root + * from the point of view of the GC. Persistent must be constructed and + * destructed in the same thread. + */ +template +using Persistent = + internal::BasicPersistent; + +/** + * WeakPersistent is a way to create a weak pointer from an off-heap object to + * an on-heap object. The pointer is automatically cleared when the pointee gets + * collected. WeakPersistent must be constructed and destructed in the same + * thread. + */ +template +using WeakPersistent = + internal::BasicPersistent; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_PERSISTENT_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/platform.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/platform.h new file mode 100644 index 0000000000..3276a26b65 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/platform.h @@ -0,0 +1,154 @@ +// 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_CPPGC_PLATFORM_H_ +#define INCLUDE_CPPGC_PLATFORM_H_ + +#include + +#include "v8-platform.h" // NOLINT(build/include_directory) +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +// TODO(v8:10346): Create separate includes for concepts that are not +// V8-specific. +using IdleTask = v8::IdleTask; +using JobHandle = v8::JobHandle; +using JobDelegate = v8::JobDelegate; +using JobTask = v8::JobTask; +using PageAllocator = v8::PageAllocator; +using Task = v8::Task; +using TaskPriority = v8::TaskPriority; +using TaskRunner = v8::TaskRunner; +using TracingController = v8::TracingController; + +/** + * Platform interface used by Heap. Contains allocators and executors. + */ +class V8_EXPORT Platform { + public: + virtual ~Platform() = default; + + /** + * Returns the allocator used by cppgc to allocate its heap and various + * support structures. + */ + virtual PageAllocator* GetPageAllocator() = 0; + + /** + * 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; + + /** + * Foreground task runner that should be used by a Heap. + */ + virtual std::shared_ptr GetForegroundTaskRunner() { + return nullptr; + } + + /** + * 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: + * \code + * class MyJobTask : public JobTask { + * public: + * MyJobTask(...) : worker_queue_(...) {} + * // JobTask implementation. + * 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(...)); + * handle->Join(); + * \endcode + * + * `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). + * + * A sufficient `PostJob()` implementation that uses the default Job provided + * in libplatform looks like: + * \code + * std::unique_ptr PostJob( + * TaskPriority priority, std::unique_ptr job_task) override { + * return std::make_unique( + * std::make_shared( + * this, std::move(job_task), kNumThreads)); + * } + * \endcode + */ + virtual std::unique_ptr PostJob( + TaskPriority priority, std::unique_ptr job_task) { + return nullptr; + } + + /** + * Returns an instance of a `TracingController`. This must be non-nullptr. The + * default implementation returns an empty `TracingController` that consumes + * trace data without effect. + */ + virtual TracingController* GetTracingController(); +}; + +/** + * Process-global initialization of the garbage collector. Must be called before + * creating a Heap. + * + * Can be called multiple times when paired with `ShutdownProcess()`. + * + * \param page_allocator The allocator used for maintaining meta data. Must not + * change between multiple calls to InitializeProcess. + */ +V8_EXPORT void InitializeProcess(PageAllocator* page_allocator); + +/** + * Must be called after destroying the last used heap. Some process-global + * metadata may not be returned and reused upon a subsequent + * `InitializeProcess()` call. + */ +V8_EXPORT void ShutdownProcess(); + +namespace internal { + +V8_EXPORT void Abort(); + +} // namespace internal + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_PLATFORM_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/prefinalizer.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/prefinalizer.h new file mode 100644 index 0000000000..29b18bef90 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/prefinalizer.h @@ -0,0 +1,52 @@ +// 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_CPPGC_PREFINALIZER_H_ +#define INCLUDE_CPPGC_PREFINALIZER_H_ + +#include "cppgc/internal/compiler-specific.h" +#include "cppgc/internal/prefinalizer-handler.h" +#include "cppgc/liveness-broker.h" + +namespace cppgc { + +namespace internal { + +template +class PrefinalizerRegistration final { + public: + explicit PrefinalizerRegistration(T* self) { + static_assert(sizeof(&T::InvokePreFinalizer) > 0, + "USING_PRE_FINALIZER(T) must be defined."); + + cppgc::internal::PreFinalizerRegistrationDispatcher::RegisterPrefinalizer( + {self, T::InvokePreFinalizer}); + } + + void* operator new(size_t, void* location) = delete; + void* operator new(size_t) = delete; +}; + +} // namespace internal + +#define CPPGC_USING_PRE_FINALIZER(Class, PreFinalizer) \ + public: \ + static bool InvokePreFinalizer(const cppgc::LivenessBroker& liveness_broker, \ + void* object) { \ + static_assert(cppgc::IsGarbageCollectedOrMixinTypeV, \ + "Only garbage collected objects can have prefinalizers"); \ + Class* self = static_cast(object); \ + if (liveness_broker.IsHeapObjectAlive(self)) return false; \ + self->Class::PreFinalizer(); \ + return true; \ + } \ + \ + private: \ + CPPGC_NO_UNIQUE_ADDRESS cppgc::internal::PrefinalizerRegistration \ + prefinalizer_dummy_{this}; \ + static_assert(true, "Force semicolon.") + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_PREFINALIZER_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/process-heap-statistics.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/process-heap-statistics.h new file mode 100644 index 0000000000..774cc92f46 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/process-heap-statistics.h @@ -0,0 +1,36 @@ +// 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_CPPGC_PROCESS_HEAP_STATISTICS_H_ +#define INCLUDE_CPPGC_PROCESS_HEAP_STATISTICS_H_ + +#include +#include + +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { +namespace internal { +class ProcessHeapStatisticsUpdater; +} // namespace internal + +class V8_EXPORT ProcessHeapStatistics final { + public: + static size_t TotalAllocatedObjectSize() { + return total_allocated_object_size_.load(std::memory_order_relaxed); + } + static size_t TotalAllocatedSpace() { + return total_allocated_space_.load(std::memory_order_relaxed); + } + + private: + static std::atomic_size_t total_allocated_space_; + static std::atomic_size_t total_allocated_object_size_; + + friend class internal::ProcessHeapStatisticsUpdater; +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_PROCESS_HEAP_STATISTICS_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/sentinel-pointer.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/sentinel-pointer.h new file mode 100644 index 0000000000..b049d1a2b3 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/sentinel-pointer.h @@ -0,0 +1,32 @@ +// 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_CPPGC_SENTINEL_POINTER_H_ +#define INCLUDE_CPPGC_SENTINEL_POINTER_H_ + +#include + +namespace cppgc { +namespace internal { + +// Special tag type used to denote some sentinel member. The semantics of the +// sentinel is defined by the embedder. +struct SentinelPointer { + template + operator T*() const { + static constexpr intptr_t kSentinelValue = 1; + return reinterpret_cast(kSentinelValue); + } + // Hidden friends. + friend bool operator==(SentinelPointer, SentinelPointer) { return true; } + friend bool operator!=(SentinelPointer, SentinelPointer) { return false; } +}; + +} // namespace internal + +constexpr internal::SentinelPointer kSentinelPointer; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_SENTINEL_POINTER_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/source-location.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/source-location.h new file mode 100644 index 0000000000..da5a5ede52 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/source-location.h @@ -0,0 +1,92 @@ +// 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_CPPGC_SOURCE_LOCATION_H_ +#define INCLUDE_CPPGC_SOURCE_LOCATION_H_ + +#include +#include + +#include "v8config.h" // NOLINT(build/include_directory) + +#if defined(__has_builtin) +#define CPPGC_SUPPORTS_SOURCE_LOCATION \ + (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) && \ + __has_builtin(__builtin_LINE)) // NOLINT +#elif defined(V8_CC_GNU) && __GNUC__ >= 7 +#define CPPGC_SUPPORTS_SOURCE_LOCATION 1 +#elif defined(V8_CC_INTEL) && __ICC >= 1800 +#define CPPGC_SUPPORTS_SOURCE_LOCATION 1 +#else +#define CPPGC_SUPPORTS_SOURCE_LOCATION 0 +#endif + +namespace cppgc { + +/** + * 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 CPPGC_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 // CPPGC_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 cppgc + +#endif // INCLUDE_CPPGC_SOURCE_LOCATION_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/testing.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/testing.h new file mode 100644 index 0000000000..229ce140f9 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/testing.h @@ -0,0 +1,99 @@ +// 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_CPPGC_TESTING_H_ +#define INCLUDE_CPPGC_TESTING_H_ + +#include "cppgc/common.h" +#include "cppgc/macros.h" +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +class HeapHandle; + +/** + * Namespace contains testing helpers. + */ +namespace testing { + +/** + * Overrides the state of the stack with the provided value. Takes precedence + * over other parameters that set the stack state. Must no be nested. + */ +class V8_EXPORT V8_NODISCARD OverrideEmbedderStackStateScope final { + CPPGC_STACK_ALLOCATED(); + + public: + /** + * Constructs a scoped object that automatically enters and leaves the scope. + * + * \param heap_handle The corresponding heap. + */ + explicit OverrideEmbedderStackStateScope(HeapHandle& heap_handle, + EmbedderStackState state); + ~OverrideEmbedderStackStateScope(); + + OverrideEmbedderStackStateScope(const OverrideEmbedderStackStateScope&) = + delete; + OverrideEmbedderStackStateScope& operator=( + const OverrideEmbedderStackStateScope&) = delete; + + private: + HeapHandle& heap_handle_; +}; + +/** + * Testing interface for managed heaps that allows for controlling garbage + * collection timings. Embedders should use this class when testing the + * interaction of their code with incremental/concurrent garbage collection. + */ +class V8_EXPORT StandaloneTestingHeap final { + public: + explicit StandaloneTestingHeap(HeapHandle&); + + /** + * Start an incremental garbage collection. + */ + void StartGarbageCollection(); + + /** + * Perform an incremental step. This will also schedule concurrent steps if + * needed. + * + * \param stack_state The state of the stack during the step. + */ + bool PerformMarkingStep(EmbedderStackState stack_state); + + /** + * Finalize the current garbage collection cycle atomically. + * Assumes that garbage collection is in progress. + * + * \param stack_state The state of the stack for finalizing the garbage + * collection cycle. + */ + void FinalizeGarbageCollection(EmbedderStackState stack_state); + + /** + * Toggle main thread marking on/off. Allows to stress concurrent marking + * (e.g. to better detect data races). + * + * \param should_mark Denotes whether the main thread should contribute to + * marking. Defaults to true. + */ + void ToggleMainThreadMarking(bool should_mark); + + /** + * Force enable compaction for the next garbage collection cycle. + */ + void ForceCompactionForNextGarbageCollection(); + + private: + HeapHandle& heap_handle_; +}; + +} // namespace testing +} // namespace cppgc + +#endif // INCLUDE_CPPGC_TESTING_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/trace-trait.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/trace-trait.h new file mode 100644 index 0000000000..83619b1d51 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/trace-trait.h @@ -0,0 +1,116 @@ +// 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_CPPGC_TRACE_TRAIT_H_ +#define INCLUDE_CPPGC_TRACE_TRAIT_H_ + +#include + +#include "cppgc/type-traits.h" +#include "v8config.h" // NOLINT(build/include_directory) + +namespace cppgc { + +class Visitor; + +namespace internal { + +// Implementation of the default TraceTrait handling GarbageCollected and +// GarbageCollectedMixin. +template ::type>> +struct TraceTraitImpl; + +} // namespace internal + +/** + * Callback for invoking tracing on a given object. + * + * \param visitor The visitor to dispatch to. + * \param object The object to invoke tracing on. + */ +using TraceCallback = void (*)(Visitor* visitor, const void* object); + +/** + * Describes how to trace an object, i.e., how to visit all Oilpan-relevant + * fields of an object. + */ +struct TraceDescriptor { + /** + * Adjusted base pointer, i.e., the pointer to the class inheriting directly + * from GarbageCollected, of the object that is being traced. + */ + const void* base_object_payload; + /** + * Callback for tracing the object. + */ + TraceCallback callback; +}; + +namespace internal { + +struct V8_EXPORT TraceTraitFromInnerAddressImpl { + static TraceDescriptor GetTraceDescriptor(const void* address); +}; + +/** + * Trait specifying how the garbage collector processes an object of type T. + * + * Advanced users may override handling by creating a specialization for their + * type. + */ +template +struct TraceTraitBase { + static_assert(internal::IsTraceableV, "T must have a Trace() method"); + + /** + * Accessor for retrieving a TraceDescriptor to process an object of type T. + * + * \param self The object to be processed. + * \returns a TraceDescriptor to process the object. + */ + static TraceDescriptor GetTraceDescriptor(const void* self) { + return internal::TraceTraitImpl::GetTraceDescriptor( + static_cast(self)); + } + + /** + * Function invoking the tracing for an object of type T. + * + * \param visitor The visitor to dispatch to. + * \param self The object to invoke tracing on. + */ + static void Trace(Visitor* visitor, const void* self) { + static_cast(self)->Trace(visitor); + } +}; + +} // namespace internal + +template +struct TraceTrait : public internal::TraceTraitBase {}; + +namespace internal { + +template +struct TraceTraitImpl { + static_assert(IsGarbageCollectedTypeV, + "T must be of type GarbageCollected or GarbageCollectedMixin"); + static TraceDescriptor GetTraceDescriptor(const void* self) { + return {self, TraceTrait::Trace}; + } +}; + +template +struct TraceTraitImpl { + static TraceDescriptor GetTraceDescriptor(const void* self) { + return internal::TraceTraitFromInnerAddressImpl::GetTraceDescriptor(self); + } +}; + +} // namespace internal +} // namespace cppgc + +#endif // INCLUDE_CPPGC_TRACE_TRAIT_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/type-traits.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/type-traits.h new file mode 100644 index 0000000000..56cd55d61e --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/type-traits.h @@ -0,0 +1,247 @@ +// 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_CPPGC_TYPE_TRAITS_H_ +#define INCLUDE_CPPGC_TYPE_TRAITS_H_ + +// This file should stay with minimal dependencies to allow embedder to check +// against Oilpan types without including any other parts. +#include +#include + +namespace cppgc { + +class Visitor; + +namespace internal { +template +class BasicMember; +struct DijkstraWriteBarrierPolicy; +struct NoWriteBarrierPolicy; +class StrongMemberTag; +class UntracedMemberTag; +class WeakMemberTag; + +// Pre-C++17 custom implementation of std::void_t. +template +struct make_void { + typedef void type; +}; +template +using void_t = typename make_void::type; + +// Not supposed to be specialized by the user. +template +struct IsWeak : std::false_type {}; + +// IsTraceMethodConst is used to verify that all Trace methods are marked as +// const. It is equivalent to IsTraceable but for a non-const object. +template +struct IsTraceMethodConst : std::false_type {}; + +template +struct IsTraceMethodConst().Trace( + std::declval()))>> : std::true_type { +}; + +template +struct IsTraceable : std::false_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template +struct IsTraceable< + T, void_t().Trace(std::declval()))>> + : std::true_type { + // All Trace methods should be marked as const. If an object of type + // 'T' is traceable then any object of type 'const T' should also + // be traceable. + static_assert(IsTraceMethodConst(), + "Trace methods should be marked as const."); +}; + +template +constexpr bool IsTraceableV = IsTraceable::value; + +template +struct HasGarbageCollectedMixinTypeMarker : std::false_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template +struct HasGarbageCollectedMixinTypeMarker< + T, + void_t::IsGarbageCollectedMixinTypeMarker>> + : std::true_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template +struct HasGarbageCollectedTypeMarker : std::false_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template +struct HasGarbageCollectedTypeMarker< + T, void_t::IsGarbageCollectedTypeMarker>> + : std::true_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template ::value, + bool = HasGarbageCollectedMixinTypeMarker::value> +struct IsGarbageCollectedMixinType : std::false_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template +struct IsGarbageCollectedMixinType : std::true_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template ::value> +struct IsGarbageCollectedType : std::false_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template +struct IsGarbageCollectedType : std::true_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template +struct IsGarbageCollectedOrMixinType + : std::integral_constant::value || + IsGarbageCollectedMixinType::value> { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template ::value && + HasGarbageCollectedMixinTypeMarker::value)> +struct IsGarbageCollectedWithMixinType : std::false_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template +struct IsGarbageCollectedWithMixinType : std::true_type { + static_assert(sizeof(T), "T must be fully defined"); +}; + +template +struct IsSubclassOfBasicMemberTemplate { + private: + template + static std::true_type SubclassCheck( + BasicMember*); + static std::false_type SubclassCheck(...); + + public: + static constexpr bool value = + decltype(SubclassCheck(std::declval()))::value; +}; + +template ::value> +struct IsMemberType : std::false_type {}; + +template +struct IsMemberType : std::true_type {}; + +template ::value> +struct IsWeakMemberType : std::false_type {}; + +template +struct IsWeakMemberType : std::true_type {}; + +template ::value> +struct IsUntracedMemberType : std::false_type {}; + +template +struct IsUntracedMemberType : std::true_type {}; + +template +struct IsComplete { + private: + template + static std::true_type IsSizeOfKnown(U*); + static std::false_type IsSizeOfKnown(...); + + public: + static constexpr bool value = + decltype(IsSizeOfKnown(std::declval()))::value; +}; + +} // namespace internal + +/** + * Value is true for types that inherit from `GarbageCollectedMixin` but not + * `GarbageCollected` (i.e., they are free mixins), and false otherwise. + */ +template +constexpr bool IsGarbageCollectedMixinTypeV = + internal::IsGarbageCollectedMixinType::value; + +/** + * Value is true for types that inherit from `GarbageCollected`, and false + * otherwise. + */ +template +constexpr bool IsGarbageCollectedTypeV = + internal::IsGarbageCollectedType::value; + +/** + * Value is true for types that inherit from either `GarbageCollected` or + * `GarbageCollectedMixin`, and false otherwise. + */ +template +constexpr bool IsGarbageCollectedOrMixinTypeV = + internal::IsGarbageCollectedOrMixinType::value; + +/** + * Value is true for types that inherit from `GarbageCollected` and + * `GarbageCollectedMixin`, and false otherwise. + */ +template +constexpr bool IsGarbageCollectedWithMixinTypeV = + internal::IsGarbageCollectedWithMixinType::value; + +/** + * Value is true for types of type `Member`, and false otherwise. + */ +template +constexpr bool IsMemberTypeV = internal::IsMemberType::value; + +/** + * Value is true for types of type `UntracedMember`, and false otherwise. + */ +template +constexpr bool IsUntracedMemberTypeV = internal::IsUntracedMemberType::value; + +/** + * Value is true for types of type `WeakMember`, and false otherwise. + */ +template +constexpr bool IsWeakMemberTypeV = internal::IsWeakMemberType::value; + +/** + * Value is true for types that are considered weak references, and false + * otherwise. + */ +template +constexpr bool IsWeakV = internal::IsWeak::value; + +/** + * Value is true for types that are complete, and false otherwise. + */ +template +constexpr bool IsCompleteV = internal::IsComplete::value; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_TYPE_TRAITS_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/visitor.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/visitor.h new file mode 100644 index 0000000000..57e2ce3963 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/cppgc/visitor.h @@ -0,0 +1,379 @@ +// 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_CPPGC_VISITOR_H_ +#define INCLUDE_CPPGC_VISITOR_H_ + +#include "cppgc/custom-space.h" +#include "cppgc/ephemeron-pair.h" +#include "cppgc/garbage-collected.h" +#include "cppgc/internal/logging.h" +#include "cppgc/internal/pointer-policies.h" +#include "cppgc/liveness-broker.h" +#include "cppgc/member.h" +#include "cppgc/sentinel-pointer.h" +#include "cppgc/source-location.h" +#include "cppgc/trace-trait.h" +#include "cppgc/type-traits.h" + +namespace cppgc { + +namespace internal { +template +class BasicCrossThreadPersistent; +template +class BasicPersistent; +class ConservativeTracingVisitor; +class VisitorBase; +class VisitorFactory; +} // namespace internal + +using WeakCallback = void (*)(const LivenessBroker&, const void*); + +/** + * Visitor passed to trace methods. All managed pointers must have called the + * Visitor's trace method on them. + * + * \code + * class Foo final : public GarbageCollected { + * public: + * void Trace(Visitor* visitor) const { + * visitor->Trace(foo_); + * visitor->Trace(weak_foo_); + * } + * private: + * Member foo_; + * WeakMember weak_foo_; + * }; + * \endcode + */ +class V8_EXPORT Visitor { + public: + class Key { + private: + Key() = default; + friend class internal::VisitorFactory; + }; + + explicit Visitor(Key) {} + + virtual ~Visitor() = default; + + /** + * Trace method for raw pointers. Prefer the versions for managed pointers. + * + * \param member Reference retaining an object. + */ + template + void Trace(const T* t) { + static_assert(sizeof(T), "Pointee type must be fully defined."); + static_assert(internal::IsGarbageCollectedOrMixinType::value, + "T must be GarbageCollected or GarbageCollectedMixin type"); + if (!t) { + return; + } + Visit(t, TraceTrait::GetTraceDescriptor(t)); + } + + /** + * Trace method for Member. + * + * \param member Member reference retaining an object. + */ + template + void Trace(const Member& member) { + const T* value = member.GetRawAtomic(); + CPPGC_DCHECK(value != kSentinelPointer); + Trace(value); + } + + /** + * Trace method for WeakMember. + * + * \param weak_member WeakMember reference weakly retaining an object. + */ + template + void Trace(const WeakMember& weak_member) { + static_assert(sizeof(T), "Pointee type must be fully defined."); + static_assert(internal::IsGarbageCollectedOrMixinType::value, + "T must be GarbageCollected or GarbageCollectedMixin type"); + static_assert(!internal::IsAllocatedOnCompactableSpace::value, + "Weak references to compactable objects are not allowed"); + + const T* value = weak_member.GetRawAtomic(); + + // Bailout assumes that WeakMember emits write barrier. + if (!value) { + return; + } + + CPPGC_DCHECK(value != kSentinelPointer); + VisitWeak(value, TraceTrait::GetTraceDescriptor(value), + &HandleWeak>, &weak_member); + } + + /** + * Trace method for inlined objects that are not allocated themselves but + * otherwise follow managed heap layout and have a Trace() method. + * + * \param object reference of the inlined object. + */ + template + void Trace(const T& object) { +#if V8_ENABLE_CHECKS + // This object is embedded in potentially multiple nested objects. The + // outermost object must not be in construction as such objects are (a) not + // processed immediately, and (b) only processed conservatively if not + // otherwise possible. + CheckObjectNotInConstruction(&object); +#endif // V8_ENABLE_CHECKS + TraceTrait::Trace(this, &object); + } + + /** + * Registers a weak callback method on the object of type T. See + * LivenessBroker for an usage example. + * + * \param object of type T specifying a weak callback method. + */ + template + void RegisterWeakCallbackMethod(const T* object) { + RegisterWeakCallback(&WeakCallbackMethodDelegate, object); + } + + /** + * Trace method for EphemeronPair. + * + * \param ephemeron_pair EphemeronPair reference weakly retaining a key object + * and strongly retaining a value object in case the key object is alive. + */ + template + void Trace(const EphemeronPair& ephemeron_pair) { + TraceEphemeron(ephemeron_pair.key, &ephemeron_pair.value); + RegisterWeakCallbackMethod, + &EphemeronPair::ClearValueIfKeyIsDead>( + &ephemeron_pair); + } + + /** + * Trace method for a single ephemeron. Used for tracing a raw ephemeron in + * which the `key` and `value` are kept separately. + * + * \param weak_member_key WeakMember reference weakly retaining a key object. + * \param member_value Member reference with ephemeron semantics. + */ + template + void TraceEphemeron(const WeakMember& weak_member_key, + const Member* member_value) { + const KeyType* key = weak_member_key.GetRawAtomic(); + if (!key) return; + + // `value` must always be non-null. + CPPGC_DCHECK(member_value); + const ValueType* value = member_value->GetRawAtomic(); + if (!value) return; + + // KeyType and ValueType may refer to GarbageCollectedMixin. + TraceDescriptor value_desc = + TraceTrait::GetTraceDescriptor(value); + CPPGC_DCHECK(value_desc.base_object_payload); + const void* key_base_object_payload = + TraceTrait::GetTraceDescriptor(key).base_object_payload; + CPPGC_DCHECK(key_base_object_payload); + + VisitEphemeron(key_base_object_payload, value, value_desc); + } + + /** + * Trace method for a single ephemeron. Used for tracing a raw ephemeron in + * which the `key` and `value` are kept separately. Note that this overload + * is for non-GarbageCollected `value`s that can be traced though. + * + * \param key `WeakMember` reference weakly retaining a key object. + * \param value Reference weakly retaining a value object. Note that + * `ValueType` here should not be `Member`. It is expected that + * `TraceTrait::GetTraceDescriptor(value)` returns a + * `TraceDescriptor` with a null base pointer but a valid trace method. + */ + template + void TraceEphemeron(const WeakMember& weak_member_key, + const ValueType* value) { + static_assert(!IsGarbageCollectedOrMixinTypeV, + "garbage-collected types must use WeakMember and Member"); + const KeyType* key = weak_member_key.GetRawAtomic(); + if (!key) return; + + // `value` must always be non-null. + CPPGC_DCHECK(value); + TraceDescriptor value_desc = + TraceTrait::GetTraceDescriptor(value); + // `value_desc.base_object_payload` must be null as this override is only + // taken for non-garbage-collected values. + CPPGC_DCHECK(!value_desc.base_object_payload); + + // KeyType might be a GarbageCollectedMixin. + const void* key_base_object_payload = + TraceTrait::GetTraceDescriptor(key).base_object_payload; + CPPGC_DCHECK(key_base_object_payload); + + VisitEphemeron(key_base_object_payload, value, value_desc); + } + + /** + * Trace method that strongifies a WeakMember. + * + * \param weak_member WeakMember reference retaining an object. + */ + template + void TraceStrongly(const WeakMember& weak_member) { + const T* value = weak_member.GetRawAtomic(); + CPPGC_DCHECK(value != kSentinelPointer); + Trace(value); + } + + /** + * Trace method for weak containers. + * + * \param object reference of the weak container. + * \param callback to be invoked. + * \param data custom data that is passed to the callback. + */ + template + void TraceWeakContainer(const T* object, WeakCallback callback, + const void* data) { + if (!object) return; + VisitWeakContainer(object, TraceTrait::GetTraceDescriptor(object), + TraceTrait::GetWeakTraceDescriptor(object), callback, + data); + } + + /** + * Registers a slot containing a reference to an object allocated on a + * compactable space. Such references maybe be arbitrarily moved by the GC. + * + * \param slot location of reference to object that might be moved by the GC. + */ + template + void RegisterMovableReference(const T** slot) { + static_assert(internal::IsAllocatedOnCompactableSpace::value, + "Only references to objects allocated on compactable spaces " + "should be registered as movable slots."); + static_assert(!IsGarbageCollectedMixinTypeV, + "Mixin types do not support compaction."); + HandleMovableReference(reinterpret_cast(slot)); + } + + /** + * Registers a weak callback that is invoked during garbage collection. + * + * \param callback to be invoked. + * \param data custom data that is passed to the callback. + */ + virtual void RegisterWeakCallback(WeakCallback callback, const void* data) {} + + /** + * Defers tracing an object from a concurrent thread to the mutator thread. + * Should be called by Trace methods of types that are not safe to trace + * concurrently. + * + * \param parameter tells the trace callback which object was deferred. + * \param callback to be invoked for tracing on the mutator thread. + * \param deferred_size size of deferred object. + * + * \returns false if the object does not need to be deferred (i.e. currently + * traced on the mutator thread) and true otherwise (i.e. currently traced on + * a concurrent thread). + */ + virtual V8_WARN_UNUSED_RESULT bool DeferTraceToMutatorThreadIfConcurrent( + const void* parameter, TraceCallback callback, size_t deferred_size) { + // By default tracing is not deferred. + return false; + } + + protected: + virtual void Visit(const void* self, TraceDescriptor) {} + virtual void VisitWeak(const void* self, TraceDescriptor, WeakCallback, + const void* weak_member) {} + virtual void VisitRoot(const void*, TraceDescriptor, const SourceLocation&) {} + virtual void VisitWeakRoot(const void* self, TraceDescriptor, WeakCallback, + const void* weak_root, const SourceLocation&) {} + virtual void VisitEphemeron(const void* key, const void* value, + TraceDescriptor value_desc) {} + virtual void VisitWeakContainer(const void* self, TraceDescriptor strong_desc, + TraceDescriptor weak_desc, + WeakCallback callback, const void* data) {} + virtual void HandleMovableReference(const void**) {} + + private: + template + static void WeakCallbackMethodDelegate(const LivenessBroker& info, + const void* self) { + // Callback is registered through a potential const Trace method but needs + // to be able to modify fields. See HandleWeak. + (const_cast(static_cast(self))->*method)(info); + } + + template + static void HandleWeak(const LivenessBroker& info, const void* object) { + const PointerType* weak = static_cast(object); + auto* raw_ptr = weak->GetFromGC(); + // Sentinel values are preserved for weak pointers. + if (raw_ptr == kSentinelPointer) return; + if (!info.IsHeapObjectAlive(raw_ptr)) { + weak->ClearFromGC(); + } + } + + template * = nullptr> + void TraceRoot(const Persistent& p, const SourceLocation& loc) { + using PointeeType = typename Persistent::PointeeType; + static_assert(sizeof(PointeeType), + "Persistent's pointee type must be fully defined"); + static_assert(internal::IsGarbageCollectedOrMixinType::value, + "Persistent's pointee type must be GarbageCollected or " + "GarbageCollectedMixin"); + auto* ptr = p.GetFromGC(); + if (!ptr) { + return; + } + VisitRoot(ptr, TraceTrait::GetTraceDescriptor(ptr), loc); + } + + template < + typename WeakPersistent, + std::enable_if_t* = nullptr> + void TraceRoot(const WeakPersistent& p, const SourceLocation& loc) { + using PointeeType = typename WeakPersistent::PointeeType; + static_assert(sizeof(PointeeType), + "Persistent's pointee type must be fully defined"); + static_assert(internal::IsGarbageCollectedOrMixinType::value, + "Persistent's pointee type must be GarbageCollected or " + "GarbageCollectedMixin"); + static_assert(!internal::IsAllocatedOnCompactableSpace::value, + "Weak references to compactable objects are not allowed"); + auto* ptr = p.GetFromGC(); + VisitWeakRoot(ptr, TraceTrait::GetTraceDescriptor(ptr), + &HandleWeak, &p, loc); + } + +#if V8_ENABLE_CHECKS + void CheckObjectNotInConstruction(const void* address); +#endif // V8_ENABLE_CHECKS + + template + friend class internal::BasicCrossThreadPersistent; + template + friend class internal::BasicPersistent; + friend class internal::ConservativeTracingVisitor; + friend class internal::VisitorBase; +}; + +} // namespace cppgc + +#endif // INCLUDE_CPPGC_VISITOR_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/js_native_api.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/js_native_api.h index d72e7f4e99..220d140d4b 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/js_native_api.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/js_native_api.h @@ -2,8 +2,8 @@ #define SRC_JS_NATIVE_API_H_ // This file needs to be compatible with C compilers. -#include // NOLINT(modernize-deprecated-headers) #include // NOLINT(modernize-deprecated-headers) +#include // NOLINT(modernize-deprecated-headers) // Use INT_MAX, this should only be consumed by the pre-processor anyway. #define NAPI_VERSION_EXPERIMENTAL 2147483647 @@ -26,14 +26,15 @@ // If you need __declspec(dllimport), either include 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(__wasm32__) - #define NAPI_EXTERN __attribute__((visibility("default"))) \ - __attribute__((__import_module__("napi"))) - #else - #define NAPI_EXTERN __attribute__((visibility("default"))) - #endif +#ifdef _WIN32 +#define NAPI_EXTERN __declspec(dllexport) +#elif defined(__wasm32__) +#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 @@ -48,228 +49,228 @@ EXTERN_C_START -NAPI_EXTERN napi_status -napi_get_last_error_info(napi_env env, - const napi_extended_error_info** result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_last_error_info(napi_env env, const napi_extended_error_info** result); // Getters for defined singletons -NAPI_EXTERN napi_status napi_get_undefined(napi_env env, napi_value* result); -NAPI_EXTERN napi_status napi_get_null(napi_env env, napi_value* result); -NAPI_EXTERN napi_status napi_get_global(napi_env env, napi_value* result); -NAPI_EXTERN napi_status napi_get_boolean(napi_env env, - bool value, - napi_value* result); +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_create_object(napi_env env, napi_value* result); -NAPI_EXTERN napi_status napi_create_array(napi_env env, napi_value* result); -NAPI_EXTERN napi_status napi_create_array_with_length(napi_env env, - size_t length, +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); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_symbol(napi_env env, + napi_value description, napi_value* result); -NAPI_EXTERN napi_status napi_create_double(napi_env env, - double value, - napi_value* result); -NAPI_EXTERN napi_status napi_create_int32(napi_env env, - int32_t value, - napi_value* result); -NAPI_EXTERN napi_status napi_create_uint32(napi_env env, - uint32_t value, - napi_value* result); -NAPI_EXTERN napi_status napi_create_int64(napi_env env, - int64_t value, - napi_value* result); -NAPI_EXTERN napi_status napi_create_string_latin1(napi_env env, - const char* str, - size_t length, - napi_value* result); -NAPI_EXTERN napi_status napi_create_string_utf8(napi_env env, - const char* str, - size_t length, - napi_value* result); -NAPI_EXTERN napi_status napi_create_string_utf16(napi_env env, - const char16_t* str, - size_t length, - napi_value* result); -NAPI_EXTERN napi_status napi_create_symbol(napi_env env, - napi_value description, - napi_value* result); -NAPI_EXTERN napi_status 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_create_error(napi_env env, - napi_value code, - napi_value msg, - napi_value* result); -NAPI_EXTERN napi_status napi_create_type_error(napi_env env, - napi_value code, - napi_value msg, - napi_value* result); -NAPI_EXTERN napi_status napi_create_range_error(napi_env env, - napi_value code, - napi_value msg, - napi_value* result); #ifdef NAPI_EXPERIMENTAL -NAPI_EXTERN napi_status node_api_create_syntax_error(napi_env env, +NAPI_EXTERN napi_status NAPI_CDECL +node_api_symbol_for(napi_env env, + const char* utf8description, + size_t length, + napi_value* result); +#endif // NAPI_EXPERIMENTAL +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); +#ifdef NAPI_EXPERIMENTAL +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_EXPERIMENTAL // Methods to get the native napi_value from Primitive type -NAPI_EXTERN napi_status napi_typeof(napi_env env, - napi_value value, - napi_valuetype* result); -NAPI_EXTERN napi_status napi_get_value_double(napi_env env, - napi_value value, - double* result); -NAPI_EXTERN napi_status napi_get_value_int32(napi_env env, - napi_value value, - int32_t* result); -NAPI_EXTERN napi_status napi_get_value_uint32(napi_env env, - napi_value value, - uint32_t* result); -NAPI_EXTERN napi_status napi_get_value_int64(napi_env env, - napi_value value, - int64_t* result); -NAPI_EXTERN napi_status napi_get_value_bool(napi_env env, - napi_value value, - bool* result); +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_get_value_string_latin1(napi_env env, - napi_value value, - char* buf, - size_t bufsize, - size_t* result); +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_get_value_string_utf8(napi_env env, - napi_value value, - char* buf, - size_t bufsize, - size_t* result); +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_get_value_string_utf16(napi_env env, - napi_value value, - char16_t* buf, - size_t bufsize, - size_t* result); +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_coerce_to_bool(napi_env env, - napi_value value, - napi_value* result); -NAPI_EXTERN napi_status napi_coerce_to_number(napi_env env, - napi_value value, - napi_value* result); -NAPI_EXTERN napi_status napi_coerce_to_object(napi_env env, - napi_value value, - napi_value* result); -NAPI_EXTERN napi_status napi_coerce_to_string(napi_env env, - napi_value value, - napi_value* result); +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_get_prototype(napi_env env, - napi_value object, - napi_value* result); -NAPI_EXTERN napi_status napi_get_property_names(napi_env env, - napi_value object, - napi_value* result); -NAPI_EXTERN napi_status napi_set_property(napi_env env, - napi_value object, - napi_value key, - napi_value value); -NAPI_EXTERN napi_status napi_has_property(napi_env env, - napi_value object, - napi_value key, - bool* result); -NAPI_EXTERN napi_status napi_get_property(napi_env env, - napi_value object, - napi_value key, - napi_value* result); -NAPI_EXTERN napi_status napi_delete_property(napi_env env, - napi_value object, - napi_value key, - bool* result); -NAPI_EXTERN napi_status napi_has_own_property(napi_env env, - napi_value object, - napi_value key, - bool* result); -NAPI_EXTERN napi_status napi_set_named_property(napi_env env, - napi_value object, - const char* utf8name, - napi_value value); -NAPI_EXTERN napi_status napi_has_named_property(napi_env env, - napi_value object, - const char* utf8name, - bool* result); -NAPI_EXTERN napi_status napi_get_named_property(napi_env env, - napi_value object, - const char* utf8name, - napi_value* result); -NAPI_EXTERN napi_status napi_set_element(napi_env env, - napi_value object, - uint32_t index, - napi_value value); -NAPI_EXTERN napi_status napi_has_element(napi_env env, - napi_value object, - uint32_t index, - bool* result); -NAPI_EXTERN napi_status napi_get_element(napi_env env, - napi_value object, - uint32_t index, - napi_value* result); -NAPI_EXTERN napi_status napi_delete_element(napi_env env, - napi_value object, - uint32_t index, - bool* result); -NAPI_EXTERN napi_status +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_is_array(napi_env env, - napi_value value, - bool* result); -NAPI_EXTERN napi_status napi_get_array_length(napi_env env, - napi_value value, - uint32_t* result); +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_strict_equals(napi_env env, - napi_value lhs, - napi_value rhs, - bool* result); +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_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_new_instance(napi_env env, - napi_value constructor, - size_t argc, - const napi_value* argv, - napi_value* result); -NAPI_EXTERN napi_status napi_instanceof(napi_env env, - napi_value object, - napi_value constructor, - bool* result); +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_get_cb_info( +NAPI_EXTERN napi_status NAPI_CDECL napi_get_cb_info( napi_env env, // [in] NAPI environment handle napi_callback_info cbinfo, // [in] Opaque callback-info handle size_t* argc, // [in-out] Specifies the size of the provided argv array @@ -278,10 +279,9 @@ NAPI_EXTERN napi_status napi_get_cb_info( 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_get_new_target(napi_env env, - napi_callback_info cbinfo, - napi_value* result); -NAPI_EXTERN napi_status +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, @@ -292,237 +292,240 @@ napi_define_class(napi_env env, napi_value* result); // Methods to work with external data objects -NAPI_EXTERN napi_status napi_wrap(napi_env env, - napi_value js_object, - void* native_object, - napi_finalize finalize_cb, - void* finalize_hint, - napi_ref* result); -NAPI_EXTERN napi_status napi_unwrap(napi_env env, - napi_value js_object, - void** result); -NAPI_EXTERN napi_status napi_remove_wrap(napi_env env, - napi_value js_object, - void** result); -NAPI_EXTERN napi_status napi_create_external(napi_env env, - void* data, +NAPI_EXTERN napi_status NAPI_CDECL napi_wrap(napi_env env, + napi_value js_object, + void* native_object, napi_finalize finalize_cb, void* finalize_hint, - napi_value* result); -NAPI_EXTERN napi_status napi_get_value_external(napi_env env, - napi_value value, - void** result); + 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, + napi_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_create_reference(napi_env env, - napi_value value, - uint32_t initial_refcount, - napi_ref* result); +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_delete_reference(napi_env env, napi_ref ref); +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_reference_ref(napi_env env, - napi_ref ref, - uint32_t* result); +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_reference_unref(napi_env env, - napi_ref ref, - uint32_t* result); +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_get_reference_value(napi_env env, - napi_ref ref, - napi_value* result); - -NAPI_EXTERN napi_status napi_open_handle_scope(napi_env env, - napi_handle_scope* result); -NAPI_EXTERN napi_status napi_close_handle_scope(napi_env env, - napi_handle_scope scope); -NAPI_EXTERN napi_status -napi_open_escapable_handle_scope(napi_env env, - napi_escapable_handle_scope* result); -NAPI_EXTERN napi_status -napi_close_escapable_handle_scope(napi_env env, - napi_escapable_handle_scope scope); - -NAPI_EXTERN napi_status napi_escape_handle(napi_env env, - napi_escapable_handle_scope scope, - napi_value escapee, - napi_value* result); +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_throw(napi_env env, napi_value error); -NAPI_EXTERN napi_status napi_throw_error(napi_env env, - const char* code, - const char* msg); -NAPI_EXTERN napi_status napi_throw_type_error(napi_env env, - const char* code, - const char* msg); -NAPI_EXTERN napi_status napi_throw_range_error(napi_env env, - const char* code, - const char* msg); -#ifdef NAPI_EXPERIMENTAL -NAPI_EXTERN napi_status node_api_throw_syntax_error(napi_env env, +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); +#ifdef NAPI_EXPERIMENTAL +NAPI_EXTERN napi_status NAPI_CDECL node_api_throw_syntax_error(napi_env env, + const char* code, + const char* msg); #endif // NAPI_EXPERIMENTAL -NAPI_EXTERN napi_status napi_is_error(napi_env env, - napi_value value, - bool* result); +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_is_exception_pending(napi_env env, bool* result); -NAPI_EXTERN napi_status napi_get_and_clear_last_exception(napi_env env, - napi_value* result); +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_is_arraybuffer(napi_env env, - napi_value value, - bool* result); -NAPI_EXTERN napi_status napi_create_arraybuffer(napi_env env, - size_t byte_length, - void** data, - napi_value* result); -NAPI_EXTERN napi_status +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); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_external_arraybuffer(napi_env env, void* external_data, size_t byte_length, napi_finalize finalize_cb, void* finalize_hint, napi_value* result); -NAPI_EXTERN napi_status napi_get_arraybuffer_info(napi_env env, - napi_value arraybuffer, - void** data, - size_t* byte_length); -NAPI_EXTERN napi_status napi_is_typedarray(napi_env env, - napi_value value, - bool* result); -NAPI_EXTERN napi_status 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_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_create_dataview(napi_env env, - size_t length, - napi_value arraybuffer, - size_t byte_offset, - napi_value* result); -NAPI_EXTERN napi_status napi_is_dataview(napi_env env, - napi_value value, - bool* result); -NAPI_EXTERN napi_status napi_get_dataview_info(napi_env env, - napi_value dataview, - size_t* bytelength, - void** data, - napi_value* arraybuffer, - size_t* byte_offset); +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_get_version(napi_env env, uint32_t* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(napi_env env, + uint32_t* result); // Promises -NAPI_EXTERN napi_status napi_create_promise(napi_env env, - napi_deferred* deferred, - napi_value* promise); -NAPI_EXTERN napi_status napi_resolve_deferred(napi_env env, - napi_deferred deferred, - napi_value resolution); -NAPI_EXTERN napi_status napi_reject_deferred(napi_env env, - napi_deferred deferred, - napi_value rejection); -NAPI_EXTERN napi_status napi_is_promise(napi_env env, - napi_value value, - bool* is_promise); +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_run_script(napi_env env, - napi_value script, - napi_value* result); +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_adjust_external_memory(napi_env env, - int64_t change_in_bytes, - int64_t* adjusted_value); +NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory( + napi_env env, int64_t change_in_bytes, int64_t* adjusted_value); #if NAPI_VERSION >= 5 // Dates -NAPI_EXTERN napi_status napi_create_date(napi_env env, - double time, - napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_date(napi_env env, + double time, + napi_value* result); -NAPI_EXTERN napi_status napi_is_date(napi_env env, - napi_value value, - bool* is_date); +NAPI_EXTERN napi_status NAPI_CDECL napi_is_date(napi_env env, + napi_value value, + bool* is_date); -NAPI_EXTERN napi_status napi_get_date_value(napi_env env, - napi_value value, - double* result); +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_add_finalizer(napi_env env, - napi_value js_object, - void* native_object, - napi_finalize finalize_cb, - void* finalize_hint, - napi_ref* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_add_finalizer(napi_env env, + napi_value js_object, + void* native_object, + napi_finalize finalize_cb, + void* finalize_hint, + napi_ref* result); #endif // NAPI_VERSION >= 5 #if NAPI_VERSION >= 6 // BigInt -NAPI_EXTERN napi_status napi_create_bigint_int64(napi_env env, - int64_t value, - napi_value* result); -NAPI_EXTERN napi_status napi_create_bigint_uint64(napi_env env, - uint64_t value, - napi_value* result); -NAPI_EXTERN napi_status 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_get_value_bigint_int64(napi_env env, - napi_value value, - int64_t* result, - bool* lossless); -NAPI_EXTERN napi_status napi_get_value_bigint_uint64(napi_env env, - napi_value value, - uint64_t* result, - bool* lossless); -NAPI_EXTERN napi_status napi_get_value_bigint_words(napi_env env, - napi_value value, - int* sign_bit, - size_t* word_count, - uint64_t* words); +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_EXTERN napi_status NAPI_CDECL napi_get_all_property_names(napi_env env, napi_value object, napi_key_collection_mode key_mode, @@ -531,40 +534,36 @@ napi_get_all_property_names(napi_env env, napi_value* result); // Instance data -NAPI_EXTERN napi_status napi_set_instance_data(napi_env env, - void* data, - napi_finalize finalize_cb, - void* finalize_hint); +NAPI_EXTERN napi_status NAPI_CDECL napi_set_instance_data( + napi_env env, void* data, napi_finalize finalize_cb, void* finalize_hint); -NAPI_EXTERN napi_status napi_get_instance_data(napi_env env, - void** data); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_instance_data(napi_env env, + void** data); #endif // NAPI_VERSION >= 6 #if NAPI_VERSION >= 7 // ArrayBuffer detaching -NAPI_EXTERN napi_status napi_detach_arraybuffer(napi_env env, - napi_value arraybuffer); +NAPI_EXTERN napi_status NAPI_CDECL +napi_detach_arraybuffer(napi_env env, napi_value arraybuffer); -NAPI_EXTERN napi_status napi_is_detached_arraybuffer(napi_env env, - napi_value value, - bool* result); +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_type_tag_object(napi_env env, - napi_value value, - const napi_type_tag* type_tag); +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_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_object_freeze(napi_env env, - napi_value object); -NAPI_EXTERN napi_status napi_object_seal(napi_env env, - napi_value object); +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 diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/js_native_api_types.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/js_native_api_types.h index 6aba06629b..376930ba4a 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/js_native_api_types.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/js_native_api_types.h @@ -8,7 +8,15 @@ #include // NOLINT(modernize-deprecated-headers) #if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900) - typedef uint16_t char16_t; +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 @@ -36,9 +44,7 @@ typedef enum { 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, + napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable, #endif // NAPI_VERSION >= 8 } napi_property_attributes; @@ -102,11 +108,11 @@ typedef enum { // * the definition of `napi_status` in doc/api/n-api.md to reflect the newly // added value(s). -typedef napi_value (*napi_callback)(napi_env env, - napi_callback_info info); -typedef void (*napi_finalize)(napi_env env, - void* finalize_data, - void* finalize_hint); +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); typedef struct { // One of utf8name or name should be NULL. diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/libplatform/libplatform-export.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/libplatform/libplatform-export.h new file mode 100644 index 0000000000..1561843497 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/libplatform/libplatform-export.h @@ -0,0 +1,29 @@ +// Copyright 2016 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_LIBPLATFORM_LIBPLATFORM_EXPORT_H_ +#define V8_LIBPLATFORM_LIBPLATFORM_EXPORT_H_ + +#if defined(_WIN32) + +#ifdef BUILDING_V8_PLATFORM_SHARED +#define V8_PLATFORM_EXPORT __declspec(dllexport) +#elif USING_V8_PLATFORM_SHARED +#define V8_PLATFORM_EXPORT __declspec(dllimport) +#else +#define V8_PLATFORM_EXPORT +#endif // BUILDING_V8_PLATFORM_SHARED + +#else // defined(_WIN32) + +// Setup for Linux shared library export. +#ifdef BUILDING_V8_PLATFORM_SHARED +#define V8_PLATFORM_EXPORT __attribute__((visibility("default"))) +#else +#define V8_PLATFORM_EXPORT +#endif + +#endif // defined(_WIN32) + +#endif // V8_LIBPLATFORM_LIBPLATFORM_EXPORT_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/libplatform/libplatform.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/libplatform/libplatform.h new file mode 100644 index 0000000000..00de81df88 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/libplatform/libplatform.h @@ -0,0 +1,117 @@ +// Copyright 2014 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef V8_LIBPLATFORM_LIBPLATFORM_H_ +#define V8_LIBPLATFORM_LIBPLATFORM_H_ + +#include + +#include "libplatform/libplatform-export.h" +#include "libplatform/v8-tracing.h" +#include "v8-platform.h" // NOLINT(build/include_directory) +#include "v8config.h" // NOLINT(build/include_directory) + +namespace v8 { +namespace platform { + +enum class IdleTaskSupport { kDisabled, kEnabled }; +enum class InProcessStackDumping { kDisabled, kEnabled }; + +enum class MessageLoopBehavior : bool { + kDoNotWait = false, + kWaitForWork = true +}; + +/** + * Returns a new instance of the default v8::Platform implementation. + * + * The caller will take ownership of the returned pointer. |thread_pool_size| + * is the number of worker threads to allocate for background jobs. If a value + * of zero is passed, a suitable default based on the current number of + * processors online will be chosen. + * If |idle_task_support| is enabled then the platform will accept idle + * tasks (IdleTasksEnabled will return true) and will rely on the embedder + * calling v8::platform::RunIdleTasks to process the idle tasks. + * If |tracing_controller| is nullptr, the default platform will create a + * v8::platform::TracingController instance and use it. + */ +V8_PLATFORM_EXPORT std::unique_ptr NewDefaultPlatform( + int thread_pool_size = 0, + IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled, + InProcessStackDumping in_process_stack_dumping = + InProcessStackDumping::kDisabled, + std::unique_ptr tracing_controller = {}); + +/** + * The same as NewDefaultPlatform but disables the worker thread pool. + * It must be used with the --single-threaded V8 flag. + */ +V8_PLATFORM_EXPORT std::unique_ptr +NewSingleThreadedDefaultPlatform( + IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled, + InProcessStackDumping in_process_stack_dumping = + InProcessStackDumping::kDisabled, + std::unique_ptr tracing_controller = {}); + +/** + * Returns a new instance of the default v8::JobHandle implementation. + * + * The job will be executed by spawning up to |num_worker_threads| many worker + * threads on the provided |platform| with the given |priority|. + */ +V8_PLATFORM_EXPORT std::unique_ptr NewDefaultJobHandle( + v8::Platform* platform, v8::TaskPriority priority, + std::unique_ptr job_task, size_t num_worker_threads); + +/** + * Pumps the message loop for the given isolate. + * + * The caller has to make sure that this is called from the right thread. + * Returns true if a task was executed, and false otherwise. If the call to + * PumpMessageLoop is nested within another call to PumpMessageLoop, only + * nestable tasks may run. Otherwise, any task may run. Unless requested through + * the |behavior| parameter, this call does not block if no task is pending. The + * |platform| has to be created using |NewDefaultPlatform|. + */ +V8_PLATFORM_EXPORT bool PumpMessageLoop( + v8::Platform* platform, v8::Isolate* isolate, + MessageLoopBehavior behavior = MessageLoopBehavior::kDoNotWait); + +/** + * Runs pending idle tasks for at most |idle_time_in_seconds| seconds. + * + * The caller has to make sure that this is called from the right thread. + * This call does not block if no task is pending. The |platform| has to be + * created using |NewDefaultPlatform|. + */ +V8_PLATFORM_EXPORT void RunIdleTasks(v8::Platform* platform, + v8::Isolate* isolate, + double idle_time_in_seconds); + +/** + * Attempts to set the tracing controller for the given platform. + * + * The |platform| has to be created using |NewDefaultPlatform|. + * + */ +V8_DEPRECATE_SOON("Access the DefaultPlatform directly") +V8_PLATFORM_EXPORT void SetTracingController( + v8::Platform* platform, + v8::platform::tracing::TracingController* tracing_controller); + +/** + * Notifies the given platform about the Isolate getting deleted soon. Has to be + * called for all Isolates which are deleted - unless we're shutting down the + * platform. + * + * The |platform| has to be created using |NewDefaultPlatform|. + * + */ +V8_PLATFORM_EXPORT void NotifyIsolateShutdown(v8::Platform* platform, + Isolate* isolate); + +} // namespace platform +} // namespace v8 + +#endif // V8_LIBPLATFORM_LIBPLATFORM_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/libplatform/v8-tracing.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/libplatform/v8-tracing.h new file mode 100644 index 0000000000..c7a5c4f9f5 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/libplatform/v8-tracing.h @@ -0,0 +1,334 @@ +// Copyright 2016 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_LIBPLATFORM_V8_TRACING_H_ +#define V8_LIBPLATFORM_V8_TRACING_H_ + +#include +#include +#include +#include +#include + +#include "libplatform/libplatform-export.h" +#include "v8-platform.h" // NOLINT(build/include_directory) + +namespace perfetto { +namespace trace_processor { +class TraceProcessorStorage; +} +class TracingSession; +} + +namespace v8 { + +namespace base { +class Mutex; +} // namespace base + +namespace platform { +namespace tracing { + +class TraceEventListener; + +const int kTraceMaxNumArgs = 2; + +class V8_PLATFORM_EXPORT TraceObject { + public: + union ArgValue { + V8_DEPRECATED("use as_uint ? true : false") bool as_bool; + uint64_t as_uint; + int64_t as_int; + double as_double; + const void* as_pointer; + const char* as_string; + }; + + TraceObject() = default; + ~TraceObject(); + void Initialize( + char phase, const uint8_t* category_enabled_flag, const char* name, + const char* scope, uint64_t id, uint64_t bind_id, int num_args, + const char** arg_names, const uint8_t* arg_types, + const uint64_t* arg_values, + std::unique_ptr* arg_convertables, + unsigned int flags, int64_t timestamp, int64_t cpu_timestamp); + void UpdateDuration(int64_t timestamp, int64_t cpu_timestamp); + void InitializeForTesting( + char phase, const uint8_t* category_enabled_flag, const char* name, + const char* scope, uint64_t id, uint64_t bind_id, int num_args, + const char** arg_names, const uint8_t* arg_types, + const uint64_t* arg_values, + std::unique_ptr* arg_convertables, + unsigned int flags, int pid, int tid, int64_t ts, int64_t tts, + uint64_t duration, uint64_t cpu_duration); + + int pid() const { return pid_; } + int tid() const { return tid_; } + char phase() const { return phase_; } + const uint8_t* category_enabled_flag() const { + return category_enabled_flag_; + } + const char* name() const { return name_; } + const char* scope() const { return scope_; } + uint64_t id() const { return id_; } + uint64_t bind_id() const { return bind_id_; } + int num_args() const { return num_args_; } + const char** arg_names() { return arg_names_; } + uint8_t* arg_types() { return arg_types_; } + ArgValue* arg_values() { return arg_values_; } + std::unique_ptr* arg_convertables() { + return arg_convertables_; + } + unsigned int flags() const { return flags_; } + int64_t ts() { return ts_; } + int64_t tts() { return tts_; } + uint64_t duration() { return duration_; } + uint64_t cpu_duration() { return cpu_duration_; } + + private: + int pid_; + int tid_; + char phase_; + const char* name_; + const char* scope_; + const uint8_t* category_enabled_flag_; + uint64_t id_; + uint64_t bind_id_; + int num_args_ = 0; + const char* arg_names_[kTraceMaxNumArgs]; + uint8_t arg_types_[kTraceMaxNumArgs]; + ArgValue arg_values_[kTraceMaxNumArgs]; + std::unique_ptr + arg_convertables_[kTraceMaxNumArgs]; + char* parameter_copy_storage_ = nullptr; + unsigned int flags_; + int64_t ts_; + int64_t tts_; + uint64_t duration_; + uint64_t cpu_duration_; + + // Disallow copy and assign + TraceObject(const TraceObject&) = delete; + void operator=(const TraceObject&) = delete; +}; + +class V8_PLATFORM_EXPORT TraceWriter { + public: + TraceWriter() = default; + virtual ~TraceWriter() = default; + virtual void AppendTraceEvent(TraceObject* trace_event) = 0; + virtual void Flush() = 0; + + static TraceWriter* CreateJSONTraceWriter(std::ostream& stream); + static TraceWriter* CreateJSONTraceWriter(std::ostream& stream, + const std::string& tag); + + static TraceWriter* CreateSystemInstrumentationTraceWriter(); + + private: + // Disallow copy and assign + TraceWriter(const TraceWriter&) = delete; + void operator=(const TraceWriter&) = delete; +}; + +class V8_PLATFORM_EXPORT TraceBufferChunk { + public: + explicit TraceBufferChunk(uint32_t seq); + + void Reset(uint32_t new_seq); + bool IsFull() const { return next_free_ == kChunkSize; } + TraceObject* AddTraceEvent(size_t* event_index); + TraceObject* GetEventAt(size_t index) { return &chunk_[index]; } + + uint32_t seq() const { return seq_; } + size_t size() const { return next_free_; } + + static const size_t kChunkSize = 64; + + private: + size_t next_free_ = 0; + TraceObject chunk_[kChunkSize]; + uint32_t seq_; + + // Disallow copy and assign + TraceBufferChunk(const TraceBufferChunk&) = delete; + void operator=(const TraceBufferChunk&) = delete; +}; + +class V8_PLATFORM_EXPORT TraceBuffer { + public: + TraceBuffer() = default; + virtual ~TraceBuffer() = default; + + virtual TraceObject* AddTraceEvent(uint64_t* handle) = 0; + virtual TraceObject* GetEventByHandle(uint64_t handle) = 0; + virtual bool Flush() = 0; + + static const size_t kRingBufferChunks = 1024; + + static TraceBuffer* CreateTraceBufferRingBuffer(size_t max_chunks, + TraceWriter* trace_writer); + + private: + // Disallow copy and assign + TraceBuffer(const TraceBuffer&) = delete; + void operator=(const TraceBuffer&) = delete; +}; + +// Options determines how the trace buffer stores data. +enum TraceRecordMode { + // Record until the trace buffer is full. + RECORD_UNTIL_FULL, + + // Record until the user ends the trace. The trace buffer is a fixed size + // and we use it as a ring buffer during recording. + RECORD_CONTINUOUSLY, + + // Record until the trace buffer is full, but with a huge buffer size. + RECORD_AS_MUCH_AS_POSSIBLE, + + // Echo to console. Events are discarded. + ECHO_TO_CONSOLE, +}; + +class V8_PLATFORM_EXPORT TraceConfig { + public: + typedef std::vector StringList; + + static TraceConfig* CreateDefaultTraceConfig(); + + TraceConfig() : enable_systrace_(false), enable_argument_filter_(false) {} + TraceRecordMode GetTraceRecordMode() const { return record_mode_; } + const StringList& GetEnabledCategories() const { + return included_categories_; + } + bool IsSystraceEnabled() const { return enable_systrace_; } + bool IsArgumentFilterEnabled() const { return enable_argument_filter_; } + + void SetTraceRecordMode(TraceRecordMode mode) { record_mode_ = mode; } + void EnableSystrace() { enable_systrace_ = true; } + void EnableArgumentFilter() { enable_argument_filter_ = true; } + + void AddIncludedCategory(const char* included_category); + + bool IsCategoryGroupEnabled(const char* category_group) const; + + private: + TraceRecordMode record_mode_; + bool enable_systrace_ : 1; + bool enable_argument_filter_ : 1; + StringList included_categories_; + + // Disallow copy and assign + TraceConfig(const TraceConfig&) = delete; + void operator=(const TraceConfig&) = delete; +}; + +#if defined(_MSC_VER) +#define V8_PLATFORM_NON_EXPORTED_BASE(code) \ + __pragma(warning(suppress : 4275)) code +#else +#define V8_PLATFORM_NON_EXPORTED_BASE(code) code +#endif // defined(_MSC_VER) + +class V8_PLATFORM_EXPORT TracingController + : public V8_PLATFORM_NON_EXPORTED_BASE(v8::TracingController) { + public: + TracingController(); + ~TracingController() override; + +#if defined(V8_USE_PERFETTO) + // Must be called before StartTracing() if V8_USE_PERFETTO is true. Provides + // the output stream for the JSON trace data. + void InitializeForPerfetto(std::ostream* output_stream); + // Provide an optional listener for testing that will receive trace events. + // Must be called before StartTracing(). + void SetTraceEventListenerForTesting(TraceEventListener* listener); +#else // defined(V8_USE_PERFETTO) + // The pointer returned from GetCategoryGroupEnabled() points to a value with + // zero or more of the following bits. Used in this class only. The + // TRACE_EVENT macros should only use the value as a bool. These values must + // be in sync with macro values in TraceEvent.h in Blink. + enum CategoryGroupEnabledFlags { + // Category group enabled for the recording mode. + ENABLED_FOR_RECORDING = 1 << 0, + // Category group enabled by SetEventCallbackEnabled(). + ENABLED_FOR_EVENT_CALLBACK = 1 << 2, + // Category group enabled to export events to ETW. + ENABLED_FOR_ETW_EXPORT = 1 << 3 + }; + + // Takes ownership of |trace_buffer|. + void Initialize(TraceBuffer* trace_buffer); + + // v8::TracingController implementation. + const uint8_t* GetCategoryGroupEnabled(const char* category_group) override; + 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* arg_convertables, + unsigned int flags) override; + 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* arg_convertables, + unsigned int flags, int64_t timestamp) override; + void UpdateTraceEventDuration(const uint8_t* category_enabled_flag, + const char* name, uint64_t handle) override; + + static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag); +#endif // !defined(V8_USE_PERFETTO) + + void AddTraceStateObserver( + v8::TracingController::TraceStateObserver* observer) override; + void RemoveTraceStateObserver( + v8::TracingController::TraceStateObserver* observer) override; + + void StartTracing(TraceConfig* trace_config); + void StopTracing(); + + protected: +#if !defined(V8_USE_PERFETTO) + virtual int64_t CurrentTimestampMicroseconds(); + virtual int64_t CurrentCpuTimestampMicroseconds(); +#endif // !defined(V8_USE_PERFETTO) + + private: +#if !defined(V8_USE_PERFETTO) + void UpdateCategoryGroupEnabledFlag(size_t category_index); + void UpdateCategoryGroupEnabledFlags(); +#endif // !defined(V8_USE_PERFETTO) + + std::unique_ptr mutex_; + std::unique_ptr trace_config_; + std::atomic_bool recording_{false}; + std::unordered_set observers_; + +#if defined(V8_USE_PERFETTO) + std::ostream* output_stream_ = nullptr; + std::unique_ptr + trace_processor_; + TraceEventListener* listener_for_testing_ = nullptr; + std::unique_ptr tracing_session_; +#else // !defined(V8_USE_PERFETTO) + std::unique_ptr trace_buffer_; +#endif // !defined(V8_USE_PERFETTO) + + // Disallow copy and assign + TracingController(const TracingController&) = delete; + void operator=(const TracingController&) = delete; +}; + +#undef V8_PLATFORM_NON_EXPORTED_BASE + +} // namespace tracing +} // namespace platform +} // namespace v8 + +#endif // V8_LIBPLATFORM_V8_TRACING_H_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/node.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/node.h index 5b1404ff8e..4be002ac18 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/node.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/node.h @@ -32,6 +32,16 @@ # 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 @@ -438,7 +448,12 @@ enum Flags : uint64_t { // $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 + kNoGlobalSearchPaths = 1 << 7, + // 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 }; } // namespace EnvironmentFlags @@ -819,11 +834,13 @@ extern "C" NODE_EXTERN void node_module_register(void* mod); #endif #if defined(_MSC_VER) -#pragma section(".CRT$XCU", read) #define NODE_C_CTOR(fn) \ NODE_CTOR_PREFIX void __cdecl fn(void); \ - __declspec(dllexport, allocate(".CRT$XCU")) \ - void (__cdecl*fn ## _)(void) = fn; \ + namespace { \ + struct fn##_ { \ + fn##_() { fn(); }; \ + } fn##_v_; \ + } \ NODE_CTOR_PREFIX void __cdecl fn(void) #else #define NODE_C_CTOR(fn) \ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_api.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_api.h index 1772c67c15..982b41cadf 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_api.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_api.h @@ -2,12 +2,12 @@ #define SRC_NODE_API_H_ #ifdef BUILDING_NODE_EXTENSION - #ifdef _WIN32 - // Building native module against node - #define NAPI_EXTERN __declspec(dllimport) - #elif defined(__wasm32__) - #define NAPI_EXTERN __attribute__((__import_module__("napi"))) - #endif +#ifdef _WIN32 +// Building native module against node +#define NAPI_EXTERN __declspec(dllimport) +#elif defined(__wasm32__) +#define NAPI_EXTERN __attribute__((__import_module__("napi"))) +#endif #endif #include "js_native_api.h" #include "node_api_types.h" @@ -15,21 +15,21 @@ struct uv_loop_s; // Forward declaration. #ifdef _WIN32 -# define NAPI_MODULE_EXPORT __declspec(dllexport) +#define NAPI_MODULE_EXPORT __declspec(dllexport) #else -# define NAPI_MODULE_EXPORT __attribute__((visibility("default"))) +#define NAPI_MODULE_EXPORT __attribute__((visibility("default"))) #endif #if defined(__GNUC__) -# define NAPI_NO_RETURN __attribute__((noreturn)) +#define NAPI_NO_RETURN __attribute__((noreturn)) #elif defined(_WIN32) -# define NAPI_NO_RETURN __declspec(noreturn) +#define NAPI_NO_RETURN __declspec(noreturn) #else -# define NAPI_NO_RETURN +#define NAPI_NO_RETURN #endif -typedef napi_value (*napi_addon_register_func)(napi_env env, - napi_value exports); +typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env, + napi_value exports); typedef struct napi_module { int nm_version; @@ -41,36 +41,50 @@ typedef struct napi_module { void* reserved[4]; } napi_module; -#define NAPI_MODULE_VERSION 1 +#define NAPI_MODULE_VERSION 1 #if defined(_MSC_VER) +#if defined(__cplusplus) +#define NAPI_C_CTOR(fn) \ + static void NAPI_CDECL fn(void); \ + namespace { \ + struct fn##_ { \ + fn##_() { fn(); } \ + } fn##_v_; \ + } \ + static void NAPI_CDECL fn(void) +#else // !defined(__cplusplus) #pragma section(".CRT$XCU", read) -#define NAPI_C_CTOR(fn) \ - static void __cdecl fn(void); \ - __declspec(dllexport, allocate(".CRT$XCU")) void(__cdecl * fn##_)(void) = \ - fn; \ - static void __cdecl fn(void) +// The NAPI_C_CTOR macro defines a function fn that is called during CRT +// initialization. +// C does not support dynamic initialization of static variables and this code +// simulates C++ behavior. Exporting the function pointer prevents it from being +// optimized. See for details: +// https://docs.microsoft.com/en-us/cpp/c-runtime-library/crt-initialization?view=msvc-170 +#define NAPI_C_CTOR(fn) \ + static void NAPI_CDECL fn(void); \ + __declspec(dllexport, allocate(".CRT$XCU")) void(NAPI_CDECL * fn##_)(void) = \ + fn; \ + static void NAPI_CDECL fn(void) +#endif // defined(__cplusplus) #else -#define NAPI_C_CTOR(fn) \ - static void fn(void) __attribute__((constructor)); \ +#define NAPI_C_CTOR(fn) \ + static void fn(void) __attribute__((constructor)); \ static void fn(void) #endif -#define NAPI_MODULE_X(modname, regfunc, priv, flags) \ - EXTERN_C_START \ - static napi_module _module = \ - { \ - NAPI_MODULE_VERSION, \ - flags, \ - __FILE__, \ - regfunc, \ - #modname, \ - priv, \ - {0}, \ - }; \ - NAPI_C_CTOR(_register_ ## modname) { \ - napi_module_register(&_module); \ - } \ +#define NAPI_MODULE_X(modname, regfunc, priv, flags) \ + EXTERN_C_START \ + static napi_module _module = { \ + NAPI_MODULE_VERSION, \ + flags, \ + __FILE__, \ + regfunc, \ + #modname, \ + priv, \ + {0}, \ + }; \ + NAPI_C_CTOR(_register_##modname) { napi_module_register(&_module); } \ EXTERN_C_END #define NAPI_MODULE_INITIALIZER_X(base, version) \ @@ -88,123 +102,124 @@ typedef struct napi_module { } \ EXTERN_C_END #else -#define NAPI_MODULE(modname, regfunc) \ +#define NAPI_MODULE(modname, regfunc) \ NAPI_MODULE_X(modname, regfunc, NULL, 0) // NOLINT (readability/null_usage) #endif #define NAPI_MODULE_INITIALIZER_BASE napi_register_module_v -#define NAPI_MODULE_INITIALIZER \ - NAPI_MODULE_INITIALIZER_X(NAPI_MODULE_INITIALIZER_BASE, \ - NAPI_MODULE_VERSION) +#define NAPI_MODULE_INITIALIZER \ + NAPI_MODULE_INITIALIZER_X(NAPI_MODULE_INITIALIZER_BASE, NAPI_MODULE_VERSION) -#define NAPI_MODULE_INIT() \ - EXTERN_C_START \ - NAPI_MODULE_EXPORT napi_value \ - NAPI_MODULE_INITIALIZER(napi_env env, napi_value exports); \ - EXTERN_C_END \ - NAPI_MODULE(NODE_GYP_MODULE_NAME, NAPI_MODULE_INITIALIZER) \ - napi_value NAPI_MODULE_INITIALIZER(napi_env env, \ - napi_value exports) +#define NAPI_MODULE_INIT() \ + EXTERN_C_START \ + NAPI_MODULE_EXPORT napi_value NAPI_MODULE_INITIALIZER(napi_env env, \ + napi_value exports); \ + EXTERN_C_END \ + NAPI_MODULE(NODE_GYP_MODULE_NAME, NAPI_MODULE_INITIALIZER) \ + napi_value NAPI_MODULE_INITIALIZER(napi_env env, napi_value exports) EXTERN_C_START -NAPI_EXTERN void napi_module_register(napi_module* mod); +NAPI_EXTERN void NAPI_CDECL napi_module_register(napi_module* mod); -NAPI_EXTERN NAPI_NO_RETURN void napi_fatal_error(const char* location, - size_t location_len, - const char* message, - size_t message_len); +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_async_init(napi_env env, - napi_value async_resource, - napi_value async_resource_name, - napi_async_context* result); - -NAPI_EXTERN napi_status napi_async_destroy(napi_env env, - napi_async_context async_context); - -NAPI_EXTERN napi_status 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); +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_create_buffer(napi_env env, - size_t length, - void** data, - napi_value* result); -NAPI_EXTERN napi_status napi_create_external_buffer(napi_env env, - size_t length, - void* data, - napi_finalize finalize_cb, - void* finalize_hint, - napi_value* result); -NAPI_EXTERN napi_status napi_create_buffer_copy(napi_env env, - size_t length, - const void* data, - void** result_data, - napi_value* result); -NAPI_EXTERN napi_status napi_is_buffer(napi_env env, - napi_value value, - bool* result); -NAPI_EXTERN napi_status napi_get_buffer_info(napi_env env, - napi_value value, - void** data, - size_t* length); +NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer(napi_env env, + size_t length, + void** data, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_external_buffer(napi_env env, + size_t length, + void* data, + napi_finalize finalize_cb, + void* finalize_hint, + napi_value* result); +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_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_delete_async_work(napi_env env, - napi_async_work work); -NAPI_EXTERN napi_status napi_queue_async_work(napi_env env, - napi_async_work work); -NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env, - napi_async_work work); +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(napi_env env, + napi_async_work work); +NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(napi_env env, + napi_async_work work); // version management -NAPI_EXTERN -napi_status napi_get_node_version(napi_env env, - const napi_node_version** version); +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_node_version(napi_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_get_uv_event_loop(napi_env env, - struct uv_loop_s** loop); +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_uv_event_loop(napi_env env, struct uv_loop_s** loop); #endif // NAPI_VERSION >= 2 #if NAPI_VERSION >= 3 -NAPI_EXTERN napi_status napi_fatal_exception(napi_env env, napi_value err); +NAPI_EXTERN napi_status NAPI_CDECL napi_fatal_exception(napi_env env, + napi_value err); -NAPI_EXTERN napi_status napi_add_env_cleanup_hook(napi_env env, - void (*fun)(void* arg), - void* arg); +NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook( + napi_env env, void(NAPI_CDECL* fun)(void* arg), void* arg); -NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(napi_env env, - void (*fun)(void* arg), - void* arg); +NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook( + napi_env env, void(NAPI_CDECL* fun)(void* arg), void* arg); -NAPI_EXTERN napi_status 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_open_callback_scope(napi_env env, + napi_value resource_object, + napi_async_context context, + napi_callback_scope* result); -NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env, - napi_callback_scope scope); +NAPI_EXTERN napi_status NAPI_CDECL +napi_close_callback_scope(napi_env env, napi_callback_scope scope); #endif // NAPI_VERSION >= 3 @@ -212,7 +227,7 @@ NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env, #ifndef __wasm32__ // Calling into JS from other threads -NAPI_EXTERN napi_status +NAPI_EXTERN napi_status NAPI_CDECL napi_create_threadsafe_function(napi_env env, napi_value func, napi_value async_resource, @@ -225,26 +240,24 @@ napi_create_threadsafe_function(napi_env env, napi_threadsafe_function_call_js call_js_cb, napi_threadsafe_function* result); -NAPI_EXTERN napi_status -napi_get_threadsafe_function_context(napi_threadsafe_function func, - void** result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_threadsafe_function_context( + napi_threadsafe_function func, void** result); -NAPI_EXTERN napi_status +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_EXTERN napi_status NAPI_CDECL napi_acquire_threadsafe_function(napi_threadsafe_function func); -NAPI_EXTERN napi_status -napi_release_threadsafe_function(napi_threadsafe_function func, - napi_threadsafe_function_release_mode mode); +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_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func); -NAPI_EXTERN napi_status +NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func); #endif // __wasm32__ @@ -252,20 +265,20 @@ napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func); #if NAPI_VERSION >= 8 -NAPI_EXTERN napi_status napi_add_async_cleanup_hook( - napi_env env, - napi_async_cleanup_hook hook, - void* arg, - napi_async_cleanup_hook_handle* remove_handle); +NAPI_EXTERN napi_status NAPI_CDECL +napi_add_async_cleanup_hook(napi_env env, + napi_async_cleanup_hook hook, + void* arg, + napi_async_cleanup_hook_handle* remove_handle); -NAPI_EXTERN napi_status napi_remove_async_cleanup_hook( - 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 #ifdef NAPI_EXPERIMENTAL -NAPI_EXTERN napi_status +NAPI_EXTERN napi_status NAPI_CDECL node_api_get_module_file_name(napi_env env, const char** result); #endif // NAPI_EXPERIMENTAL diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_api_types.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_api_types.h index 58ffc61b3a..4231994748 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_api_types.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_api_types.h @@ -22,16 +22,13 @@ typedef enum { } napi_threadsafe_function_call_mode; #endif // NAPI_VERSION >= 4 -typedef void (*napi_async_execute_callback)(napi_env env, - void* data); -typedef void (*napi_async_complete_callback)(napi_env env, - napi_status status, - void* data); +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_threadsafe_function_call_js)(napi_env env, - napi_value js_callback, - void* context, - void* data); +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 { @@ -43,8 +40,8 @@ typedef struct { #if NAPI_VERSION >= 8 typedef struct napi_async_cleanup_hook_handle__* napi_async_cleanup_hook_handle; -typedef void (*napi_async_cleanup_hook)(napi_async_cleanup_hook_handle handle, - void* data); +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_ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_version.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_version.h index 41081f8271..d95df7498e 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_version.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/node_version.h @@ -23,13 +23,13 @@ #define SRC_NODE_VERSION_H_ #define NODE_MAJOR_VERSION 16 -#define NODE_MINOR_VERSION 14 -#define NODE_PATCH_VERSION 2 +#define NODE_MINOR_VERSION 17 +#define NODE_PATCH_VERSION 1 #define NODE_VERSION_IS_LTS 1 #define NODE_VERSION_LTS_CODENAME "Gallium" -#define NODE_VERSION_IS_RELEASE 1 +#define NODE_VERSION_IS_RELEASE 0 #ifndef NODE_STRINGIFY #define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n) diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/asm/crypto/buildinf.h index ab8d040db3..aab8081e74 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: BSD-x86" -#define DATE "built on: Tue Mar 15 19:21:51 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:24 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/asm_avx2/crypto/buildinf.h index bc0e2cc85f..5f1cc2113b 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: BSD-x86" -#define DATE "built on: Tue Mar 15 19:21:54 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:26 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/no-asm/crypto/buildinf.h index 28dfdf866a..4301e5711b 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: BSD-x86" -#define DATE "built on: Tue Mar 15 19:21:57 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:28 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/asm/crypto/buildinf.h index 86d3904d30..f9062b5267 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: BSD-x86_64" -#define DATE "built on: Tue Mar 15 19:21:59 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:29 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/asm_avx2/crypto/buildinf.h index 8bbd5bf80a..fa6112af3c 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: BSD-x86_64" -#define DATE "built on: Tue Mar 15 19:22:05 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:34 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/no-asm/crypto/buildinf.h index ba498aa13e..f16ca39845 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/BSD-x86_64/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: BSD-x86_64" -#define DATE "built on: Tue Mar 15 19:22:12 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:38 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/asm/crypto/buildinf.h index b11a3c050f..b5d476128c 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: " -#define DATE "built on: Tue Mar 15 19:26:23 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:18 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/asm_avx2/crypto/buildinf.h index a4f9a7467b..90b66705ac 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: " -#define DATE "built on: Tue Mar 15 19:26:29 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:20 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/no-asm/crypto/buildinf.h index 4db593fbf0..017ac0eb5b 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN32/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: " -#define DATE "built on: Tue Mar 15 19:26:35 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:22 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64-ARM/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64-ARM/no-asm/crypto/buildinf.h index 105164d32a..a928f71c76 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64-ARM/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64-ARM/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: VC-WIN64-ARM" -#define DATE "built on: Tue Mar 15 19:26:38 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:23 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/asm/crypto/buildinf.h index 621e404bb7..21d9fc78f4 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: " -#define DATE "built on: Tue Mar 15 19:25:52 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:08 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/asm_avx2/crypto/buildinf.h index 355dfaa2e8..c2f7b39d84 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: " -#define DATE "built on: Tue Mar 15 19:26:06 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:13 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/no-asm/crypto/buildinf.h index 40853b3137..33381dd7e4 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/VC-WIN64A/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: " -#define DATE "built on: Tue Mar 15 19:26:20 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:17 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/asm/crypto/buildinf.h index 83c7cc6b93..b37b9e6c59 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: aix-gcc" -#define DATE "built on: Tue Mar 15 19:21:36 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:14 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/asm_avx2/crypto/buildinf.h index 0d3ff3d373..8fb9327076 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: aix-gcc" -#define DATE "built on: Tue Mar 15 19:21:39 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:16 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/no-asm/crypto/buildinf.h index 9462d84014..8c3cd2b01b 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix-gcc/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: aix-gcc" -#define DATE "built on: Tue Mar 15 19:21:41 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:17 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/asm/crypto/buildinf.h index 03e4771247..0c2d814c1e 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: aix64-gcc" -#define DATE "built on: Tue Mar 15 19:21:43 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:19 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/asm_avx2/crypto/buildinf.h index b9840d933c..00e835eac2 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: aix64-gcc" -#define DATE "built on: Tue Mar 15 19:21:46 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:21 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/no-asm/crypto/buildinf.h index 1186e6a866..287cebb19f 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/aix64-gcc/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: aix64-gcc" -#define DATE "built on: Tue Mar 15 19:21:49 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:23 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/asm/crypto/buildinf.h index adc1fbbbef..ebef8a8934 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: darwin-i386-cc" -#define DATE "built on: Tue Mar 15 19:22:29 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:49 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/asm_avx2/crypto/buildinf.h index 28e9720b5d..06d04a8beb 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: darwin-i386-cc" -#define DATE "built on: Tue Mar 15 19:22:33 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:52 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/no-asm/crypto/buildinf.h index 3ca93f24ae..d3c7815809 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin-i386-cc/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: darwin-i386-cc" -#define DATE "built on: Tue Mar 15 19:22:36 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:54 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/asm/crypto/buildinf.h index 3016b23634..a5c3cf9ed6 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: darwin64-arm64-cc" -#define DATE "built on: Tue Mar 15 19:22:38 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:55 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/asm_avx2/crypto/buildinf.h index 6990cd8a07..5ca24f292a 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: darwin64-arm64-cc" -#define DATE "built on: Tue Mar 15 19:22:40 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:57 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/no-asm/crypto/buildinf.h index 0e089a168d..28a8d9e826 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-arm64-cc/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: darwin64-arm64-cc" -#define DATE "built on: Tue Mar 15 19:22:43 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:59 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/asm/crypto/buildinf.h index cba186dccb..8fe544a30f 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: darwin64-x86_64-cc" -#define DATE "built on: Tue Mar 15 19:22:14 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:39 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/asm_avx2/crypto/buildinf.h index 03af08cfa9..e3c57a392f 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: darwin64-x86_64-cc" -#define DATE "built on: Tue Mar 15 19:22:21 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:44 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/no-asm/crypto/buildinf.h index 2cd36f6810..beedba419d 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/darwin64-x86_64-cc/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: darwin64-x86_64-cc" -#define DATE "built on: Tue Mar 15 19:22:27 2022 UTC" +#define DATE "built on: Tue Jul 5 15:02:48 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/asm/crypto/buildinf.h index 3dedf90dd1..494f72bf90 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-aarch64" -#define DATE "built on: Tue Mar 15 19:22:45 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:00 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/asm_avx2/crypto/buildinf.h index 6cc08f15d0..843eaecb80 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-aarch64" -#define DATE "built on: Tue Mar 15 19:22:48 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:02 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/no-asm/crypto/buildinf.h index 93a35682d6..c3fbbdff35 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-aarch64/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-aarch64" -#define DATE "built on: Tue Mar 15 19:22:51 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:04 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/asm/crypto/buildinf.h index fdc623c1bc..c6b9d193d0 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-armv4" -#define DATE "built on: Tue Mar 15 19:22:52 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:05 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/asm_avx2/crypto/buildinf.h index 9afeed3b4c..904107ab73 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-armv4" -#define DATE "built on: Tue Mar 15 19:22:55 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:07 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/no-asm/crypto/buildinf.h index 25366a4c29..37366e972f 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-armv4/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-armv4" -#define DATE "built on: Tue Mar 15 19:22:58 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:09 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/asm/crypto/buildinf.h index b17ec0597d..129fe79fd1 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-elf" -#define DATE "built on: Tue Mar 15 19:23:00 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:10 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/asm_avx2/crypto/buildinf.h index f52c3d9576..9e84917773 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-elf" -#define DATE "built on: Tue Mar 15 19:23:03 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:12 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/no-asm/crypto/buildinf.h index 4a44782c42..9d63de543c 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-elf/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-elf" -#define DATE "built on: Tue Mar 15 19:23:06 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:14 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/asm/crypto/buildinf.h index 90955efbe9..cbdc033005 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-ppc" -#define DATE "built on: Tue Mar 15 19:23:43 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:26 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/asm_avx2/crypto/buildinf.h index f117eaa978..64434c5530 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-ppc" -#define DATE "built on: Tue Mar 15 19:23:48 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:27 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/no-asm/crypto/buildinf.h index 6d75c3774d..93876129e8 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-ppc" -#define DATE "built on: Tue Mar 15 19:23:53 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:29 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/asm/crypto/buildinf.h index fa1018becc..342ef59f7f 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-ppc64" -#define DATE "built on: Tue Mar 15 19:23:57 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:30 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/asm_avx2/crypto/buildinf.h index fb001931dc..27336c9c72 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-ppc64" -#define DATE "built on: Tue Mar 15 19:24:03 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:32 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/no-asm/crypto/buildinf.h index fb114ef89b..ee77d223ff 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-ppc64" -#define DATE "built on: Tue Mar 15 19:24:09 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:34 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/asm/crypto/buildinf.h index d76fe5fcaf..b8c4d419da 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-ppc64le" -#define DATE "built on: Tue Mar 15 19:24:12 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:35 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/asm_avx2/crypto/buildinf.h index aa3cfcdeed..6f294d1e32 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-ppc64le" -#define DATE "built on: Tue Mar 15 19:24:18 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:38 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/no-asm/crypto/buildinf.h index 382a007d12..d4c4320303 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-ppc64le/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-ppc64le" -#define DATE "built on: Tue Mar 15 19:24:24 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:39 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm/crypto/include/internal/bn_conf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm/crypto/include/internal/bn_conf.h deleted file mode 100644 index 93f75e2e15..0000000000 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm/crypto/include/internal/bn_conf.h +++ /dev/null @@ -1,28 +0,0 @@ -/* WARNING: do not edit! */ -/* Generated by Makefile from include/crypto/bn_conf.h.in */ -/* - * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved. - * - * Licensed under the OpenSSL license (the "License"). You may not use - * this file except in compliance with the License. You can obtain a copy - * in the file LICENSE in the source distribution or at - * https://www.openssl.org/source/license.html - */ - -#ifndef OSSL_CRYPTO_BN_CONF_H -# define OSSL_CRYPTO_BN_CONF_H - -/* - * The contents of this file are not used in the UEFI build, as - * both 32-bit and 64-bit builds are supported from a single run - * of the Configure script. - */ - -/* Should we define BN_DIV2W here? */ - -/* Only one for the following should be defined */ -#undef SIXTY_FOUR_BIT_LONG -#define SIXTY_FOUR_BIT -#undef THIRTY_TWO_BIT - -#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm/crypto/include/internal/dso_conf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm/crypto/include/internal/dso_conf.h deleted file mode 100644 index 4b1167c3d8..0000000000 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm/crypto/include/internal/dso_conf.h +++ /dev/null @@ -1,17 +0,0 @@ -/* WARNING: do not edit! */ -/* Generated by Makefile from include/crypto/dso_conf.h.in */ -/* - * Copyright 2016-2019 The OpenSSL Project Authors. All Rights Reserved. - * - * Licensed under the OpenSSL license (the "License"). You may not use - * this file except in compliance with the License. You can obtain a copy - * in the file LICENSE in the source distribution or at - * https://www.openssl.org/source/license.html - */ - -#ifndef OSSL_CRYPTO_DSO_CONF_H -# define OSSL_CRYPTO_DSO_CONF_H -# define DSO_DLFCN -# define HAVE_DLFCN_H -# define DSO_EXTENSION ".so" -#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm/include/openssl/opensslconf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm/include/openssl/opensslconf.h deleted file mode 100644 index dc4b7ebef3..0000000000 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm/include/openssl/opensslconf.h +++ /dev/null @@ -1,200 +0,0 @@ -/* - * WARNING: do not edit! - * Generated by Makefile from include/openssl/opensslconf.h.in - * - * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved. - * - * Licensed under the OpenSSL license (the "License"). You may not use - * this file except in compliance with the License. You can obtain a copy - * in the file LICENSE in the source distribution or at - * https://www.openssl.org/source/license.html - */ - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef OPENSSL_ALGORITHM_DEFINES -# error OPENSSL_ALGORITHM_DEFINES no longer supported -#endif - -/* - * OpenSSL was configured with the following options: - */ - -#ifndef OPENSSL_NO_COMP -# define OPENSSL_NO_COMP -#endif -#ifndef OPENSSL_NO_MD2 -# define OPENSSL_NO_MD2 -#endif -#ifndef OPENSSL_NO_RC5 -# define OPENSSL_NO_RC5 -#endif -#ifndef OPENSSL_THREADS -# define OPENSSL_THREADS -#endif -#ifndef OPENSSL_RAND_SEED_OS -# define OPENSSL_RAND_SEED_OS -#endif -#ifndef OPENSSL_NO_AFALGENG -# define OPENSSL_NO_AFALGENG -#endif -#ifndef OPENSSL_NO_ASAN -# define OPENSSL_NO_ASAN -#endif -#ifndef OPENSSL_NO_CRYPTO_MDEBUG -# define OPENSSL_NO_CRYPTO_MDEBUG -#endif -#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE -# define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE -#endif -#ifndef OPENSSL_NO_DEVCRYPTOENG -# define OPENSSL_NO_DEVCRYPTOENG -#endif -#ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 -# define OPENSSL_NO_EC_NISTP_64_GCC_128 -#endif -#ifndef OPENSSL_NO_EGD -# define OPENSSL_NO_EGD -#endif -#ifndef OPENSSL_NO_EXTERNAL_TESTS -# define OPENSSL_NO_EXTERNAL_TESTS -#endif -#ifndef OPENSSL_NO_FUZZ_AFL -# define OPENSSL_NO_FUZZ_AFL -#endif -#ifndef OPENSSL_NO_FUZZ_LIBFUZZER -# define OPENSSL_NO_FUZZ_LIBFUZZER -#endif -#ifndef OPENSSL_NO_HEARTBEATS -# define OPENSSL_NO_HEARTBEATS -#endif -#ifndef OPENSSL_NO_MSAN -# define OPENSSL_NO_MSAN -#endif -#ifndef OPENSSL_NO_SCTP -# define OPENSSL_NO_SCTP -#endif -#ifndef OPENSSL_NO_SSL3 -# define OPENSSL_NO_SSL3 -#endif -#ifndef OPENSSL_NO_SSL3_METHOD -# define OPENSSL_NO_SSL3_METHOD -#endif -#ifndef OPENSSL_NO_UBSAN -# define OPENSSL_NO_UBSAN -#endif -#ifndef OPENSSL_NO_UNIT_TEST -# define OPENSSL_NO_UNIT_TEST -#endif -#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS -# define OPENSSL_NO_WEAK_SSL_CIPHERS -#endif -#ifndef OPENSSL_NO_DYNAMIC_ENGINE -# define OPENSSL_NO_DYNAMIC_ENGINE -#endif - - -/* - * Sometimes OPENSSSL_NO_xxx ends up with an empty file and some compilers - * don't like that. This will hopefully silence them. - */ -#define NON_EMPTY_TRANSLATION_UNIT static void *dummy = &dummy; - -/* - * Applications should use -DOPENSSL_API_COMPAT= to suppress the - * declarations of functions deprecated in or before . Otherwise, they - * still won't see them if the library has been built to disable deprecated - * functions. - */ -#ifndef DECLARE_DEPRECATED -# define DECLARE_DEPRECATED(f) f; -# ifdef __GNUC__ -# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0) -# undef DECLARE_DEPRECATED -# define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); -# endif -# elif defined(__SUNPRO_C) -# if (__SUNPRO_C >= 0x5130) -# undef DECLARE_DEPRECATED -# define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); -# endif -# endif -#endif - -#ifndef OPENSSL_FILE -# ifdef OPENSSL_NO_FILENAMES -# define OPENSSL_FILE "" -# define OPENSSL_LINE 0 -# else -# define OPENSSL_FILE __FILE__ -# define OPENSSL_LINE __LINE__ -# endif -#endif - -#ifndef OPENSSL_MIN_API -# define OPENSSL_MIN_API 0 -#endif - -#if !defined(OPENSSL_API_COMPAT) || OPENSSL_API_COMPAT < OPENSSL_MIN_API -# undef OPENSSL_API_COMPAT -# define OPENSSL_API_COMPAT OPENSSL_MIN_API -#endif - -/* - * Do not deprecate things to be deprecated in version 1.2.0 before the - * OpenSSL version number matches. - */ -#if OPENSSL_VERSION_NUMBER < 0x10200000L -# define DEPRECATEDIN_1_2_0(f) f; -#elif OPENSSL_API_COMPAT < 0x10200000L -# define DEPRECATEDIN_1_2_0(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_1_2_0(f) -#endif - -#if OPENSSL_API_COMPAT < 0x10100000L -# define DEPRECATEDIN_1_1_0(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_1_1_0(f) -#endif - -#if OPENSSL_API_COMPAT < 0x10000000L -# define DEPRECATEDIN_1_0_0(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_1_0_0(f) -#endif - -#if OPENSSL_API_COMPAT < 0x00908000L -# define DEPRECATEDIN_0_9_8(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_0_9_8(f) -#endif - -/* Generate 80386 code? */ -#undef I386_ONLY - -#undef OPENSSL_UNISTD -#define OPENSSL_UNISTD - -#undef OPENSSL_EXPORT_VAR_AS_FUNCTION - -/* - * The following are cipher-specific, but are part of the public API. - */ -#if !defined(OPENSSL_SYS_UEFI) -# undef BN_LLONG -/* Only one for the following should be defined */ -# undef SIXTY_FOUR_BIT_LONG -# define SIXTY_FOUR_BIT -# undef THIRTY_TWO_BIT -#endif - -#define RC4_INT unsigned int - -#ifdef __cplusplus -} -#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm_avx2/crypto/include/internal/bn_conf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm_avx2/crypto/include/internal/bn_conf.h deleted file mode 100644 index 93f75e2e15..0000000000 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm_avx2/crypto/include/internal/bn_conf.h +++ /dev/null @@ -1,28 +0,0 @@ -/* WARNING: do not edit! */ -/* Generated by Makefile from include/crypto/bn_conf.h.in */ -/* - * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved. - * - * Licensed under the OpenSSL license (the "License"). You may not use - * this file except in compliance with the License. You can obtain a copy - * in the file LICENSE in the source distribution or at - * https://www.openssl.org/source/license.html - */ - -#ifndef OSSL_CRYPTO_BN_CONF_H -# define OSSL_CRYPTO_BN_CONF_H - -/* - * The contents of this file are not used in the UEFI build, as - * both 32-bit and 64-bit builds are supported from a single run - * of the Configure script. - */ - -/* Should we define BN_DIV2W here? */ - -/* Only one for the following should be defined */ -#undef SIXTY_FOUR_BIT_LONG -#define SIXTY_FOUR_BIT -#undef THIRTY_TWO_BIT - -#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm_avx2/crypto/include/internal/dso_conf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm_avx2/crypto/include/internal/dso_conf.h deleted file mode 100644 index 4b1167c3d8..0000000000 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm_avx2/crypto/include/internal/dso_conf.h +++ /dev/null @@ -1,17 +0,0 @@ -/* WARNING: do not edit! */ -/* Generated by Makefile from include/crypto/dso_conf.h.in */ -/* - * Copyright 2016-2019 The OpenSSL Project Authors. All Rights Reserved. - * - * Licensed under the OpenSSL license (the "License"). You may not use - * this file except in compliance with the License. You can obtain a copy - * in the file LICENSE in the source distribution or at - * https://www.openssl.org/source/license.html - */ - -#ifndef OSSL_CRYPTO_DSO_CONF_H -# define OSSL_CRYPTO_DSO_CONF_H -# define DSO_DLFCN -# define HAVE_DLFCN_H -# define DSO_EXTENSION ".so" -#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm_avx2/include/openssl/opensslconf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm_avx2/include/openssl/opensslconf.h deleted file mode 100644 index dc4b7ebef3..0000000000 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/asm_avx2/include/openssl/opensslconf.h +++ /dev/null @@ -1,200 +0,0 @@ -/* - * WARNING: do not edit! - * Generated by Makefile from include/openssl/opensslconf.h.in - * - * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved. - * - * Licensed under the OpenSSL license (the "License"). You may not use - * this file except in compliance with the License. You can obtain a copy - * in the file LICENSE in the source distribution or at - * https://www.openssl.org/source/license.html - */ - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef OPENSSL_ALGORITHM_DEFINES -# error OPENSSL_ALGORITHM_DEFINES no longer supported -#endif - -/* - * OpenSSL was configured with the following options: - */ - -#ifndef OPENSSL_NO_COMP -# define OPENSSL_NO_COMP -#endif -#ifndef OPENSSL_NO_MD2 -# define OPENSSL_NO_MD2 -#endif -#ifndef OPENSSL_NO_RC5 -# define OPENSSL_NO_RC5 -#endif -#ifndef OPENSSL_THREADS -# define OPENSSL_THREADS -#endif -#ifndef OPENSSL_RAND_SEED_OS -# define OPENSSL_RAND_SEED_OS -#endif -#ifndef OPENSSL_NO_AFALGENG -# define OPENSSL_NO_AFALGENG -#endif -#ifndef OPENSSL_NO_ASAN -# define OPENSSL_NO_ASAN -#endif -#ifndef OPENSSL_NO_CRYPTO_MDEBUG -# define OPENSSL_NO_CRYPTO_MDEBUG -#endif -#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE -# define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE -#endif -#ifndef OPENSSL_NO_DEVCRYPTOENG -# define OPENSSL_NO_DEVCRYPTOENG -#endif -#ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 -# define OPENSSL_NO_EC_NISTP_64_GCC_128 -#endif -#ifndef OPENSSL_NO_EGD -# define OPENSSL_NO_EGD -#endif -#ifndef OPENSSL_NO_EXTERNAL_TESTS -# define OPENSSL_NO_EXTERNAL_TESTS -#endif -#ifndef OPENSSL_NO_FUZZ_AFL -# define OPENSSL_NO_FUZZ_AFL -#endif -#ifndef OPENSSL_NO_FUZZ_LIBFUZZER -# define OPENSSL_NO_FUZZ_LIBFUZZER -#endif -#ifndef OPENSSL_NO_HEARTBEATS -# define OPENSSL_NO_HEARTBEATS -#endif -#ifndef OPENSSL_NO_MSAN -# define OPENSSL_NO_MSAN -#endif -#ifndef OPENSSL_NO_SCTP -# define OPENSSL_NO_SCTP -#endif -#ifndef OPENSSL_NO_SSL3 -# define OPENSSL_NO_SSL3 -#endif -#ifndef OPENSSL_NO_SSL3_METHOD -# define OPENSSL_NO_SSL3_METHOD -#endif -#ifndef OPENSSL_NO_UBSAN -# define OPENSSL_NO_UBSAN -#endif -#ifndef OPENSSL_NO_UNIT_TEST -# define OPENSSL_NO_UNIT_TEST -#endif -#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS -# define OPENSSL_NO_WEAK_SSL_CIPHERS -#endif -#ifndef OPENSSL_NO_DYNAMIC_ENGINE -# define OPENSSL_NO_DYNAMIC_ENGINE -#endif - - -/* - * Sometimes OPENSSSL_NO_xxx ends up with an empty file and some compilers - * don't like that. This will hopefully silence them. - */ -#define NON_EMPTY_TRANSLATION_UNIT static void *dummy = &dummy; - -/* - * Applications should use -DOPENSSL_API_COMPAT= to suppress the - * declarations of functions deprecated in or before . Otherwise, they - * still won't see them if the library has been built to disable deprecated - * functions. - */ -#ifndef DECLARE_DEPRECATED -# define DECLARE_DEPRECATED(f) f; -# ifdef __GNUC__ -# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0) -# undef DECLARE_DEPRECATED -# define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); -# endif -# elif defined(__SUNPRO_C) -# if (__SUNPRO_C >= 0x5130) -# undef DECLARE_DEPRECATED -# define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); -# endif -# endif -#endif - -#ifndef OPENSSL_FILE -# ifdef OPENSSL_NO_FILENAMES -# define OPENSSL_FILE "" -# define OPENSSL_LINE 0 -# else -# define OPENSSL_FILE __FILE__ -# define OPENSSL_LINE __LINE__ -# endif -#endif - -#ifndef OPENSSL_MIN_API -# define OPENSSL_MIN_API 0 -#endif - -#if !defined(OPENSSL_API_COMPAT) || OPENSSL_API_COMPAT < OPENSSL_MIN_API -# undef OPENSSL_API_COMPAT -# define OPENSSL_API_COMPAT OPENSSL_MIN_API -#endif - -/* - * Do not deprecate things to be deprecated in version 1.2.0 before the - * OpenSSL version number matches. - */ -#if OPENSSL_VERSION_NUMBER < 0x10200000L -# define DEPRECATEDIN_1_2_0(f) f; -#elif OPENSSL_API_COMPAT < 0x10200000L -# define DEPRECATEDIN_1_2_0(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_1_2_0(f) -#endif - -#if OPENSSL_API_COMPAT < 0x10100000L -# define DEPRECATEDIN_1_1_0(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_1_1_0(f) -#endif - -#if OPENSSL_API_COMPAT < 0x10000000L -# define DEPRECATEDIN_1_0_0(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_1_0_0(f) -#endif - -#if OPENSSL_API_COMPAT < 0x00908000L -# define DEPRECATEDIN_0_9_8(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_0_9_8(f) -#endif - -/* Generate 80386 code? */ -#undef I386_ONLY - -#undef OPENSSL_UNISTD -#define OPENSSL_UNISTD - -#undef OPENSSL_EXPORT_VAR_AS_FUNCTION - -/* - * The following are cipher-specific, but are part of the public API. - */ -#if !defined(OPENSSL_SYS_UEFI) -# undef BN_LLONG -/* Only one for the following should be defined */ -# undef SIXTY_FOUR_BIT_LONG -# define SIXTY_FOUR_BIT -# undef THIRTY_TWO_BIT -#endif - -#define RC4_INT unsigned int - -#ifdef __cplusplus -} -#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/no-asm/crypto/include/internal/bn_conf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/no-asm/crypto/include/internal/bn_conf.h deleted file mode 100644 index 93f75e2e15..0000000000 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/no-asm/crypto/include/internal/bn_conf.h +++ /dev/null @@ -1,28 +0,0 @@ -/* WARNING: do not edit! */ -/* Generated by Makefile from include/crypto/bn_conf.h.in */ -/* - * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved. - * - * Licensed under the OpenSSL license (the "License"). You may not use - * this file except in compliance with the License. You can obtain a copy - * in the file LICENSE in the source distribution or at - * https://www.openssl.org/source/license.html - */ - -#ifndef OSSL_CRYPTO_BN_CONF_H -# define OSSL_CRYPTO_BN_CONF_H - -/* - * The contents of this file are not used in the UEFI build, as - * both 32-bit and 64-bit builds are supported from a single run - * of the Configure script. - */ - -/* Should we define BN_DIV2W here? */ - -/* Only one for the following should be defined */ -#undef SIXTY_FOUR_BIT_LONG -#define SIXTY_FOUR_BIT -#undef THIRTY_TWO_BIT - -#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/no-asm/crypto/include/internal/dso_conf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/no-asm/crypto/include/internal/dso_conf.h deleted file mode 100644 index 4b1167c3d8..0000000000 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/no-asm/crypto/include/internal/dso_conf.h +++ /dev/null @@ -1,17 +0,0 @@ -/* WARNING: do not edit! */ -/* Generated by Makefile from include/crypto/dso_conf.h.in */ -/* - * Copyright 2016-2019 The OpenSSL Project Authors. All Rights Reserved. - * - * Licensed under the OpenSSL license (the "License"). You may not use - * this file except in compliance with the License. You can obtain a copy - * in the file LICENSE in the source distribution or at - * https://www.openssl.org/source/license.html - */ - -#ifndef OSSL_CRYPTO_DSO_CONF_H -# define OSSL_CRYPTO_DSO_CONF_H -# define DSO_DLFCN -# define HAVE_DLFCN_H -# define DSO_EXTENSION ".so" -#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/no-asm/include/openssl/opensslconf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/no-asm/include/openssl/opensslconf.h deleted file mode 100644 index d78bc05bb6..0000000000 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x32/no-asm/include/openssl/opensslconf.h +++ /dev/null @@ -1,203 +0,0 @@ -/* - * WARNING: do not edit! - * Generated by Makefile from include/openssl/opensslconf.h.in - * - * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved. - * - * Licensed under the OpenSSL license (the "License"). You may not use - * this file except in compliance with the License. You can obtain a copy - * in the file LICENSE in the source distribution or at - * https://www.openssl.org/source/license.html - */ - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef OPENSSL_ALGORITHM_DEFINES -# error OPENSSL_ALGORITHM_DEFINES no longer supported -#endif - -/* - * OpenSSL was configured with the following options: - */ - -#ifndef OPENSSL_NO_COMP -# define OPENSSL_NO_COMP -#endif -#ifndef OPENSSL_NO_MD2 -# define OPENSSL_NO_MD2 -#endif -#ifndef OPENSSL_NO_RC5 -# define OPENSSL_NO_RC5 -#endif -#ifndef OPENSSL_THREADS -# define OPENSSL_THREADS -#endif -#ifndef OPENSSL_RAND_SEED_OS -# define OPENSSL_RAND_SEED_OS -#endif -#ifndef OPENSSL_NO_AFALGENG -# define OPENSSL_NO_AFALGENG -#endif -#ifndef OPENSSL_NO_ASAN -# define OPENSSL_NO_ASAN -#endif -#ifndef OPENSSL_NO_ASM -# define OPENSSL_NO_ASM -#endif -#ifndef OPENSSL_NO_CRYPTO_MDEBUG -# define OPENSSL_NO_CRYPTO_MDEBUG -#endif -#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE -# define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE -#endif -#ifndef OPENSSL_NO_DEVCRYPTOENG -# define OPENSSL_NO_DEVCRYPTOENG -#endif -#ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 -# define OPENSSL_NO_EC_NISTP_64_GCC_128 -#endif -#ifndef OPENSSL_NO_EGD -# define OPENSSL_NO_EGD -#endif -#ifndef OPENSSL_NO_EXTERNAL_TESTS -# define OPENSSL_NO_EXTERNAL_TESTS -#endif -#ifndef OPENSSL_NO_FUZZ_AFL -# define OPENSSL_NO_FUZZ_AFL -#endif -#ifndef OPENSSL_NO_FUZZ_LIBFUZZER -# define OPENSSL_NO_FUZZ_LIBFUZZER -#endif -#ifndef OPENSSL_NO_HEARTBEATS -# define OPENSSL_NO_HEARTBEATS -#endif -#ifndef OPENSSL_NO_MSAN -# define OPENSSL_NO_MSAN -#endif -#ifndef OPENSSL_NO_SCTP -# define OPENSSL_NO_SCTP -#endif -#ifndef OPENSSL_NO_SSL3 -# define OPENSSL_NO_SSL3 -#endif -#ifndef OPENSSL_NO_SSL3_METHOD -# define OPENSSL_NO_SSL3_METHOD -#endif -#ifndef OPENSSL_NO_UBSAN -# define OPENSSL_NO_UBSAN -#endif -#ifndef OPENSSL_NO_UNIT_TEST -# define OPENSSL_NO_UNIT_TEST -#endif -#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS -# define OPENSSL_NO_WEAK_SSL_CIPHERS -#endif -#ifndef OPENSSL_NO_DYNAMIC_ENGINE -# define OPENSSL_NO_DYNAMIC_ENGINE -#endif - - -/* - * Sometimes OPENSSSL_NO_xxx ends up with an empty file and some compilers - * don't like that. This will hopefully silence them. - */ -#define NON_EMPTY_TRANSLATION_UNIT static void *dummy = &dummy; - -/* - * Applications should use -DOPENSSL_API_COMPAT= to suppress the - * declarations of functions deprecated in or before . Otherwise, they - * still won't see them if the library has been built to disable deprecated - * functions. - */ -#ifndef DECLARE_DEPRECATED -# define DECLARE_DEPRECATED(f) f; -# ifdef __GNUC__ -# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0) -# undef DECLARE_DEPRECATED -# define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); -# endif -# elif defined(__SUNPRO_C) -# if (__SUNPRO_C >= 0x5130) -# undef DECLARE_DEPRECATED -# define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated)); -# endif -# endif -#endif - -#ifndef OPENSSL_FILE -# ifdef OPENSSL_NO_FILENAMES -# define OPENSSL_FILE "" -# define OPENSSL_LINE 0 -# else -# define OPENSSL_FILE __FILE__ -# define OPENSSL_LINE __LINE__ -# endif -#endif - -#ifndef OPENSSL_MIN_API -# define OPENSSL_MIN_API 0 -#endif - -#if !defined(OPENSSL_API_COMPAT) || OPENSSL_API_COMPAT < OPENSSL_MIN_API -# undef OPENSSL_API_COMPAT -# define OPENSSL_API_COMPAT OPENSSL_MIN_API -#endif - -/* - * Do not deprecate things to be deprecated in version 1.2.0 before the - * OpenSSL version number matches. - */ -#if OPENSSL_VERSION_NUMBER < 0x10200000L -# define DEPRECATEDIN_1_2_0(f) f; -#elif OPENSSL_API_COMPAT < 0x10200000L -# define DEPRECATEDIN_1_2_0(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_1_2_0(f) -#endif - -#if OPENSSL_API_COMPAT < 0x10100000L -# define DEPRECATEDIN_1_1_0(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_1_1_0(f) -#endif - -#if OPENSSL_API_COMPAT < 0x10000000L -# define DEPRECATEDIN_1_0_0(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_1_0_0(f) -#endif - -#if OPENSSL_API_COMPAT < 0x00908000L -# define DEPRECATEDIN_0_9_8(f) DECLARE_DEPRECATED(f) -#else -# define DEPRECATEDIN_0_9_8(f) -#endif - -/* Generate 80386 code? */ -#undef I386_ONLY - -#undef OPENSSL_UNISTD -#define OPENSSL_UNISTD - -#undef OPENSSL_EXPORT_VAR_AS_FUNCTION - -/* - * The following are cipher-specific, but are part of the public API. - */ -#if !defined(OPENSSL_SYS_UEFI) -# undef BN_LLONG -/* Only one for the following should be defined */ -# undef SIXTY_FOUR_BIT_LONG -# define SIXTY_FOUR_BIT -# undef THIRTY_TWO_BIT -#endif - -#define RC4_INT unsigned int - -#ifdef __cplusplus -} -#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/asm/crypto/buildinf.h index 45a6b73dbb..36bbb495dd 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-x86_64" -#define DATE "built on: Tue Mar 15 19:23:23 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:16 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/asm_avx2/crypto/buildinf.h index e9e3220f66..0c5a403f80 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-x86_64" -#define DATE "built on: Tue Mar 15 19:23:30 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:20 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/no-asm/crypto/buildinf.h index ed1411781e..893978987f 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux-x86_64/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux-x86_64" -#define DATE "built on: Tue Mar 15 19:23:39 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:24 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/asm/crypto/buildinf.h index 8d5ac45dcf..11fc73ddb7 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux32-s390x" -#define DATE "built on: Tue Mar 15 19:24:28 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:41 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/asm_avx2/crypto/buildinf.h index 85e7099239..a9345d1aa2 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux32-s390x" -#define DATE "built on: Tue Mar 15 19:24:32 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:42 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/no-asm/crypto/buildinf.h index c38fc3cb83..f96b9c0cd0 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux32-s390x/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux32-s390x" -#define DATE "built on: Tue Mar 15 19:24:36 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:44 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/asm/crypto/buildinf.h index 2d190f7b15..8beb0fa40b 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux64-mips64" -#define DATE "built on: Tue Mar 15 19:24:52 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:49 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/asm_avx2/crypto/buildinf.h index ed17ce53a8..74f5405bd4 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux64-mips64" -#define DATE "built on: Tue Mar 15 19:24:56 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:50 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/no-asm/crypto/buildinf.h index 153107ddc5..92a66095a2 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-mips64/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux64-mips64" -#define DATE "built on: Tue Mar 15 19:25:01 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:52 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-riscv64/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-riscv64/no-asm/crypto/buildinf.h index cb5095e1fa..351be58ada 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-riscv64/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-riscv64/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux64-riscv64" -#define DATE "built on: Tue Mar 15 19:26:41 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:24 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/asm/crypto/buildinf.h index 0031d17156..c6f102c7ef 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux64-s390x" -#define DATE "built on: Tue Mar 15 19:24:40 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:45 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/asm_avx2/crypto/buildinf.h index 18f6ab52b2..78722e7f42 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux64-s390x" -#define DATE "built on: Tue Mar 15 19:24:44 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:46 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/no-asm/crypto/buildinf.h index 0975b9ddda..cfff6dfbe9 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/linux64-s390x/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: linux64-s390x" -#define DATE "built on: Tue Mar 15 19:24:49 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:48 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/asm/crypto/buildinf.h index 52fc5a54e6..3086661fbb 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: solaris-x86-gcc" -#define DATE "built on: Tue Mar 15 19:25:04 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:53 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/asm_avx2/crypto/buildinf.h index 2434d0042c..0b32f9b112 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: solaris-x86-gcc" -#define DATE "built on: Tue Mar 15 19:25:11 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:55 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/no-asm/crypto/buildinf.h index c13a185042..ddf5be1c84 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris-x86-gcc/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: solaris-x86-gcc" -#define DATE "built on: Tue Mar 15 19:25:17 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:57 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/asm/crypto/buildinf.h index 1073c53cb3..889eaeb414 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: solaris64-x86_64-gcc" -#define DATE "built on: Tue Mar 15 19:25:21 2022 UTC" +#define DATE "built on: Tue Jul 5 15:03:58 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/asm_avx2/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/asm_avx2/crypto/buildinf.h index 5155d00a7e..761e974c4d 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/asm_avx2/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/asm_avx2/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: solaris64-x86_64-gcc" -#define DATE "built on: Tue Mar 15 19:25:35 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:03 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/no-asm/crypto/buildinf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/no-asm/crypto/buildinf.h index b37132f28f..b5742d321b 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/no-asm/crypto/buildinf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/archs/solaris64-x86_64-gcc/no-asm/crypto/buildinf.h @@ -11,7 +11,7 @@ */ #define PLATFORM "platform: solaris64-x86_64-gcc" -#define DATE "built on: Tue Mar 15 19:25:48 2022 UTC" +#define DATE "built on: Tue Jul 5 15:04:07 2022 UTC" /* * Generate compiler_flags as an array of individual characters. This is a diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1_asm.h new file mode 100644 index 0000000000..4d36824465 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/asn1.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/asn1.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/asn1.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/asn1.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/asn1.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/asn1.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/asn1.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/asn1.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/asn1.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/asn1.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/asn1.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/asn1.h" +#else +# include "./archs/linux-elf/asm/include/openssl/asn1.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1_no-asm.h new file mode 100644 index 0000000000..2478123862 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/asn1.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/asn1.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/asn1.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/asn1.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/asn1.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/asn1.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/asn1.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/asn1.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/asn1.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/asn1.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/asn1.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/asn1.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/asn1.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/asn1.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/asn1.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1t_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1t_asm.h new file mode 100644 index 0000000000..fbd767cb5b --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1t_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/asn1t.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/asn1t.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/asn1t.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/asn1t.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/asn1t.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/asn1t.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/asn1t.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/asn1t.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/asn1t.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/asn1t.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/asn1t.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/asn1t.h" +#else +# include "./archs/linux-elf/asm/include/openssl/asn1t.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1t_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1t_no-asm.h new file mode 100644 index 0000000000..67c1791e3c --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/asn1t_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/asn1t.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/asn1t.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/asn1t.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/asn1t.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/asn1t.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/asn1t.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/asn1t.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/asn1t.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/asn1t.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/asn1t.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/asn1t.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/asn1t.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/asn1t.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/asn1t.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/asn1t.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bio_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bio_asm.h new file mode 100644 index 0000000000..202e9eb223 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bio_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/bio.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/bio.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/bio.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/bio.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/bio.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/bio.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/bio.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/bio.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/bio.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/bio.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/bio.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/bio.h" +#else +# include "./archs/linux-elf/asm/include/openssl/bio.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bio_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bio_no-asm.h new file mode 100644 index 0000000000..9328869800 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bio_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/bio.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/bio.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/bio.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/bio.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/bio.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/bio.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/bio.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/bio.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/bio.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/bio.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/bio.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/bio.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/bio.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/bio.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/bio.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bn_conf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bn_conf.h new file mode 100644 index 0000000000..44d7d4d6e3 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bn_conf.h @@ -0,0 +1,5 @@ +#if defined(OPENSSL_NO_ASM) +# include "./bn_conf_no-asm.h" +#else +# include "./bn_conf_asm.h" +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bn_conf_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bn_conf_asm.h new file mode 100644 index 0000000000..800aad79c0 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bn_conf_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/crypto/include/internal/bn_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/crypto/include/internal/bn_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/crypto/include/internal/bn_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/crypto/include/internal/bn_conf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/crypto/include/internal/bn_conf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/crypto/include/internal/bn_conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/crypto/include/internal/bn_conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/crypto/include/internal/bn_conf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/crypto/include/internal/bn_conf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/crypto/include/internal/bn_conf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc/asm/crypto/include/internal/bn_conf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/crypto/include/internal/bn_conf.h" +#else +# include "./archs/linux-elf/asm/crypto/include/internal/bn_conf.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bn_conf_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bn_conf_no-asm.h new file mode 100644 index 0000000000..cc86048599 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/bn_conf_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/crypto/include/internal/bn_conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/crypto/include/internal/bn_conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/crypto/include/internal/bn_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/crypto/include/internal/bn_conf.h" +#else +# include "./archs/linux-elf/no-asm/crypto/include/internal/bn_conf.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cmp_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cmp_asm.h new file mode 100644 index 0000000000..160d3caae5 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cmp_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/cmp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/cmp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/cmp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/cmp.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/cmp.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/cmp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/cmp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/cmp.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/cmp.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/cmp.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/cmp.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/cmp.h" +#else +# include "./archs/linux-elf/asm/include/openssl/cmp.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cmp_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cmp_no-asm.h new file mode 100644 index 0000000000..1221649ef2 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cmp_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/cmp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/cmp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/cmp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/cmp.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/cmp.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/cmp.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/cmp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/cmp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/cmp.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/cmp.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/cmp.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/cmp.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/cmp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/cmp.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/cmp.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cms_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cms_asm.h new file mode 100644 index 0000000000..886b77ad5b --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cms_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/cms.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/cms.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/cms.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/cms.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/cms.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/cms.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/cms.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/cms.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/cms.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/cms.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/cms.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/cms.h" +#else +# include "./archs/linux-elf/asm/include/openssl/cms.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cms_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cms_no-asm.h new file mode 100644 index 0000000000..ac89ec8a4a --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/cms_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/cms.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/cms.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/cms.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/cms.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/cms.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/cms.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/cms.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/cms.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/cms.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/cms.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/cms.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/cms.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/cms.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/cms.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/cms.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/conf_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/conf_asm.h new file mode 100644 index 0000000000..60a4d475b5 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/conf_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/conf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/conf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/conf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/conf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/conf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/conf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/conf.h" +#else +# include "./archs/linux-elf/asm/include/openssl/conf.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/conf_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/conf_no-asm.h new file mode 100644 index 0000000000..0bf0c97e62 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/conf_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/conf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/conf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/conf.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/conf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/conf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/conf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/conf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/conf.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/conf.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/configuration_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/configuration_asm.h new file mode 100644 index 0000000000..badc4dabde --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/configuration_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/configuration.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/configuration.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/configuration.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/configuration.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/configuration.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/configuration.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/configuration.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/configuration.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/configuration.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/configuration.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/configuration.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/configuration.h" +#else +# include "./archs/linux-elf/asm/include/openssl/configuration.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/configuration_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/configuration_no-asm.h new file mode 100644 index 0000000000..ab50549924 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/configuration_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/configuration.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/configuration.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/configuration.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/configuration.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/configuration.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/configuration.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/configuration.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/configuration.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/configuration.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/configuration.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/configuration.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/configuration.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/configuration.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/configuration.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/configuration.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crmf_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crmf_asm.h new file mode 100644 index 0000000000..1378bd7988 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crmf_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/crmf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/crmf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/crmf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/crmf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/crmf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/crmf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/crmf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/crmf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/crmf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/crmf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/crmf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/crmf.h" +#else +# include "./archs/linux-elf/asm/include/openssl/crmf.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crmf_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crmf_no-asm.h new file mode 100644 index 0000000000..0a14cc86bb --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crmf_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/crmf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/crmf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/crmf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/crmf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/crmf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/crmf.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/crmf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/crmf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/crmf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/crmf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/crmf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/crmf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/crmf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/crmf.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/crmf.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crypto_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crypto_asm.h new file mode 100644 index 0000000000..23643c9661 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crypto_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/crypto.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/crypto.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/crypto.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/crypto.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/crypto.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/crypto.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/crypto.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/crypto.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/crypto.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/crypto.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/crypto.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/crypto.h" +#else +# include "./archs/linux-elf/asm/include/openssl/crypto.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crypto_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crypto_no-asm.h new file mode 100644 index 0000000000..9b63cb3b0a --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/crypto_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/crypto.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/crypto.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/crypto.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/crypto.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/crypto.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/crypto.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/crypto.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/crypto.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/crypto.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/crypto.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/crypto.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/crypto.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/crypto.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/crypto.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/crypto.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ct_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ct_asm.h new file mode 100644 index 0000000000..01484b070e --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ct_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/ct.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/ct.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/ct.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/ct.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/ct.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/ct.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/ct.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/ct.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/ct.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/ct.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/ct.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/ct.h" +#else +# include "./archs/linux-elf/asm/include/openssl/ct.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ct_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ct_no-asm.h new file mode 100644 index 0000000000..f4b0d8da49 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ct_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/ct.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/ct.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/ct.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/ct.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/ct.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/ct.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/ct.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/ct.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/ct.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/ct.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/ct.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/ct.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/ct.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/ct.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/ct.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/dso_conf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/dso_conf.h new file mode 100644 index 0000000000..55e48784d3 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/dso_conf.h @@ -0,0 +1,5 @@ +#if defined(OPENSSL_NO_ASM) +# include "./dso_conf_no-asm.h" +#else +# include "./dso_conf_asm.h" +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/dso_conf_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/dso_conf_asm.h new file mode 100644 index 0000000000..c4c9d5749b --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/dso_conf_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/crypto/include/internal/dso_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/crypto/include/internal/dso_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/crypto/include/internal/dso_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/crypto/include/internal/dso_conf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/crypto/include/internal/dso_conf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/crypto/include/internal/dso_conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/crypto/include/internal/dso_conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/crypto/include/internal/dso_conf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/crypto/include/internal/dso_conf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/crypto/include/internal/dso_conf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc/asm/crypto/include/internal/dso_conf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/crypto/include/internal/dso_conf.h" +#else +# include "./archs/linux-elf/asm/crypto/include/internal/dso_conf.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/dso_conf_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/dso_conf_no-asm.h new file mode 100644 index 0000000000..1c4a2ca39d --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/dso_conf_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/crypto/include/internal/dso_conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/crypto/include/internal/dso_conf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/crypto/include/internal/dso_conf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/crypto/include/internal/dso_conf.h" +#else +# include "./archs/linux-elf/no-asm/crypto/include/internal/dso_conf.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/err_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/err_asm.h new file mode 100644 index 0000000000..d03d4603d6 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/err_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/err.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/err.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/err.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/err.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/err.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/err.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/err.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/err.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/err.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/err.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/err.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/err.h" +#else +# include "./archs/linux-elf/asm/include/openssl/err.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/err_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/err_no-asm.h new file mode 100644 index 0000000000..ea4ef7a056 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/err_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/err.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/err.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/err.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/err.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/err.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/err.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/err.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/err.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/err.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/err.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/err.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/err.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/err.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/err.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/err.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ess_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ess_asm.h new file mode 100644 index 0000000000..02f973e02d --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ess_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/ess.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/ess.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/ess.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/ess.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/ess.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/ess.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/ess.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/ess.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/ess.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/ess.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/ess.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/ess.h" +#else +# include "./archs/linux-elf/asm/include/openssl/ess.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ess_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ess_no-asm.h new file mode 100644 index 0000000000..e906bafe8d --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ess_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/ess.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/ess.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/ess.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/ess.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/ess.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/ess.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/ess.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/ess.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/ess.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/ess.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/ess.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/ess.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/ess.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/ess.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/ess.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/fipskey_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/fipskey_asm.h new file mode 100644 index 0000000000..9e4ddbd495 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/fipskey_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/fipskey.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/fipskey.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/fipskey.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/fipskey.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/fipskey.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/fipskey.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/fipskey.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/fipskey.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/fipskey.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/fipskey.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/fipskey.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/fipskey.h" +#else +# include "./archs/linux-elf/asm/include/openssl/fipskey.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/fipskey_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/fipskey_no-asm.h new file mode 100644 index 0000000000..a760a02ba3 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/fipskey_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/fipskey.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/fipskey.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/fipskey.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/fipskey.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/fipskey.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/fipskey.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/fipskey.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/fipskey.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/fipskey.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/fipskey.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/fipskey.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/fipskey.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/fipskey.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/fipskey.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/fipskey.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/lhash_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/lhash_asm.h new file mode 100644 index 0000000000..1302555043 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/lhash_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/lhash.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/lhash.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/lhash.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/lhash.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/lhash.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/lhash.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/lhash.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/lhash.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/lhash.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/lhash.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/lhash.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/lhash.h" +#else +# include "./archs/linux-elf/asm/include/openssl/lhash.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/lhash_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/lhash_no-asm.h new file mode 100644 index 0000000000..62953f7629 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/lhash_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/lhash.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/lhash.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/lhash.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/lhash.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/lhash.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/lhash.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/lhash.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/lhash.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/lhash.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/lhash.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/lhash.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/lhash.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/lhash.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/lhash.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/lhash.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ocsp_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ocsp_asm.h new file mode 100644 index 0000000000..4483fff2a4 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ocsp_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/ocsp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/ocsp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/ocsp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/ocsp.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/ocsp.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/ocsp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/ocsp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/ocsp.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/ocsp.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/ocsp.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/ocsp.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/ocsp.h" +#else +# include "./archs/linux-elf/asm/include/openssl/ocsp.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ocsp_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ocsp_no-asm.h new file mode 100644 index 0000000000..0bf5594521 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ocsp_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/ocsp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/ocsp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/ocsp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/ocsp.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/ocsp.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/ocsp.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/ocsp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/ocsp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/ocsp.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/ocsp.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/ocsp.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/ocsp.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/ocsp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/ocsp.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/ocsp.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf.h index 76c99d433a..f5b3b013d8 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf.h @@ -1 +1,30 @@ -#include "../../config/opensslconf.h" +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_NO_ASM) +# include "./opensslconf_no-asm.h" +#else +# include "./opensslconf_asm.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif +/* iOS app store won't allow getcontext, setcontext, makecontext */ +#if defined(__APPLE__) && defined(__MACH__) +# include +# if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE +# define OPENSSL_NO_ASYNC +# endif +#endif +/* musl in Alpine Linux does not support getcontext etc.*/ +#if defined(OPENSSL_LINUX) && !defined(__GLIBC__) && !defined(__clang__) +# define OPENSSL_NO_ASYNC +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf_asm.h new file mode 100644 index 0000000000..8c2dbd40d0 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf_asm.h @@ -0,0 +1,138 @@ +/* + In OpenSSL, opensslconf.h was generated by Configure script with + specifying a target argument, where it includes several defines that + depend on OS and architecture platform. + + In node, we statically mapped --dest-os and --dest-cpu options in + configure to the target of Configure in OpenSSL and make + `deps/openssl/conf/openssconf.h` so as to include each file + according to its target by checking pre-defined compiler macros. + + Included opnesslconf.h files for supported target architectures can + be generated by `Makefile` and stored under + `archs/{target}/asm/opensslconf.h`. The Makefile also fixes several + defines to meet node build requirements. + + Here is a map table of configure options in node, target arch of + Configure in OpenSSL and CI support. + + | --dest-os | --dest-cpu | OpenSSL target arch | CI | + | --------- | ---------- | -------------------- | --- | + | aix | ppc | aix-gcc | o | + | aix | ppc64 | aix64-gcc | o | + | linux | ia32 | linux-elf | o | + | linux | x32 | linux-x32 | - | + | linux | x64 | linux-x86_64 | o | + | linux | arm | linux-armv4 | o | + | linux | arm64 | linux-aarch64 | o | + | linux | ppc | linux-ppc | o | + | linux | ppc64 | linux-ppc64 | o | + | linux | ppc64 | linux-ppc64le | o | (node_byteoder: little) + | linux | s390 | linux32-s390x | o | + | linux | s390x | linux64-s390x | o | + | mac | ia32 | darwin-i386-cc | - | + | mac | x64 | darwin64-x86-cc | o | + | mac | arm64 | darwin64-arm64-cc | - | + | win | ia32 | VC-WIN32 | - | + | win | x64 | VC-WIN64A | o | + | solaris | ia32 | solaris-x86-gcc | o | + | solaris | x64 | solaris64-x86_64-gcc | o | + | freebsd | ia32 | BSD-x86 | - | + | freebsd | x64 | BSD-x86_64 | o | + | openbsd | ia32 | BSD-x86 | - | + | openbsd | x64 | BSD-x86_64 | - | + | others | others | linux-elf | - | + + --dest-os and --dest-cpu are mapped to pre-defined macros. + + | --dest-os | pre-defined macro | + | ------------------ | ------------------------- | + | aix | _AIX | + | win | _WIN32 | + | win(64bit) | _WIN64 | + | mac | __APPLE__ && __MACH__ | + | solaris | __sun | + | freebsd | __FreeBSD__ | + | openbsd | __OpenBSD__ | + | linux (not andorid)| __linux__ && !__ANDROID__ | + | android | __ANDROID__ | + + | --dest-cpu | pre-defined macro | + | ---------- | ----------------- | + | arm | __arm__ | + | arm64 | __aarch64__ | + | ia32 | __i386__ | + | ia32(win) | _M_IX86 | + | mips | __mips__ | + | mipsel | __MIPSEL__ | + | x32 | __ILP32__ | + | x64 | __x86_64__ | + | x64(win) | _M_X64 | + | ppc | __PPC__ | + | | _ARCH_PPC | + | ppc64 | __PPC64__ | + | | _ARCH_PPC64 | + | s390 | __s390__ | + | s390x | __s390x__ | + + These are the list which is not implemented yet. + + | --dest-os | --dest-cpu | OpenSSL target arch | CI | + | --------- | ---------- | -------------------- | --- | + | linux | mips | linux-mips32,linux-mips64,linux64-mips64? | --- | + | linux | mipsel | ? | --- | + | android | ia32 | android-x86 | --- | + | android | arm | android-armv7 | --- | + | android | mips | android-mips | --- | + | android | mipsel | ? | --- | + + Supported target arch list in OpenSSL can be obtained by typing + `deps/openssl/openssl/Configure LIST`. + +*/ + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/opensslconf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/opensslconf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/opensslconf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/opensslconf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/opensslconf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/opensslconf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/opensslconf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/opensslconf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/opensslconf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/opensslconf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc/asm/include/openssl/opensslconf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__mips64) && defined(__MIPSEL__) +# include "./archs/linux64-mips64/asm/include/openssl/opensslconf.h" +#else +# include "./archs/linux-elf/asm/include/openssl/opensslconf.h" +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf_no-asm.h new file mode 100644 index 0000000000..ee9d5e95f1 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslconf_no-asm.h @@ -0,0 +1,47 @@ +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/opensslconf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/opensslconf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/opensslconf.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/opensslconf.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/opensslconf.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/opensslconf.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/opensslconf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/opensslconf.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/opensslconf.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/opensslconf.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/opensslconf.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc/no-asm/include/openssl/opensslconf.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/opensslconf.h" +#elif defined(OPENSSL_LINUX) && defined(__mips64) && defined(__MIPSEL__) +# include "./archs/linux64-mips64/no-asm/include/openssl/opensslconf.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/opensslconf.h" +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv.h index 5efa7860a0..dafc04109b 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv.h @@ -1,5 +1,5 @@ /* - * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved. + * Copyright 1999-2022 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the OpenSSL license (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy @@ -39,8 +39,8 @@ extern "C" { * (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for * major minor fix final patch/beta) */ -# define OPENSSL_VERSION_NUMBER 0x101010efL -# define OPENSSL_VERSION_TEXT "OpenSSL 1.1.1n+quic 15 Mar 2022" +# define OPENSSL_VERSION_NUMBER 0x1010111fL +# define OPENSSL_VERSION_TEXT "OpenSSL 1.1.1q+quic 5 Jul 2022" /*- * The macros below are to be used for shared library (.so, .dll, ...) diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv_asm.h new file mode 100644 index 0000000000..29879561cb --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/opensslv.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/opensslv.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/opensslv.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/opensslv.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/opensslv.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/opensslv.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/opensslv.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/opensslv.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/opensslv.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/opensslv.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/opensslv.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/opensslv.h" +#else +# include "./archs/linux-elf/asm/include/openssl/opensslv.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv_no-asm.h new file mode 100644 index 0000000000..dee43fec48 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/opensslv_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/opensslv.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/opensslv.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/opensslv.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/opensslv.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/opensslv.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/opensslv.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/opensslv.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/opensslv.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/opensslv.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/opensslv.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/opensslv.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/opensslv.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/opensslv.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/opensslv.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/opensslv.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs12_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs12_asm.h new file mode 100644 index 0000000000..54ad973bc2 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs12_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/pkcs12.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/pkcs12.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/pkcs12.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/pkcs12.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/pkcs12.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/pkcs12.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/pkcs12.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/pkcs12.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/pkcs12.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/pkcs12.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/pkcs12.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/pkcs12.h" +#else +# include "./archs/linux-elf/asm/include/openssl/pkcs12.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs12_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs12_no-asm.h new file mode 100644 index 0000000000..359e4fb91c --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs12_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/pkcs12.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/pkcs12.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/pkcs12.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/pkcs12.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/pkcs12.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/pkcs12.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/pkcs12.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/pkcs12.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/pkcs12.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/pkcs12.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/pkcs12.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/pkcs12.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/pkcs12.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/pkcs12.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/pkcs12.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs7_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs7_asm.h new file mode 100644 index 0000000000..b31241b99c --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs7_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/pkcs7.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/pkcs7.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/pkcs7.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/pkcs7.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/pkcs7.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/pkcs7.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/pkcs7.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/pkcs7.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/pkcs7.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/pkcs7.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/pkcs7.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/pkcs7.h" +#else +# include "./archs/linux-elf/asm/include/openssl/pkcs7.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs7_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs7_no-asm.h new file mode 100644 index 0000000000..1f4cc511c9 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/pkcs7_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/pkcs7.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/pkcs7.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/pkcs7.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/pkcs7.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/pkcs7.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/pkcs7.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/pkcs7.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/pkcs7.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/pkcs7.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/pkcs7.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/pkcs7.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/pkcs7.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/pkcs7.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/pkcs7.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/pkcs7.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/safestack_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/safestack_asm.h new file mode 100644 index 0000000000..dea445272c --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/safestack_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/safestack.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/safestack.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/safestack.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/safestack.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/safestack.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/safestack.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/safestack.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/safestack.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/safestack.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/safestack.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/safestack.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/safestack.h" +#else +# include "./archs/linux-elf/asm/include/openssl/safestack.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/safestack_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/safestack_no-asm.h new file mode 100644 index 0000000000..eb13776bff --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/safestack_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/safestack.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/safestack.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/safestack.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/safestack.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/safestack.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/safestack.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/safestack.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/safestack.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/safestack.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/safestack.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/safestack.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/safestack.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/safestack.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/safestack.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/safestack.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/srp_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/srp_asm.h new file mode 100644 index 0000000000..2d7aa65557 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/srp_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/srp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/srp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/srp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/srp.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/srp.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/srp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/srp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/srp.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/srp.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/srp.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/srp.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/srp.h" +#else +# include "./archs/linux-elf/asm/include/openssl/srp.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/srp_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/srp_no-asm.h new file mode 100644 index 0000000000..ffb42b9294 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/srp_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/srp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/srp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/srp.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/srp.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/srp.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/srp.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/srp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/srp.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/srp.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/srp.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/srp.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/srp.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/srp.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/srp.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/srp.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl.h index 17bd0bc2c9..63ee3baae7 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl.h @@ -1,5 +1,5 @@ /* - * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. + * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * @@ -1305,6 +1305,8 @@ DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION) # define SSL_CTRL_GET_MAX_PROTO_VERSION 131 # define SSL_CTRL_GET_SIGNATURE_NID 132 # define SSL_CTRL_GET_TMP_KEY 133 +# define SSL_CTRL_GET_VERIFY_CERT_STORE 137 +# define SSL_CTRL_GET_CHAIN_CERT_STORE 138 # define SSL_CERT_SET_FIRST 1 # define SSL_CERT_SET_NEXT 2 # define SSL_CERT_SET_SERVER 3 @@ -1360,10 +1362,14 @@ DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION) SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st)) # define SSL_CTX_set1_verify_cert_store(ctx,st) \ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st)) +# define SSL_CTX_get0_verify_cert_store(ctx,st) \ + SSL_CTX_ctrl(ctx,SSL_CTRL_GET_VERIFY_CERT_STORE,0,(char *)(st)) # define SSL_CTX_set0_chain_cert_store(ctx,st) \ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st)) # define SSL_CTX_set1_chain_cert_store(ctx,st) \ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st)) +# define SSL_CTX_get0_chain_cert_store(ctx,st) \ + SSL_CTX_ctrl(ctx,SSL_CTRL_GET_CHAIN_CERT_STORE,0,(char *)(st)) # define SSL_set0_chain(s,sk) \ SSL_ctrl(s,SSL_CTRL_CHAIN,0,(char *)(sk)) # define SSL_set1_chain(s,sk) \ @@ -1386,10 +1392,14 @@ DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION) SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st)) # define SSL_set1_verify_cert_store(s,st) \ SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st)) +#define SSL_get0_verify_cert_store(s,st) \ + SSL_ctrl(s,SSL_CTRL_GET_VERIFY_CERT_STORE,0,(char *)(st)) # define SSL_set0_chain_cert_store(s,st) \ SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st)) # define SSL_set1_chain_cert_store(s,st) \ SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st)) +#define SSL_get0_chain_cert_store(s,st) \ + SSL_ctrl(s,SSL_CTRL_GET_CHAIN_CERT_STORE,0,(char *)(st)) # define SSL_get1_groups(s, glist) \ SSL_ctrl(s,SSL_CTRL_GET_GROUPS,0,(int*)(glist)) # define SSL_CTX_set1_groups(ctx, glist, glistlen) \ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl_asm.h new file mode 100644 index 0000000000..2fb2e122d1 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/ssl.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/ssl.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/ssl.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/ssl.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/ssl.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/ssl.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/ssl.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/ssl.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/ssl.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/ssl.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/ssl.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/ssl.h" +#else +# include "./archs/linux-elf/asm/include/openssl/ssl.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl_no-asm.h new file mode 100644 index 0000000000..c64d4370cb --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ssl_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/ssl.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/ssl.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/ssl.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/ssl.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/ssl.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/ssl.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/ssl.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/ssl.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/ssl.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/ssl.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/ssl.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/ssl.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/ssl.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/ssl.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/ssl.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ui_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ui_asm.h new file mode 100644 index 0000000000..14b609002c --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ui_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/ui.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/ui.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/ui.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/ui.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/ui.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/ui.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/ui.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/ui.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/ui.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/ui.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/ui.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/ui.h" +#else +# include "./archs/linux-elf/asm/include/openssl/ui.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ui_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ui_no-asm.h new file mode 100644 index 0000000000..fd248b2b05 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/ui_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/ui.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/ui.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/ui.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/ui.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/ui.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/ui.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/ui.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/ui.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/ui.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/ui.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/ui.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/ui.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/ui.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/ui.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/ui.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_asm.h new file mode 100644 index 0000000000..2f5d611d46 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/x509.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/x509.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/x509.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/x509.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/x509.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/x509.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/x509.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/x509.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/x509.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/x509.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/x509.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/x509.h" +#else +# include "./archs/linux-elf/asm/include/openssl/x509.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_no-asm.h new file mode 100644 index 0000000000..155f2993b3 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/x509.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/x509.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/x509.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/x509.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/x509.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/x509.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/x509.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/x509.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/x509.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/x509.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/x509.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/x509.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/x509.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/x509.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/x509.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_vfy_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_vfy_asm.h new file mode 100644 index 0000000000..7358b59502 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_vfy_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/x509_vfy.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/x509_vfy.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/x509_vfy.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/x509_vfy.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/x509_vfy.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/x509_vfy.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/x509_vfy.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/x509_vfy.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/x509_vfy.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/x509_vfy.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/x509_vfy.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/x509_vfy.h" +#else +# include "./archs/linux-elf/asm/include/openssl/x509_vfy.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_vfy_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_vfy_no-asm.h new file mode 100644 index 0000000000..7c74250623 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509_vfy_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/x509_vfy.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/x509_vfy.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/x509_vfy.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/x509_vfy.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/x509_vfy.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/x509_vfy.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/x509_vfy.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/x509_vfy.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/x509_vfy.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/x509_vfy.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/x509_vfy.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/x509_vfy.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/x509_vfy.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/x509_vfy.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/x509_vfy.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509v3_asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509v3_asm.h new file mode 100644 index 0000000000..4010230776 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509v3_asm.h @@ -0,0 +1,57 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/asm/include/openssl/x509v3.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/asm/include/openssl/x509v3.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/asm/include/openssl/x509v3.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/asm/include/openssl/x509v3.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/asm/include/openssl/x509v3.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/asm/include/openssl/x509v3.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/asm/include/openssl/x509v3.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/asm/include/openssl/x509v3.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/asm/include/openssl/x509v3.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/asm/include/openssl/x509v3.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/asm/include/openssl/x509v3.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/asm/include/openssl/x509v3.h" +#else +# include "./archs/linux-elf/asm/include/openssl/x509v3.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509v3_no-asm.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509v3_no-asm.h new file mode 100644 index 0000000000..ce9001ac20 --- /dev/null +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/openssl/x509v3_no-asm.h @@ -0,0 +1,59 @@ +#undef OPENSSL_LINUX +#if defined(__linux) && !defined(__ANDROID__) +# define OPENSSL_LINUX 1 +#endif + +#if defined(OPENSSL_LINUX) && defined(__i386__) +# include "./archs/linux-elf/no-asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__x86_64__) +# include "./archs/linux-x86_64/no-asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__arm__) +# include "./archs/linux-armv4/no-asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__aarch64__) +# include "./archs/linux-aarch64/no-asm/include/openssl/x509v3.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +# include "./archs/darwin-i386-cc/no-asm/include/openssl/x509v3.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__x86_64__) +# include "./archs/darwin64-x86_64-cc/no-asm/include/openssl/x509v3.h" +#elif defined(__APPLE__) && defined(__MACH__) && defined(__arm64__) +# include "./archs/darwin64-arm64-cc/no-asm/include/openssl/x509v3.h" +#elif defined(_WIN32) && defined(_M_IX86) +# include "./archs/VC-WIN32/no-asm/include/openssl/x509v3.h" +#elif defined(_WIN32) && defined(_M_X64) +# include "./archs/VC-WIN64A/no-asm/include/openssl/x509v3.h" +#elif defined(_WIN32) && defined(_M_ARM64) +# include "./archs/VC-WIN64-ARM/no-asm/include/openssl/x509v3.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__i386__) +# include "./archs/BSD-x86/no-asm/include/openssl/x509v3.h" +#elif (defined(__FreeBSD__) || defined(__OpenBSD__)) && defined(__x86_64__) +# include "./archs/BSD-x86_64/no-asm/include/openssl/x509v3.h" +#elif defined(__sun) && defined(__i386__) +# include "./archs/solaris-x86-gcc/no-asm/include/openssl/x509v3.h" +#elif defined(__sun) && defined(__x86_64__) +# include "./archs/solaris64-x86_64-gcc/no-asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) && defined(L_ENDIAN) +# include "./archs/linux-ppc64le/no-asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__PPC64__) +# include "./archs/linux-ppc64/no-asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && !defined(__PPC64__) && defined(__ppc__) +# include "./archs/linux-ppc/no-asm/include/openssl/x509v3.h" +#elif defined(_AIX) && defined(_ARCH_PPC64) +# include "./archs/aix64-gcc-as/no-asm/include/openssl/x509v3.h" +#elif defined(_AIX) && !defined(_ARCH_PPC64) && defined(_ARCH_PPC) +# include "./archs/aix-gcc/no-asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__s390x__) +# include "./archs/linux64-s390x/no-asm/include/openssl/x509v3.h" +#elif defined(OPENSSL_LINUX) && defined(__s390__) +# include "./archs/linux32-s390x/no-asm/include/openssl/x509v3.h" +#else +# include "./archs/linux-elf/no-asm/include/openssl/x509v3.h" +#endif + +/* GOST is not included in all platform */ +#ifndef OPENSSL_NO_GOST +# define OPENSSL_NO_GOST +#endif +/* HW_PADLOCK is not included in all platform */ +#ifndef OPENSSL_NO_HW_PADLOCK +# define OPENSSL_NO_HW_PADLOCK +#endif diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/uv/android-ifaddrs.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/uv/android-ifaddrs.h index 9cd19fec12..908b84349a 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/uv/android-ifaddrs.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/uv/android-ifaddrs.h @@ -26,23 +26,7 @@ #ifndef _IFADDRS_H_ #define _IFADDRS_H_ -struct ifaddrs { - struct ifaddrs *ifa_next; - char *ifa_name; - unsigned int ifa_flags; - struct sockaddr *ifa_addr; - struct sockaddr *ifa_netmask; - struct sockaddr *ifa_dstaddr; - void *ifa_data; -}; - -/* - * This may have been defined in . Note that if is - * to be included it must be included before this header file. - */ -#ifndef ifa_broadaddr -#define ifa_broadaddr ifa_dstaddr /* broadcast address interface */ -#endif +#include #include diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/uv/unix.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/uv/unix.h index e05f60840c..ea37d78768 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/uv/unix.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/uv/unix.h @@ -43,7 +43,7 @@ #include #include -#include "threadpool.h" +#include "uv/threadpool.h" #if defined(__linux__) # include "uv/linux.h" @@ -56,7 +56,7 @@ #elif defined(__sun) # include "uv/sunos.h" #elif defined(__APPLE__) -# include "darwin.h" +# include "uv/darwin.h" #elif defined(__DragonFly__) || \ defined(__FreeBSD__) || \ defined(__FreeBSD_kernel__) || \ diff --git a/packages/mobile/ios/NodeJsMobile/libnode/include/node/v8-version.h b/packages/mobile/ios/NodeJsMobile/libnode/include/node/v8-version.h index a4ef2015e0..7f77900fb9 100644 --- a/packages/mobile/ios/NodeJsMobile/libnode/include/node/v8-version.h +++ b/packages/mobile/ios/NodeJsMobile/libnode/include/node/v8-version.h @@ -11,7 +11,7 @@ #define V8_MAJOR_VERSION 9 #define V8_MINOR_VERSION 4 #define V8_BUILD_NUMBER 146 -#define V8_PATCH_LEVEL 24 +#define V8_PATCH_LEVEL 26 // Use 1 for candidates and 0 otherwise. // (Boolean macro values are not supported by all preprocessors.) diff --git a/packages/mobile/ios/Podfile.lock b/packages/mobile/ios/Podfile.lock index 2f5679cf97..ec0ed03b2c 100644 --- a/packages/mobile/ios/Podfile.lock +++ b/packages/mobile/ios/Podfile.lock @@ -339,6 +339,8 @@ PODS: - React-jsi (= 0.71.6) - React-logger (= 0.71.6) - React-perflogger (= 0.71.6) + - RNCAsyncStorage (1.18.1): + - React-Core - RNCClipboard (1.11.2): - React-Core - RNCPushNotificationIOS (1.10.1): @@ -420,6 +422,7 @@ DEPENDENCIES: - React-RCTVibration (from `../node_modules/react-native/Libraries/Vibration`) - React-runtimeexecutor (from `../node_modules/react-native/ReactCommon/runtimeexecutor`) - ReactCommon/turbomodule/core (from `../node_modules/react-native/ReactCommon`) + - "RNCAsyncStorage (from `../node_modules/@react-native-async-storage/async-storage`)" - "RNCClipboard (from `../node_modules/@react-native-clipboard/clipboard`)" - "RNCPushNotificationIOS (from `../node_modules/@react-native-community/push-notification-ios`)" - RNDeviceInfo (from `../node_modules/react-native-device-info`) @@ -517,6 +520,8 @@ EXTERNAL SOURCES: :path: "../node_modules/react-native/ReactCommon/runtimeexecutor" ReactCommon: :path: "../node_modules/react-native/ReactCommon" + RNCAsyncStorage: + :path: "../node_modules/@react-native-async-storage/async-storage" RNCClipboard: :path: "../node_modules/@react-native-clipboard/clipboard" RNCPushNotificationIOS: @@ -584,6 +589,7 @@ SPEC CHECKSUMS: React-RCTVibration: 73d201599a64ea14b4e0b8f91b64970979fd92e6 React-runtimeexecutor: 8692ac548bec648fa121980ccb4304afd136d584 ReactCommon: e1067159764444e5db7c14e294d5cd79fb159c59 + RNCAsyncStorage: b90b71f45b8b97be43bc4284e71a6af48ac9f547 RNCClipboard: 3f0451a8100393908bea5c5c5b16f96d45f30bfc RNCPushNotificationIOS: 87b8d16d3ede4532745e05b03c42cff33a36cc45 RNDeviceInfo: aad3c663b25752a52bf8fce93f2354001dd185aa diff --git a/packages/mobile/ios/classic-level.framework/classic-level b/packages/mobile/ios/classic-level.framework/classic-level index c3eaa0f2a6..2c4190371c 100755 Binary files a/packages/mobile/ios/classic-level.framework/classic-level and b/packages/mobile/ios/classic-level.framework/classic-level differ diff --git a/packages/mobile/nodejs-assets/deps/ios/arm64/classic-level/classic_level.node b/packages/mobile/nodejs-assets/deps/ios/universal/classic-level/classic_level.node similarity index 100% rename from packages/mobile/nodejs-assets/deps/ios/arm64/classic-level/classic_level.node rename to packages/mobile/nodejs-assets/deps/ios/universal/classic-level/classic_level.node